//****************************************************************************
// Copyright (c) 2005, Coveo Solutions Inc.
//****************************************************************************

//****************************************************************************
// Shortcut for document.getElementById(...).
//****************************************************************************
function G(p_Id)
{
    return document.getElementById(p_Id);
}

//****************************************************************************
// Returns whether the current browser is Internet Explorer.
//****************************************************************************
function CNL_IsIE()
{
    return navigator.userAgent.indexOf('MSIE') != -1;
}

//****************************************************************************
// Returns whether the current browser is Internet Explorer 6.
//****************************************************************************
function CNL_IsIE6() {
    return navigator.userAgent.indexOf('MSIE 6.0') != -1;
}

//****************************************************************************
// Returns whether the browser is in standard mode.
//****************************************************************************
function CNL_IsStandard()
{
    // I tested those with IE, FireFox and Opera.
    return document.compatMode != 'BackCompat' && document.compatMode != 'QuirksMode';
}

//****************************************************************************
// Adds an event handler to an object.
// p_Target  - The object tag fires the event.
// p_Event   - The name of the event.
// p_Handler - The event handler to register.
//****************************************************************************
function CNL_WireEvent(p_Target, p_Event, p_Handler)
{
    if (CNL_IsIE()) {
        p_Target.attachEvent(p_Event, p_Handler);
    } else {
        // addEventLister takes an event type that is usually the name of the
        // event with the 'on' at the start removed.
        if (p_Event.substring(0, 2) != 'on') {
            throw "Unknown event type: " + p_Event;
        }
        var name = p_Event.substring(2, p_Event.length);
        p_Target.addEventListener(name, p_Handler, false);
    }
}

//****************************************************************************
// Stops the propagation of an event.
// p_Event - The event whose propagation to stop.
//****************************************************************************
function CNL_StopPropagation(p_Event)
{
    if (CNL_IsIE()) {
        p_Event.cancelBubble = true;
    } else {
        p_Event.stopPropagation();
    }
}

//****************************************************************************
// Cancels an event (prevents it from bubbling up, and disable the default action).
// p_Event - The event to cancel.
//****************************************************************************
function CNL_CancelEvent(p_Event)
{
    if (CNL_IsIE()) {
        p_Event.cancelBubble = true;
        p_Event.returnValue = false;
    } else {
        p_Event.stopPropagation();
        p_Event.preventDefault();
    }
}

//****************************************************************************
// Returns a new  XMLHttpRequest object.
//****************************************************************************
function CNL_CreateXmlHttpRequest()
{
    var req;
    if (CNL_IsIE()) {
        req = new ActiveXObject("Microsoft.XMLHTTP");
    } else {
        req = new XMLHttpRequest();
    }

    return req;
}

//****************************************************************************
// Parses a string as xml and returns the xml dom object.
// p_Xml - The xml to parse.
// Returns the DOM object.
//****************************************************************************
function CNL_ParseStringAsXml(p_Xml)
{
    var dom;
    if (CNL_IsIE()) {
        dom = new ActiveXObject("Microsoft.XMLDOM");
        dom.loadXML(p_Xml);
    } else {
        var parser = new DOMParser();
        dom = parser.parseFromString(p_Xml, 'text/xml');
    }

    return dom;
}

//****************************************************************************
// Performs a SelectNodes in a cross-browser compatible way.
// p_Node  - The node on which to perform the operation.
// p_XPath - The xpath expression to use.
// Returns the matching nodes.
//****************************************************************************
function CNL_SelectNodes(p_Node, p_XPath)
{
    var nodes;
    if (CNL_IsIE()) {
        nodes = p_Node.selectNodes(p_XPath);
    } else {
        var doc = p_Node.ownerDocument ? p_Node.ownerDocument : p_Node;
        var resolver = doc.createNSResolver(doc);
        var results = doc.evaluate(p_XPath, p_Node, resolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        nodes = new Array();
        for (var i = 0; i < results.snapshotLength; ++i) {
            nodes.push(results.snapshotItem(i));
        }
    }

    return nodes;
}

//****************************************************************************
// Performs a SelectSingleNode in a cross-browser compatible way.
// p_Node  - The node on which to perform the operation.
// p_XPath - The xpath expression to use.
// Returns the first matching node, if any, and null otherwise.
//****************************************************************************
function CNL_SelectSingleNode(p_Node, p_XPath)
{
    var node;
    if (CNL_IsIE()) {
        node = p_Node.selectSingleNode(p_XPath);
    } else {
        var nodes = CNL_SelectNodes(p_Node, p_XPath);
        node = nodes.length != 0 ? nodes[0] : null;
    }

    return node;
}

//****************************************************************************
// Returns the text content of an xml node.
//****************************************************************************
function CNL_GetTextContent(p_Node)
{
    return CNL_IsIE() ? p_Node.text : p_Node.textContent;
}

//****************************************************************************
// Converts an RGB value to a color string.
// p_Red   - The Red component.
// p_Green - The Green component.
// p_Blue  - The Blue component.
// Returns The color as a string (in the #xxxxxx format).
//****************************************************************************
function CNL_RGBToString(p_Red, p_Green, p_Blue)
{
    var r = p_Red.toString(16);
    if (r.length == 1) {
        r = '0' + r;
    }
    var g = p_Green.toString(16);
    if (g.length == 1) {
        g = '0' + g;
    }
    var b = p_Blue.toString(16);
    if (b.length == 1) {
        b = '0' + b;
    }

    return ('#' + r + g + b).toUpperCase();
}

//****************************************************************************
// Sets the absolute position of an object, relative to the document.
// p_Object - The object whose position should be set.
// p_X      - The X offset from the left of the document.
// p_Y      - The Y offset from the top of the document.
//****************************************************************************
function CNL_SetPosition(p_Object, p_X, p_Y)
{
    p_Object.style.left = p_X + 'px';
    p_Object.style.top = p_Y + 'px';
}

//****************************************************************************
// Retrieves the absolute position of an HTML object (in pixels) from the top of the document.
// p_Object - The object whose position to retrieve.
// Returns an object that contains the information.
//****************************************************************************
function CNL_GetPosition(p_Object)
{
    var pos = new Object();
    pos.m_Left = 0;
    pos.m_Top = 0;

    var obj = p_Object;
    while (obj != null) {
        pos.m_Left += obj.offsetLeft - obj.scrollLeft;
        pos.m_Top += obj.offsetTop - obj.scrollTop;
        obj = obj.offsetParent;
    }

    return pos;
}

//****************************************************************************
// Retrieves the size of an HTML object (in pixels).
// p_Object - The object whose size to retrieve.
// Returns An object that contains the information.
//****************************************************************************
function CNL_GetSize(p_Object)
{
    var size = new Object();
    size.m_Width = p_Object.offsetWidth;
    size.m_Height = p_Object.offsetHeight;
  
    return size;
}

//****************************************************************************
// Sets the size of an object.
// p_Object - The object whose size should be set.
// p_Width  - The width to set.
// p_Height - The height to set.
//****************************************************************************
function CNL_SetSize(p_Object, p_Width, p_Height)
{
    p_Object.style.width = p_Width + 'px';
    p_Object.style.height = p_Height + 'px';
}

//****************************************************************************
// Retrieves the bounding rectangle of an HTML object (in pixels).
// p_Object - The object whose bounding rectangle to retrieve.
// Returns An object that contains the information.
//****************************************************************************
function CNL_GetBoundingRectangle(p_Object)
{
    var pos = CNL_GetPosition(p_Object);
    var size = CNL_GetSize(p_Object);
    var rect = new Object();
    rect.m_Left = pos.m_Left;
    rect.m_Top = pos.m_Top;
    rect.m_Right = pos.m_Left + size.m_Width;
    rect.m_Bottom = pos.m_Top + size.m_Height;
  
    return rect;
}

//****************************************************************************
// Retrieves the bounding of the region that is visible in the window (in pixels).
// Returns An object that contains the information.
//****************************************************************************
function CNL_GetVisibleRectangle()
{
    var rect = new Object();
    if (CNL_IsStandard()) {
        rect.m_Left = document.documentElement.scrollLeft;
        rect.m_Top = document.documentElement.scrollTop;
        rect.m_Right = rect.m_Left + document.documentElement.clientWidth;
        rect.m_Bottom = rect.m_Top + document.documentElement.clientHeight;
    } else {
        rect.m_Left = document.body.scrollLeft;
        rect.m_Top = document.body.scrollTop;
        rect.m_Right = rect.m_Left + document.body.clientWidth;
        rect.m_Bottom = rect.m_Top + document.body.clientHeight;
    }

    rect.m_Width = rect.m_Right - rect.m_Left;
    rect.m_Height = rect.m_Bottom - rect.m_Top;
  
    return rect;
}

//****************************************************************************
// Checks if a point is within a rectangle.
// p_X - The X coordinate.
// p_Y - The Y coordinate.
// p_Rect - The rectangle.
// Returns Whether the point is within the rectangle.
//****************************************************************************
function CNL_IsWithin(p_X, p_Y, p_Rect)
{
    return p_X >= p_Rect.m_Left && p_X < p_Rect.m_Right &&
           p_Y >= p_Rect.m_Top && p_Y < p_Rect.m_Bottom; 
}

//****************************************************************************
// Checks if a rectangle is within another rectangle.
// p_Inside  - The rectangle that should be inside.
// p_Outside - The rectangle that should contain p_Inside.
// Returns Whether the first rectangle is within the second one.
//****************************************************************************
function CNL_IsRectangleWithin(p_Inside, p_Outside)
{
    return CNL_IsWithin(p_Inside.m_Left, p_Inside.m_Top, p_Outside) &&
           CNL_IsWithin(p_Inside.m_Right, p_Inside.m_Top, p_Outside) &&
           CNL_IsWithin(p_Inside.m_Left, p_Inside.m_Bottom, p_Outside) &&
           CNL_IsWithin(p_Inside.m_Right, p_Inside.m_Bottom, p_Outside);
}

//****************************************************************************
// Checks if two rectangles overlap.
// p_Rect1 - The first rectangle.
// p_Rect2 - The second rectangle.
// Returns Whether the two rectangles overlap.
//****************************************************************************
function CNL_IsOverlap(p_Rect1, p_Rect2)
{
    // Look for an horizontal overlap
    var horiz = (p_Rect1.m_Left >= p_Rect2.m_Left &&
                 p_Rect1.m_Left < p_Rect2.m_Right) ||
                (p_Rect1.m_Right > p_Rect2.m_Left &&
                 p_Rect1.m_Right < p_Rect2.m_Right) ||
                (p_Rect2.m_Left >= p_Rect1.m_Left &&
                 p_Rect2.m_Left < p_Rect1.m_Right) ||
                (p_Rect2.m_Right > p_Rect1.m_Left &&
                 p_Rect2.m_Right < p_Rect1.m_Right);

    // Look for a vertical overlap
    var vert = (p_Rect1.m_Top >= p_Rect2.m_Top &&
                p_Rect1.m_Top < p_Rect2.m_Bottom) ||
               (p_Rect1.m_Bottom > p_Rect2.m_Top &&
                p_Rect1.m_Bottom < p_Rect2.m_Bottom) ||
               (p_Rect2.m_Top >= p_Rect1.m_Top &&
                p_Rect2.m_Top < p_Rect1.m_Bottom) ||
               (p_Rect2.m_Bottom > p_Rect1.m_Top &&
                p_Rect2.m_Bottom < p_Rect1.m_Bottom);

    return horiz && vert;
}

//****************************************************************************
// Positions an object relative to another.
// p_Object - The object to position.
// p_Reference - The object to position relatively to.
// p_Position - Where to place the object from the other.
//****************************************************************************
function CNL_PositionObject(p_Object, p_Reference, p_Position)
{
    // Determine the default major and minor positions
    var position1;
    var position2;
    if (p_Position == 'LeftBelow') {
        position1 = 'Left';
        position2 = 'Below';
    } else if (p_Position == 'LeftAbove') {
        position1 = 'Left';
        position2 = 'Above';
    } else if (p_Position == 'AboveLeft') {
        position1 = 'Above';
        position2 = 'Left';
    } else if (p_Position == 'AboveRight') {
        position1 = 'Above';
        position2 = 'Right';
    } else if (p_Position == 'RightBelow') {
        position1 = 'Right';
        position2 = 'Below';
    } else if (p_Position == 'RightAbove') {
        position1 = 'Right';
        position2 = 'Above';
    } else if (p_Position == 'BelowLeft') {
        position1 = 'Below';
        position2 = 'Left';
    } else if (p_Position == 'BelowRight') {
        position1 = 'Below';
        position2 = 'Right';
    } else {
        throw 'Invalid value for p_Position';
    }
    
    var left;
    var top;
    var done = false;
    var attempts = 0;
    var osize = CNL_GetSize(p_Object);
    var rrect = CNL_GetBoundingRectangle(p_Reference);
    var vrect = CNL_GetVisibleRectangle();

    // Try 3 times to position the object. Globally speaking, when first iteration
    // fails, the invert position on all bad levels will be tried. If this position
    // is bad too, we want to allow another iteration to revert positions to the
    // initial ones (which are better when everything is bad).
    while (!done && attempts < 3) {
        // Position the object using the two indicators
        if (position1 == 'Left') {
            left = rrect.m_Left - osize.m_Width;
        } else if (position1 == 'Right') {
            left = rrect.m_Right - 1;
        } else if (position1 == 'Above') {
            top = rrect.m_Top - osize.m_Height;
        } else if (position1 == 'Below') {
            top = rrect.m_Bottom - 1;
        }
        if (position2 == 'Left') {
            left = rrect.m_Left;
        } else if (position2 == 'Right') {
            left = rrect.m_Right - osize.m_Width;
        } else if (position2 == 'Above') {
            top = rrect.m_Bottom - osize.m_Height;
        } else if (position2 == 'Below') {
            top = rrect.m_Top;
        }

        // Invert major and/or minor positions when needed
        done = true;
        var right = left + osize.m_Width;
        var bottom = top + osize.m_Height;
        if (left < vrect.m_Left || right >= vrect.m_Right) {
            if (position1 == 'Left') {
                position1 = 'Right';
            } else if (position1 == 'Right') {
                position1 = 'Left'
            } else if (position2 == 'Left') {
                position2 = 'Right'
            } else if (position2 == 'Right') {
                position2 = 'Left'
            }
            done = false;
        }
        if (top < vrect.m_Top || bottom >= vrect.m_Bottom) {
            if (position1 == 'Above') {
                position1 = 'Below';
            } else if (position1 == 'Below') {
                position1 = 'Above'
            } else if (position2 == 'Above') {
                position2 = 'Below'
            } else if (position2 == 'Below') {
                position2 = 'Above'
            }
            done = false;
        }
        
        ++attempts;
    }

    CNL_SetPosition(p_Object, left, top);
}

//****************************************************************************
// Fits the width of an element to the client width of it's parent.
// p_Element - The element whose width to set.
// Works only under IE!
//****************************************************************************
function CNL_FitToParentWidth(p_Element)
{
    var borderWidth = parseInt(p_Element.currentStyle.borderLeftWidth) + parseInt(p_Element.currentStyle.borderRightWidth);
    var paddingWidth = parseInt(p_Element.currentStyle.paddingLeft) + parseInt(p_Element.currentStyle.paddingRight);
    var available = p_Element.parentElement.scrollWidth - parseInt(p_Element.parentElement.currentStyle.paddingLeft) - parseInt(p_Element.parentElement.currentStyle.paddingRight);
    p_Element.style.pixelWidth = available - borderWidth - paddingWidth;
}

//****************************************************************************
// Resizes an iframe to it's content.
// p_IFrame - The iframe to resize.
//****************************************************************************
function CNL_ResizeIFrame(p_IFrame)
{
    var width = p_IFrame.contentWindow.document.documentElement.scrollWidth;
    var height = p_IFrame.contentWindow.document.documentElement.scrollHeight;
    CNL_SetSize(p_IFrame, width, height);
}

//****************************************************************************
// Sets the opacity of an object.
// p_Object  - The object whose opacity should be set.
// p_Opacity - The opacity to set (from 0 to 1).
//****************************************************************************
function CNL_SetOpacity(p_Object, p_Opacity)
{
    if (p_Opacity != 1) {
        if (CNL_IsIE()) {
            p_Object.style.filter = 'alpha(opacity=' + p_Opacity * 100 + ')'; 
        } else {
            p_Object.style.opacity = p_Opacity;
        }
    } else {
        if (CNL_IsIE()) {
            p_Object.style.filter = ''; 
        } else {
            p_Object.style.opacity = '';
        }
    }
}

//****************************************************************************
// Retrieves the position of a mouse click relative to an object.
// p_Event     - The event object.
// p_Reference - The reference element to use to size the iframe.
//****************************************************************************
function CNL_GetMouseClickPosition(p_Event, p_Reference)
{
    var rpos = CNL_GetPosition(p_Reference);

    // First compute the click offset from the page
    var px, py;
    if (CNL_IsIE()) {
        // IE provides the offset from the clicked object.
        var tpos = CNL_GetPosition(p_Event.srcElement);
        px = tpos.m_Left + p_Event.offsetX;
        py = tpos.m_Top + p_Event.offsetY;
    } else {
        // FireFox provides the offset from the page
        px = p_Event.pageX;
        py = p_Event.pageY;
    }

    // Then compute the offset from the reference
    var rpos = CNL_GetPosition(p_Reference);
    var pos = new Object();
    pos.m_Left = px - rpos.m_Left;
    pos.m_Top = py - rpos.m_Top;

    return pos;
}

//****************************************************************************
// Sets the selected range of characters in a textbox.
// p_TextBox - The textbox.
// p_First   - Index of the first character.
// p_Last    - Index of the character after the last one.
//****************************************************************************
function CNL_SetSelectedRange(p_TextBox, p_First, p_Last)
{
    if (CNL_IsIE()) {
        var range = p_TextBox.createTextRange();
        range.moveStart('character', p_First);
        range.moveEnd('character', p_Last - p_TextBox.value.length);
        range.select();
    } else {
        p_TextBox.setSelectionRange(p_First, p_Last);
    }
}

//****************************************************************************
// Copyright (c) 2006, Coveo Solutions Inc.
//****************************************************************************

// This file defines augments the prototypes of various objects with useful
// functions and also tries to make browsers a little more homogenous.

//****************************************************************************
// Trims the content of a string.
// Returns the trimmed string.
//****************************************************************************
String.prototype.trim = function()
{
    return this.replace(/^[\s\xA0]+/, "").replace(/[\s\xA0]+$/, "");
}

if (!CNL_IsIE()) {
    //************************************************************************
    // Gets/sets the text inside a tag.
    //************************************************************************
    HTMLElement.prototype.__defineGetter__("innerText", function()
    {
        return this.textContent;
    });
    HTMLElement.prototype.__defineSetter__("innerText", function(p_Text) 
    {
        this.textContent = p_Text;
    });
}

//****************************************************************************
// Copyright (c) 2005, Coveo Solutions Inc.
//****************************************************************************

function CNL_BaseDropDown() {

//****************************************************************************
// Hints the control that the dropdown may soon be shown, and that any preparation
// code that must be executed prior to it may begin to execute.
//****************************************************************************
this.HintDropDownPrepare = function()
{
    if (this.m_PrepareCode != '' && !this.m_Ready && !this.m_Preparing) {
        this.m_Preparing = true;
        eval(this.m_PrepareCode);
    }
}

//****************************************************************************
// Indicates that the dropdown is ready to be shown.
//****************************************************************************
this.DropDownIsReady = function()
{
    this.m_Preparing = false;
    this.m_Ready = true;

    // If we're supposed to be visible but that we aren't, show the dropdown now.
    if (this.m_Show && !this.IsDropDownVisible()) {
        this._DisplayDropDown();
    }
}

//****************************************************************************
// Shows the dropdown box. 
//****************************************************************************
this.ShowDropDown = function()
{
    this.m_Show = true;

    // If the dropdown is async and that it isn't ready, the DropIsReady method
    // will automatically show it when it is called. Otherwise, show it now.
    if (this.m_PrepareCode != '') {
        if (this.m_Ready) {
            this._DisplayDropDown();
        } else if (!this.m_Preparing) {
            this.HintDropDownPrepare();
        }
    } else {
        this._DisplayDropDown();
    }
}

//****************************************************************************
// Hides the dropdown box.
//****************************************************************************
this.HideDropDown = function()
{
    document.getElementById(this.m_DropDownId).style.display = 'none';
    this.m_Show = false;
}

//****************************************************************************
// Returns whether the dropdown should be visible or not.
//****************************************************************************
this.IsDropDownVisible = function()
{
    return this.m_Show;
}

//****************************************************************************
// Really shows the dropdown, when it is ready.
//****************************************************************************
this._DisplayDropDown = function()
{
    var dropDown = document.getElementById(this.m_DropDownId);
    dropDown.style.display = '';
    var size = CNL_GetSize(dropDown);
    if (size.m_Width > 5 && size.m_Height > 5) {
        CNL_PositionObject(dropDown, this, this.m_Position);
    } else {
        dropDown.style.display = 'none';
    }
}

} // Constructor

//****************************************************************************
// Copyright (c) 2005, Coveo Solutions Inc.
//****************************************************************************

function CNL_CustomDropDown() {

var m_IsMouseOver = false;

//****************************************************************************
// Event handler for the onmouseover event of the dropdown.
//****************************************************************************
this.OnMouseOver = function()
{
    if (!this.m_IsMouseOver) {
        if (!this.IsDropDownVisible()) {
            if (Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current() != null) {
                Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().blockTimer();
            }
        }

        if (this.m_BorderOnHover) {
            this.style.borderColor = this.m_BorderColor;
        }
        if (this.m_ArrowOnHover) {
            document.getElementById(this.m_ArrowId).style.visibility = 'visible';
        }
    }
    
    this.m_IsMouseOver = true;
}

//****************************************************************************
// Event handler for the onmouseoout event of the dropdown.
//****************************************************************************
this.OnMouseOut = function()
{
    if (this.m_IsMouseOver) {
        this.m_IsMouseOver = false;
        this.OnMouseOutBehaviour();
    }
}

//****************************************************************************
// Behaviour of the OnMouseOut event of the dropdown.
// It is extracted from the event handler because the method
// HideAndRestoreHandler use it.
//****************************************************************************
this.OnMouseOutBehaviour = function()
{
    if ((!this.m_IsMouseOver) && (!this.IsDropDownVisible())) {
        if (document.getElementById(this.m_DropDownId).style.visibility != 'visible') {
            if (this.m_BorderOnHover) {
                this.style.borderColor = this.m_BackColor;
            }
            if (this.m_ArrowOnHover) {
                document.getElementById(this.m_ArrowId).style.visibility = 'hidden';
            }
        }

        if (Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current() != null) {
            Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().unblockTimer();
        }
    }
}

//****************************************************************************
// Event handler for the onclick event of the dropdown button.
//****************************************************************************
this.Arrow_OnClick = function(p_Event)
{
    if (!this.IsDropDownVisible()) {
        var size = CNL_GetSize(this);
        CNL_SetSize(document.getElementById(this.m_DropDownId), size.m_Width, size.m_Height);
        this.ShowDropDown();

        // Fire any old handler, so that any other dropdown on the page may
        // properly close itself before this one opens.
        if (document.onclick) {
            document.onclick(p_Event);
        }

        this.m_OldClickHandler = document.onclick;
        this.m_OldKeyPressHandler = document.onkeypress;
        var myself = this;
        if (CNL_IsIE()) {
            document.onclick = function() { myself.Document_OnClick(event); };
            document.onkeypress = function() { myself.Document_OnKeyPress(event); };
        } else {
            document.onclick = function(event) { myself.Document_OnClick(event); };
            document.onkeydown = function(event) { myself.Document_OnKeyPress(event); };
        }

    } else {
        this.HideAndRestoreHandler();
    }

    CNL_StopPropagation(p_Event);
}

//****************************************************************************
// Event handler for the onclick event of the document.
//****************************************************************************
this.Document_OnClick = function(p_Event)
{
    if (this.m_HideOnClick || !CNL_IsWithin(p_Event.clientX, p_Event.clientY, CNL_GetBoundingRectangle(document.getElementById(this.m_DropDownId)))) {
        this.HideAndRestoreHandler();
    }
}

//****************************************************************************
// Event handler for the onkeypress event.
//****************************************************************************
this.Document_OnKeyPress = function(p_Event)
{
    if (CNL_IsIE()) {
        if (p_Event.keyCode == 27) {
          this.HideAndRestoreHandler();
        }
    } else {
        if (p_Event.which == 27) {
          this.HideAndRestoreHandler();
        }
    }
}

//****************************************************************************
// Hides the dropdown and restore the old event handler.
//****************************************************************************
this.HideAndRestoreHandler = function()
{
    if (this.IsDropDownVisible()) {
        this.HideDropDown();
        document.onclick = this.m_OldClickHandler;
        if (CNL_IsIE()) {
            document.onkeypress = this.m_OldKeyPressHandler;
        } else {
            document.onkeydown = this.m_OldKeyPressHandler;
        }
        this.OnMouseOutBehaviour();
    }
}

} // Constructor

/*!
 * jQuery JavaScript Library v1.5.1
 * http://jquery.com/
 *
 * Copyright 2011, John Resig
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * Includes Sizzle.js
 * http://sizzlejs.com/
 * Copyright 2011, The Dojo Foundation
 * Released under the MIT, BSD, and GPL Licenses.
 *
 * Date: Wed Feb 23 13:55:29 2011 -0500
 */
(function( window, undefined ) {

// Use the correct document accordingly with window argument (sandbox)
var document = window.document;
var jQuery = (function() {

// Define a local copy of jQuery
var jQuery = function( selector, context ) {
		// The jQuery object is actually just the init constructor 'enhanced'
		return new jQuery.fn.init( selector, context, rootjQuery );
	},

	// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,

	// Map over the $ in case of overwrite
	_$ = window.$,

	// A central reference to the root jQuery(document)
	rootjQuery,

	// A simple way to check for HTML strings or ID strings
	// (both of which we optimize for)
	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,

	// Check if a string has a non-whitespace character in it
	rnotwhite = /\S/,

	// Used for trimming whitespace
	trimLeft = /^\s+/,
	trimRight = /\s+$/,

	// Check for digits
	rdigit = /\d/,

	// Match a standalone tag
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,

	// JSON RegExp
	rvalidchars = /^[\],:{}\s]*$/,
	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

	// Useragent RegExp
	rwebkit = /(webkit)[ \/]([\w.]+)/,
	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
	rmsie = /(msie) ([\w.]+)/,
	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,

	// Keep a UserAgent string for use with jQuery.browser
	userAgent = navigator.userAgent,

	// For matching the engine and version of the browser
	browserMatch,

	// Has the ready events already been bound?
	readyBound = false,

	// The deferred used on DOM ready
	readyList,

	// Promise methods
	promiseMethods = "then done fail isResolved isRejected promise".split( " " ),

	// The ready event handler
	DOMContentLoaded,

	// Save a reference to some core methods
	toString = Object.prototype.toString,
	hasOwn = Object.prototype.hasOwnProperty,
	push = Array.prototype.push,
	slice = Array.prototype.slice,
	trim = String.prototype.trim,
	indexOf = Array.prototype.indexOf,

	// [[Class]] -> type pairs
	class2type = {};

jQuery.fn = jQuery.prototype = {
	constructor: jQuery,
	init: function( selector, context, rootjQuery ) {
		var match, elem, ret, doc;

		// Handle $(""), $(null), or $(undefined)
		if ( !selector ) {
			return this;
		}

		// Handle $(DOMElement)
		if ( selector.nodeType ) {
			this.context = this[0] = selector;
			this.length = 1;
			return this;
		}

		// The body element only exists once, optimize finding it
		if ( selector === "body" && !context && document.body ) {
			this.context = document;
			this[0] = document.body;
			this.selector = "body";
			this.length = 1;
			return this;
		}

		// Handle HTML strings
		if ( typeof selector === "string" ) {
			// Are we dealing with HTML string or an ID?
			match = quickExpr.exec( selector );

			// Verify a match, and that no context was specified for #id
			if ( match && (match[1] || !context) ) {

				// HANDLE: $(html) -> $(array)
				if ( match[1] ) {
					context = context instanceof jQuery ? context[0] : context;
					doc = (context ? context.ownerDocument || context : document);

					// If a single string is passed in and it's a single tag
					// just do a createElement and skip the rest
					ret = rsingleTag.exec( selector );

					if ( ret ) {
						if ( jQuery.isPlainObject( context ) ) {
							selector = [ document.createElement( ret[1] ) ];
							jQuery.fn.attr.call( selector, context, true );

						} else {
							selector = [ doc.createElement( ret[1] ) ];
						}

					} else {
						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
					}

					return jQuery.merge( this, selector );

				// HANDLE: $("#id")
				} else {
					elem = document.getElementById( match[2] );

					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentNode ) {
						// Handle the case where IE and Opera return items
						// by name instead of ID
						if ( elem.id !== match[2] ) {
							return rootjQuery.find( selector );
						}

						// Otherwise, we inject the element directly into the jQuery object
						this.length = 1;
						this[0] = elem;
					}

					this.context = document;
					this.selector = selector;
					return this;
				}

			// HANDLE: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return (context || rootjQuery).find( selector );

			// HANDLE: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}

		// HANDLE: $(function)
		// Shortcut for document ready
		} else if ( jQuery.isFunction( selector ) ) {
			return rootjQuery.ready( selector );
		}

		if (selector.selector !== undefined) {
			this.selector = selector.selector;
			this.context = selector.context;
		}

		return jQuery.makeArray( selector, this );
	},

	// Start with an empty selector
	selector: "",

	// The current version of jQuery being used
	jquery: "1.5.1",

	// The default length of a jQuery object is 0
	length: 0,

	// The number of elements contained in the matched element set
	size: function() {
		return this.length;
	},

	toArray: function() {
		return slice.call( this, 0 );
	},

	// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get: function( num ) {
		return num == null ?

			// Return a 'clean' array
			this.toArray() :

			// Return just the object
			( num < 0 ? this[ this.length + num ] : this[ num ] );
	},

	// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems, name, selector ) {
		// Build a new jQuery matched element set
		var ret = this.constructor();

		if ( jQuery.isArray( elems ) ) {
			push.apply( ret, elems );

		} else {
			jQuery.merge( ret, elems );
		}

		// Add the old object onto the stack (as a reference)
		ret.prevObject = this;

		ret.context = this.context;

		if ( name === "find" ) {
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
		} else if ( name ) {
			ret.selector = this.selector + "." + name + "(" + selector + ")";
		}

		// Return the newly-formed element set
		return ret;
	},

	// Execute a callback for every element in the matched set.
	// (You can seed the arguments with an array of args, but this is
	// only used internally.)
	each: function( callback, args ) {
		return jQuery.each( this, callback, args );
	},

	ready: function( fn ) {
		// Attach the listeners
		jQuery.bindReady();

		// Add the callback
		readyList.done( fn );

		return this;
	},

	eq: function( i ) {
		return i === -1 ?
			this.slice( i ) :
			this.slice( i, +i + 1 );
	},

	first: function() {
		return this.eq( 0 );
	},

	last: function() {
		return this.eq( -1 );
	},

	slice: function() {
		return this.pushStack( slice.apply( this, arguments ),
			"slice", slice.call(arguments).join(",") );
	},

	map: function( callback ) {
		return this.pushStack( jQuery.map(this, function( elem, i ) {
			return callback.call( elem, i, elem );
		}));
	},

	end: function() {
		return this.prevObject || this.constructor(null);
	},

	// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: push,
	sort: [].sort,
	splice: [].splice
};

// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {
	var options, name, src, copy, copyIsArray, clone,
		target = arguments[0] || {},
		i = 1,
		length = arguments.length,
		deep = false;

	// Handle a deep copy situation
	if ( typeof target === "boolean" ) {
		deep = target;
		target = arguments[1] || {};
		// skip the boolean and the target
		i = 2;
	}

	// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
		target = {};
	}

	// extend jQuery itself if only one argument is passed
	if ( length === i ) {
		target = this;
		--i;
	}

	for ( ; i < length; i++ ) {
		// Only deal with non-null/undefined values
		if ( (options = arguments[ i ]) != null ) {
			// Extend the base object
			for ( name in options ) {
				src = target[ name ];
				copy = options[ name ];

				// Prevent never-ending loop
				if ( target === copy ) {
					continue;
				}

				// Recurse if we're merging plain objects or arrays
				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
					if ( copyIsArray ) {
						copyIsArray = false;
						clone = src && jQuery.isArray(src) ? src : [];

					} else {
						clone = src && jQuery.isPlainObject(src) ? src : {};
					}

					// Never move original objects, clone them
					target[ name ] = jQuery.extend( deep, clone, copy );

				// Don't bring in undefined values
				} else if ( copy !== undefined ) {
					target[ name ] = copy;
				}
			}
		}
	}

	// Return the modified object
	return target;
};

jQuery.extend({
	noConflict: function( deep ) {
		window.$ = _$;

		if ( deep ) {
			window.jQuery = _jQuery;
		}

		return jQuery;
	},

	// Is the DOM ready to be used? Set to true once it occurs.
	isReady: false,

	// A counter to track how many items to wait for before
	// the ready event fires. See #6781
	readyWait: 1,

	// Handle when the DOM is ready
	ready: function( wait ) {
		// A third-party is pushing the ready event forwards
		if ( wait === true ) {
			jQuery.readyWait--;
		}

		// Make sure that the DOM is not already loaded
		if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
			if ( !document.body ) {
				return setTimeout( jQuery.ready, 1 );
			}

			// Remember that the DOM is ready
			jQuery.isReady = true;

			// If a normal DOM Ready event fired, decrement, and wait if need be
			if ( wait !== true && --jQuery.readyWait > 0 ) {
				return;
			}

			// If there are functions bound, to execute
			readyList.resolveWith( document, [ jQuery ] );

			// Trigger any bound ready events
			if ( jQuery.fn.trigger ) {
				jQuery( document ).trigger( "ready" ).unbind( "ready" );
			}
		}
	},

	bindReady: function() {
		if ( readyBound ) {
			return;
		}

		readyBound = true;

		// Catch cases where $(document).ready() is called after the
		// browser event has already occurred.
		if ( document.readyState === "complete" ) {
			// Handle it asynchronously to allow scripts the opportunity to delay ready
			return setTimeout( jQuery.ready, 1 );
		}

		// Mozilla, Opera and webkit nightlies currently support this event
		if ( document.addEventListener ) {
			// Use the handy event callback
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

			// A fallback to window.onload, that will always work
			window.addEventListener( "load", jQuery.ready, false );

		// If IE event model is used
		} else if ( document.attachEvent ) {
			// ensure firing before onload,
			// maybe late but safe also for iframes
			document.attachEvent("onreadystatechange", DOMContentLoaded);

			// A fallback to window.onload, that will always work
			window.attachEvent( "onload", jQuery.ready );

			// If IE and not a frame
			// continually check to see if the document is ready
			var toplevel = false;

			try {
				toplevel = window.frameElement == null;
			} catch(e) {}

			if ( document.documentElement.doScroll && toplevel ) {
				doScrollCheck();
			}
		}
	},

	// See test/unit/core.js for details concerning isFunction.
	// Since version 1.3, DOM methods and functions like alert
	// aren't supported. They return false on IE (#2968).
	isFunction: function( obj ) {
		return jQuery.type(obj) === "function";
	},

	isArray: Array.isArray || function( obj ) {
		return jQuery.type(obj) === "array";
	},

	// A crude way of determining if an object is a window
	isWindow: function( obj ) {
		return obj && typeof obj === "object" && "setInterval" in obj;
	},

	isNaN: function( obj ) {
		return obj == null || !rdigit.test( obj ) || isNaN( obj );
	},

	type: function( obj ) {
		return obj == null ?
			String( obj ) :
			class2type[ toString.call(obj) ] || "object";
	},

	isPlainObject: function( obj ) {
		// Must be an Object.
		// Because of IE, we also have to check the presence of the constructor property.
		// Make sure that DOM nodes and window objects don't pass through, as well
		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
			return false;
		}

		// Not own constructor property must be Object
		if ( obj.constructor &&
			!hasOwn.call(obj, "constructor") &&
			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
			return false;
		}

		// Own properties are enumerated firstly, so to speed up,
		// if last one is own, then all properties are own.

		var key;
		for ( key in obj ) {}

		return key === undefined || hasOwn.call( obj, key );
	},

	isEmptyObject: function( obj ) {
		for ( var name in obj ) {
			return false;
		}
		return true;
	},

	error: function( msg ) {
		throw msg;
	},

	parseJSON: function( data ) {
		if ( typeof data !== "string" || !data ) {
			return null;
		}

		// Make sure leading/trailing whitespace is removed (IE can't handle it)
		data = jQuery.trim( data );

		// Make sure the incoming data is actual JSON
		// Logic borrowed from http://json.org/json2.js
		if ( rvalidchars.test(data.replace(rvalidescape, "@")
			.replace(rvalidtokens, "]")
			.replace(rvalidbraces, "")) ) {

			// Try to use the native JSON parser first
			return window.JSON && window.JSON.parse ?
				window.JSON.parse( data ) :
				(new Function("return " + data))();

		} else {
			jQuery.error( "Invalid JSON: " + data );
		}
	},

	// Cross-browser xml parsing
	// (xml & tmp used internally)
	parseXML: function( data , xml , tmp ) {

		if ( window.DOMParser ) { // Standard
			tmp = new DOMParser();
			xml = tmp.parseFromString( data , "text/xml" );
		} else { // IE
			xml = new ActiveXObject( "Microsoft.XMLDOM" );
			xml.async = "false";
			xml.loadXML( data );
		}

		tmp = xml.documentElement;

		if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
			jQuery.error( "Invalid XML: " + data );
		}

		return xml;
	},

	noop: function() {},

	// Evalulates a script in a global context
	globalEval: function( data ) {
		if ( data && rnotwhite.test(data) ) {
			// Inspired by code by Andrea Giammarchi
			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
			var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement,
				script = document.createElement( "script" );

			if ( jQuery.support.scriptEval() ) {
				script.appendChild( document.createTextNode( data ) );
			} else {
				script.text = data;
			}

			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
			// This arises when a base node is used (#2709).
			head.insertBefore( script, head.firstChild );
			head.removeChild( script );
		}
	},

	nodeName: function( elem, name ) {
		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
	},

	// args is for internal usage only
	each: function( object, callback, args ) {
		var name, i = 0,
			length = object.length,
			isObj = length === undefined || jQuery.isFunction(object);

		if ( args ) {
			if ( isObj ) {
				for ( name in object ) {
					if ( callback.apply( object[ name ], args ) === false ) {
						break;
					}
				}
			} else {
				for ( ; i < length; ) {
					if ( callback.apply( object[ i++ ], args ) === false ) {
						break;
					}
				}
			}

		// A special, fast, case for the most common use of each
		} else {
			if ( isObj ) {
				for ( name in object ) {
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
						break;
					}
				}
			} else {
				for ( var value = object[0];
					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
			}
		}

		return object;
	},

	// Use native String.trim function wherever possible
	trim: trim ?
		function( text ) {
			return text == null ?
				"" :
				trim.call( text );
		} :

		// Otherwise use our own trimming functionality
		function( text ) {
			return text == null ?
				"" :
				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
		},

	// results is for internal usage only
	makeArray: function( array, results ) {
		var ret = results || [];

		if ( array != null ) {
			// The window, strings (and functions) also have 'length'
			// The extra typeof function check is to prevent crashes
			// in Safari 2 (See: #3039)
			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
			var type = jQuery.type(array);

			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
				push.call( ret, array );
			} else {
				jQuery.merge( ret, array );
			}
		}

		return ret;
	},

	inArray: function( elem, array ) {
		if ( array.indexOf ) {
			return array.indexOf( elem );
		}

		for ( var i = 0, length = array.length; i < length; i++ ) {
			if ( array[ i ] === elem ) {
				return i;
			}
		}

		return -1;
	},

	merge: function( first, second ) {
		var i = first.length,
			j = 0;

		if ( typeof second.length === "number" ) {
			for ( var l = second.length; j < l; j++ ) {
				first[ i++ ] = second[ j ];
			}

		} else {
			while ( second[j] !== undefined ) {
				first[ i++ ] = second[ j++ ];
			}
		}

		first.length = i;

		return first;
	},

	grep: function( elems, callback, inv ) {
		var ret = [], retVal;
		inv = !!inv;

		// Go through the array, only saving the items
		// that pass the validator function
		for ( var i = 0, length = elems.length; i < length; i++ ) {
			retVal = !!callback( elems[ i ], i );
			if ( inv !== retVal ) {
				ret.push( elems[ i ] );
			}
		}

		return ret;
	},

	// arg is for internal usage only
	map: function( elems, callback, arg ) {
		var ret = [], value;

		// Go through the array, translating each of the items to their
		// new value (or values).
		for ( var i = 0, length = elems.length; i < length; i++ ) {
			value = callback( elems[ i ], i, arg );

			if ( value != null ) {
				ret[ ret.length ] = value;
			}
		}

		// Flatten any nested arrays
		return ret.concat.apply( [], ret );
	},

	// A global GUID counter for objects
	guid: 1,

	proxy: function( fn, proxy, thisObject ) {
		if ( arguments.length === 2 ) {
			if ( typeof proxy === "string" ) {
				thisObject = fn;
				fn = thisObject[ proxy ];
				proxy = undefined;

			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
				thisObject = proxy;
				proxy = undefined;
			}
		}

		if ( !proxy && fn ) {
			proxy = function() {
				return fn.apply( thisObject || this, arguments );
			};
		}

		// Set the guid of unique handler to the same of original handler, so it can be removed
		if ( fn ) {
			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
		}

		// So proxy can be declared as an argument
		return proxy;
	},

	// Mutifunctional method to get and set values to a collection
	// The value/s can be optionally by executed if its a function
	access: function( elems, key, value, exec, fn, pass ) {
		var length = elems.length;

		// Setting many attributes
		if ( typeof key === "object" ) {
			for ( var k in key ) {
				jQuery.access( elems, k, key[k], exec, fn, value );
			}
			return elems;
		}

		// Setting one attribute
		if ( value !== undefined ) {
			// Optionally, function values get executed if exec is true
			exec = !pass && exec && jQuery.isFunction(value);

			for ( var i = 0; i < length; i++ ) {
				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
			}

			return elems;
		}

		// Getting an attribute
		return length ? fn( elems[0], key ) : undefined;
	},

	now: function() {
		return (new Date()).getTime();
	},

	// Create a simple deferred (one callbacks list)
	_Deferred: function() {
		var // callbacks list
			callbacks = [],
			// stored [ context , args ]
			fired,
			// to avoid firing when already doing so
			firing,
			// flag to know if the deferred has been cancelled
			cancelled,
			// the deferred itself
			deferred  = {

				// done( f1, f2, ...)
				done: function() {
					if ( !cancelled ) {
						var args = arguments,
							i,
							length,
							elem,
							type,
							_fired;
						if ( fired ) {
							_fired = fired;
							fired = 0;
						}
						for ( i = 0, length = args.length; i < length; i++ ) {
							elem = args[ i ];
							type = jQuery.type( elem );
							if ( type === "array" ) {
								deferred.done.apply( deferred, elem );
							} else if ( type === "function" ) {
								callbacks.push( elem );
							}
						}
						if ( _fired ) {
							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
						}
					}
					return this;
				},

				// resolve with given context and args
				resolveWith: function( context, args ) {
					if ( !cancelled && !fired && !firing ) {
						firing = 1;
						try {
							while( callbacks[ 0 ] ) {
								callbacks.shift().apply( context, args );
							}
						}
						// We have to add a catch block for
						// IE prior to 8 or else the finally
						// block will never get executed
						catch (e) {
							throw e;
						}
						finally {
							fired = [ context, args ];
							firing = 0;
						}
					}
					return this;
				},

				// resolve with this as context and given arguments
				resolve: function() {
					deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
					return this;
				},

				// Has this deferred been resolved?
				isResolved: function() {
					return !!( firing || fired );
				},

				// Cancel
				cancel: function() {
					cancelled = 1;
					callbacks = [];
					return this;
				}
			};

		return deferred;
	},

	// Full fledged deferred (two callbacks list)
	Deferred: function( func ) {
		var deferred = jQuery._Deferred(),
			failDeferred = jQuery._Deferred(),
			promise;
		// Add errorDeferred methods, then and promise
		jQuery.extend( deferred, {
			then: function( doneCallbacks, failCallbacks ) {
				deferred.done( doneCallbacks ).fail( failCallbacks );
				return this;
			},
			fail: failDeferred.done,
			rejectWith: failDeferred.resolveWith,
			reject: failDeferred.resolve,
			isRejected: failDeferred.isResolved,
			// Get a promise for this deferred
			// If obj is provided, the promise aspect is added to the object
			promise: function( obj ) {
				if ( obj == null ) {
					if ( promise ) {
						return promise;
					}
					promise = obj = {};
				}
				var i = promiseMethods.length;
				while( i-- ) {
					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
				}
				return obj;
			}
		} );
		// Make sure only one callback list will be used
		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
		// Unexpose cancel
		delete deferred.cancel;
		// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}
		return deferred;
	},

	// Deferred helper
	when: function( object ) {
		var lastIndex = arguments.length,
			deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ?
				object :
				jQuery.Deferred(),
			promise = deferred.promise();

		if ( lastIndex > 1 ) {
			var array = slice.call( arguments, 0 ),
				count = lastIndex,
				iCallback = function( index ) {
					return function( value ) {
						array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
						if ( !( --count ) ) {
							deferred.resolveWith( promise, array );
						}
					};
				};
			while( ( lastIndex-- ) ) {
				object = array[ lastIndex ];
				if ( object && jQuery.isFunction( object.promise ) ) {
					object.promise().then( iCallback(lastIndex), deferred.reject );
				} else {
					--count;
				}
			}
			if ( !count ) {
				deferred.resolveWith( promise, array );
			}
		} else if ( deferred !== object ) {
			deferred.resolve( object );
		}
		return promise;
	},

	// Use of jQuery.browser is frowned upon.
	// More details: http://docs.jquery.com/Utilities/jQuery.browser
	uaMatch: function( ua ) {
		ua = ua.toLowerCase();

		var match = rwebkit.exec( ua ) ||
			ropera.exec( ua ) ||
			rmsie.exec( ua ) ||
			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
			[];

		return { browser: match[1] || "", version: match[2] || "0" };
	},

	sub: function() {
		function jQuerySubclass( selector, context ) {
			return new jQuerySubclass.fn.init( selector, context );
		}
		jQuery.extend( true, jQuerySubclass, this );
		jQuerySubclass.superclass = this;
		jQuerySubclass.fn = jQuerySubclass.prototype = this();
		jQuerySubclass.fn.constructor = jQuerySubclass;
		jQuerySubclass.subclass = this.subclass;
		jQuerySubclass.fn.init = function init( selector, context ) {
			if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
				context = jQuerySubclass(context);
			}

			return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
		};
		jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
		var rootjQuerySubclass = jQuerySubclass(document);
		return jQuerySubclass;
	},

	browser: {}
});

// Create readyList deferred
readyList = jQuery._Deferred();

// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
});

browserMatch = jQuery.uaMatch( userAgent );
if ( browserMatch.browser ) {
	jQuery.browser[ browserMatch.browser ] = true;
	jQuery.browser.version = browserMatch.version;
}

// Deprecated, use jQuery.browser.webkit instead
if ( jQuery.browser.webkit ) {
	jQuery.browser.safari = true;
}

if ( indexOf ) {
	jQuery.inArray = function( elem, array ) {
		return indexOf.call( array, elem );
	};
}

// IE doesn't match non-breaking spaces with \s
if ( rnotwhite.test( "\xA0" ) ) {
	trimLeft = /^[\s\xA0]+/;
	trimRight = /[\s\xA0]+$/;
}

// All jQuery objects should point back to these
rootjQuery = jQuery(document);

// Cleanup functions for the document ready method
if ( document.addEventListener ) {
	DOMContentLoaded = function() {
		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
		jQuery.ready();
	};

} else if ( document.attachEvent ) {
	DOMContentLoaded = function() {
		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
		if ( document.readyState === "complete" ) {
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
			jQuery.ready();
		}
	};
}

// The DOM ready check for Internet Explorer
function doScrollCheck() {
	if ( jQuery.isReady ) {
		return;
	}

	try {
		// If IE is used, use the trick by Diego Perini
		// http://javascript.nwbox.com/IEContentLoaded/
		document.documentElement.doScroll("left");
	} catch(e) {
		setTimeout( doScrollCheck, 1 );
		return;
	}

	// and execute any waiting functions
	jQuery.ready();
}

// Expose jQuery to the global object
return jQuery;

})();


(function() {

	jQuery.support = {};

	var div = document.createElement("div");

	div.style.display = "none";
	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";

	var all = div.getElementsByTagName("*"),
		a = div.getElementsByTagName("a")[0],
		select = document.createElement("select"),
		opt = select.appendChild( document.createElement("option") ),
		input = div.getElementsByTagName("input")[0];

	// Can't get basic test support
	if ( !all || !all.length || !a ) {
		return;
	}

	jQuery.support = {
		// IE strips leading whitespace when .innerHTML is used
		leadingWhitespace: div.firstChild.nodeType === 3,

		// Make sure that tbody elements aren't automatically inserted
		// IE will insert them into empty tables
		tbody: !div.getElementsByTagName("tbody").length,

		// Make sure that link elements get serialized correctly by innerHTML
		// This requires a wrapper element in IE
		htmlSerialize: !!div.getElementsByTagName("link").length,

		// Get the style information from getAttribute
		// (IE uses .cssText insted)
		style: /red/.test( a.getAttribute("style") ),

		// Make sure that URLs aren't manipulated
		// (IE normalizes it by default)
		hrefNormalized: a.getAttribute("href") === "/a",

		// Make sure that element opacity exists
		// (IE uses filter instead)
		// Use a regex to work around a WebKit issue. See #5145
		opacity: /^0.55$/.test( a.style.opacity ),

		// Verify style float existence
		// (IE uses styleFloat instead of cssFloat)
		cssFloat: !!a.style.cssFloat,

		// Make sure that if no value is specified for a checkbox
		// that it defaults to "on".
		// (WebKit defaults to "" instead)
		checkOn: input.value === "on",

		// Make sure that a selected-by-default option has a working selected property.
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
		optSelected: opt.selected,

		// Will be defined later
		deleteExpando: true,
		optDisabled: false,
		checkClone: false,
		noCloneEvent: true,
		noCloneChecked: true,
		boxModel: null,
		inlineBlockNeedsLayout: false,
		shrinkWrapBlocks: false,
		reliableHiddenOffsets: true
	};

	input.checked = true;
	jQuery.support.noCloneChecked = input.cloneNode( true ).checked;

	// Make sure that the options inside disabled selects aren't marked as disabled
	// (WebKit marks them as diabled)
	select.disabled = true;
	jQuery.support.optDisabled = !opt.disabled;

	var _scriptEval = null;
	jQuery.support.scriptEval = function() {
		if ( _scriptEval === null ) {
			var root = document.documentElement,
				script = document.createElement("script"),
				id = "script" + jQuery.now();

			try {
				script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
			} catch(e) {}

			root.insertBefore( script, root.firstChild );

			// Make sure that the execution of code works by injecting a script
			// tag with appendChild/createTextNode
			// (IE doesn't support this, fails, and uses .text instead)
			if ( window[ id ] ) {
				_scriptEval = true;
				delete window[ id ];
			} else {
				_scriptEval = false;
			}

			root.removeChild( script );
			// release memory in IE
			root = script = id  = null;
		}

		return _scriptEval;
	};

	// Test to see if it's possible to delete an expando from an element
	// Fails in Internet Explorer
	try {
		delete div.test;

	} catch(e) {
		jQuery.support.deleteExpando = false;
	}

	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
		div.attachEvent("onclick", function click() {
			// Cloning a node shouldn't copy over any
			// bound event handlers (IE does this)
			jQuery.support.noCloneEvent = false;
			div.detachEvent("onclick", click);
		});
		div.cloneNode(true).fireEvent("onclick");
	}

	div = document.createElement("div");
	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";

	var fragment = document.createDocumentFragment();
	fragment.appendChild( div.firstChild );

	// WebKit doesn't clone checked state correctly in fragments
	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;

	// Figure out if the W3C box model works as expected
	// document.body must exist before we can do this
	jQuery(function() {
		var div = document.createElement("div"),
			body = document.getElementsByTagName("body")[0];

		// Frameset documents with no body should not run this code
		if ( !body ) {
			return;
		}

		div.style.width = div.style.paddingLeft = "1px";
		body.appendChild( div );
		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;

		if ( "zoom" in div.style ) {
			// Check if natively block-level elements act like inline-block
			// elements when setting their display to 'inline' and giving
			// them layout
			// (IE < 8 does this)
			div.style.display = "inline";
			div.style.zoom = 1;
			jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;

			// Check if elements with layout shrink-wrap their children
			// (IE 6 does this)
			div.style.display = "";
			div.innerHTML = "<div style='width:4px;'></div>";
			jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
		}

		div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
		var tds = div.getElementsByTagName("td");

		// Check if table cells still have offsetWidth/Height when they are set
		// to display:none and there are still other visible table cells in a
		// table row; if so, offsetWidth/Height are not reliable for use when
		// determining if an element has been hidden directly using
		// display:none (it is still safe to use offsets if a parent element is
		// hidden; don safety goggles and see bug #4512 for more information).
		// (only IE 8 fails this test)
		jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;

		tds[0].style.display = "";
		tds[1].style.display = "none";

		// Check if empty table cells still have offsetWidth/Height
		// (IE < 8 fail this test)
		jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
		div.innerHTML = "";

		body.removeChild( div ).style.display = "none";
		div = tds = null;
	});

	// Technique from Juriy Zaytsev
	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
	var eventSupported = function( eventName ) {
		var el = document.createElement("div");
		eventName = "on" + eventName;

		// We only care about the case where non-standard event systems
		// are used, namely in IE. Short-circuiting here helps us to
		// avoid an eval call (in setAttribute) which can cause CSP
		// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
		if ( !el.attachEvent ) {
			return true;
		}

		var isSupported = (eventName in el);
		if ( !isSupported ) {
			el.setAttribute(eventName, "return;");
			isSupported = typeof el[eventName] === "function";
		}
		el = null;

		return isSupported;
	};

	jQuery.support.submitBubbles = eventSupported("submit");
	jQuery.support.changeBubbles = eventSupported("change");

	// release memory in IE
	div = all = a = null;
})();



var rbrace = /^(?:\{.*\}|\[.*\])$/;

jQuery.extend({
	cache: {},

	// Please use with caution
	uuid: 0,

	// Unique for each copy of jQuery on the page
	// Non-digits removed to match rinlinejQuery
	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),

	// The following elements throw uncatchable exceptions if you
	// attempt to add expando properties to them.
	noData: {
		"embed": true,
		// Ban all objects except for Flash (which handle expandos)
		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
		"applet": true
	},

	hasData: function( elem ) {
		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];

		return !!elem && !isEmptyDataObject( elem );
	},

	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
		if ( !jQuery.acceptData( elem ) ) {
			return;
		}

		var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,

			// We have to handle DOM nodes and JS objects differently because IE6-7
			// can't GC object references properly across the DOM-JS boundary
			isNode = elem.nodeType,

			// Only DOM nodes need the global jQuery cache; JS object data is
			// attached directly to the object so GC can occur automatically
			cache = isNode ? jQuery.cache : elem,

			// Only defining an ID for JS objects if its cache already exists allows
			// the code to shortcut on the same path as a DOM node with no cache
			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;

		// Avoid doing any more work than we need to when trying to get data on an
		// object that has no data at all
		if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
			return;
		}

		if ( !id ) {
			// Only DOM nodes need a new unique ID for each element since their data
			// ends up in the global cache
			if ( isNode ) {
				elem[ jQuery.expando ] = id = ++jQuery.uuid;
			} else {
				id = jQuery.expando;
			}
		}

		if ( !cache[ id ] ) {
			cache[ id ] = {};

			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
			// metadata on plain JS objects when the object is serialized using
			// JSON.stringify
			if ( !isNode ) {
				cache[ id ].toJSON = jQuery.noop;
			}
		}

		// An object can be passed to jQuery.data instead of a key/value pair; this gets
		// shallow copied over onto the existing cache
		if ( typeof name === "object" || typeof name === "function" ) {
			if ( pvt ) {
				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
			} else {
				cache[ id ] = jQuery.extend(cache[ id ], name);
			}
		}

		thisCache = cache[ id ];

		// Internal jQuery data is stored in a separate object inside the object's data
		// cache in order to avoid key collisions between internal data and user-defined
		// data
		if ( pvt ) {
			if ( !thisCache[ internalKey ] ) {
				thisCache[ internalKey ] = {};
			}

			thisCache = thisCache[ internalKey ];
		}

		if ( data !== undefined ) {
			thisCache[ name ] = data;
		}

		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
		// not attempt to inspect the internal events object using jQuery.data, as this
		// internal data object is undocumented and subject to change.
		if ( name === "events" && !thisCache[name] ) {
			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
		}

		return getByName ? thisCache[ name ] : thisCache;
	},

	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
		if ( !jQuery.acceptData( elem ) ) {
			return;
		}

		var internalKey = jQuery.expando, isNode = elem.nodeType,

			// See jQuery.data for more information
			cache = isNode ? jQuery.cache : elem,

			// See jQuery.data for more information
			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;

		// If there is already no cache entry for this object, there is no
		// purpose in continuing
		if ( !cache[ id ] ) {
			return;
		}

		if ( name ) {
			var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];

			if ( thisCache ) {
				delete thisCache[ name ];

				// If there is no data left in the cache, we want to continue
				// and let the cache object itself get destroyed
				if ( !isEmptyDataObject(thisCache) ) {
					return;
				}
			}
		}

		// See jQuery.data for more information
		if ( pvt ) {
			delete cache[ id ][ internalKey ];

			// Don't destroy the parent cache unless the internal data object
			// had been the only thing left in it
			if ( !isEmptyDataObject(cache[ id ]) ) {
				return;
			}
		}

		var internalCache = cache[ id ][ internalKey ];

		// Browsers that fail expando deletion also refuse to delete expandos on
		// the window, but it will allow it on all other JS objects; other browsers
		// don't care
		if ( jQuery.support.deleteExpando || cache != window ) {
			delete cache[ id ];
		} else {
			cache[ id ] = null;
		}

		// We destroyed the entire user cache at once because it's faster than
		// iterating through each key, but we need to continue to persist internal
		// data if it existed
		if ( internalCache ) {
			cache[ id ] = {};
			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
			// metadata on plain JS objects when the object is serialized using
			// JSON.stringify
			if ( !isNode ) {
				cache[ id ].toJSON = jQuery.noop;
			}

			cache[ id ][ internalKey ] = internalCache;

		// Otherwise, we need to eliminate the expando on the node to avoid
		// false lookups in the cache for entries that no longer exist
		} else if ( isNode ) {
			// IE does not allow us to delete expando properties from nodes,
			// nor does it have a removeAttribute function on Document nodes;
			// we must handle all of these cases
			if ( jQuery.support.deleteExpando ) {
				delete elem[ jQuery.expando ];
			} else if ( elem.removeAttribute ) {
				elem.removeAttribute( jQuery.expando );
			} else {
				elem[ jQuery.expando ] = null;
			}
		}
	},

	// For internal use only.
	_data: function( elem, name, data ) {
		return jQuery.data( elem, name, data, true );
	},

	// A method for determining if a DOM node can handle the data expando
	acceptData: function( elem ) {
		if ( elem.nodeName ) {
			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];

			if ( match ) {
				return !(match === true || elem.getAttribute("classid") !== match);
			}
		}

		return true;
	}
});

jQuery.fn.extend({
	data: function( key, value ) {
		var data = null;

		if ( typeof key === "undefined" ) {
			if ( this.length ) {
				data = jQuery.data( this[0] );

				if ( this[0].nodeType === 1 ) {
					var attr = this[0].attributes, name;
					for ( var i = 0, l = attr.length; i < l; i++ ) {
						name = attr[i].name;

						if ( name.indexOf( "data-" ) === 0 ) {
							name = name.substr( 5 );
							dataAttr( this[0], name, data[ name ] );
						}
					}
				}
			}

			return data;

		} else if ( typeof key === "object" ) {
			return this.each(function() {
				jQuery.data( this, key );
			});
		}

		var parts = key.split(".");
		parts[1] = parts[1] ? "." + parts[1] : "";

		if ( value === undefined ) {
			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);

			// Try to fetch any internally stored data first
			if ( data === undefined && this.length ) {
				data = jQuery.data( this[0], key );
				data = dataAttr( this[0], key, data );
			}

			return data === undefined && parts[1] ?
				this.data( parts[0] ) :
				data;

		} else {
			return this.each(function() {
				var $this = jQuery( this ),
					args = [ parts[0], value ];

				$this.triggerHandler( "setData" + parts[1] + "!", args );
				jQuery.data( this, key, value );
				$this.triggerHandler( "changeData" + parts[1] + "!", args );
			});
		}
	},

	removeData: function( key ) {
		return this.each(function() {
			jQuery.removeData( this, key );
		});
	}
});

function dataAttr( elem, key, data ) {
	// If nothing was found internally, try to fetch any
	// data from the HTML5 data-* attribute
	if ( data === undefined && elem.nodeType === 1 ) {
		data = elem.getAttribute( "data-" + key );

		if ( typeof data === "string" ) {
			try {
				data = data === "true" ? true :
				data === "false" ? false :
				data === "null" ? null :
				!jQuery.isNaN( data ) ? parseFloat( data ) :
					rbrace.test( data ) ? jQuery.parseJSON( data ) :
					data;
			} catch( e ) {}

			// Make sure we set the data so it isn't changed later
			jQuery.data( elem, key, data );

		} else {
			data = undefined;
		}
	}

	return data;
}

// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
// property to be considered empty objects; this property always exists in
// order to make sure JSON.stringify does not expose internal metadata
function isEmptyDataObject( obj ) {
	for ( var name in obj ) {
		if ( name !== "toJSON" ) {
			return false;
		}
	}

	return true;
}




jQuery.extend({
	queue: function( elem, type, data ) {
		if ( !elem ) {
			return;
		}

		type = (type || "fx") + "queue";
		var q = jQuery._data( elem, type );

		// Speed up dequeue by getting out quickly if this is just a lookup
		if ( !data ) {
			return q || [];
		}

		if ( !q || jQuery.isArray(data) ) {
			q = jQuery._data( elem, type, jQuery.makeArray(data) );

		} else {
			q.push( data );
		}

		return q;
	},

	dequeue: function( elem, type ) {
		type = type || "fx";

		var queue = jQuery.queue( elem, type ),
			fn = queue.shift();

		// If the fx queue is dequeued, always remove the progress sentinel
		if ( fn === "inprogress" ) {
			fn = queue.shift();
		}

		if ( fn ) {
			// Add a progress sentinel to prevent the fx queue from being
			// automatically dequeued
			if ( type === "fx" ) {
				queue.unshift("inprogress");
			}

			fn.call(elem, function() {
				jQuery.dequeue(elem, type);
			});
		}

		if ( !queue.length ) {
			jQuery.removeData( elem, type + "queue", true );
		}
	}
});

jQuery.fn.extend({
	queue: function( type, data ) {
		if ( typeof type !== "string" ) {
			data = type;
			type = "fx";
		}

		if ( data === undefined ) {
			return jQuery.queue( this[0], type );
		}
		return this.each(function( i ) {
			var queue = jQuery.queue( this, type, data );

			if ( type === "fx" && queue[0] !== "inprogress" ) {
				jQuery.dequeue( this, type );
			}
		});
	},
	dequeue: function( type ) {
		return this.each(function() {
			jQuery.dequeue( this, type );
		});
	},

	// Based off of the plugin by Clint Helfers, with permission.
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
	delay: function( time, type ) {
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
		type = type || "fx";

		return this.queue( type, function() {
			var elem = this;
			setTimeout(function() {
				jQuery.dequeue( elem, type );
			}, time );
		});
	},

	clearQueue: function( type ) {
		return this.queue( type || "fx", [] );
	}
});




var rclass = /[\n\t\r]/g,
	rspaces = /\s+/,
	rreturn = /\r/g,
	rspecialurl = /^(?:href|src|style)$/,
	rtype = /^(?:button|input)$/i,
	rfocusable = /^(?:button|input|object|select|textarea)$/i,
	rclickable = /^a(?:rea)?$/i,
	rradiocheck = /^(?:radio|checkbox)$/i;

jQuery.props = {
	"for": "htmlFor",
	"class": "className",
	readonly: "readOnly",
	maxlength: "maxLength",
	cellspacing: "cellSpacing",
	rowspan: "rowSpan",
	colspan: "colSpan",
	tabindex: "tabIndex",
	usemap: "useMap",
	frameborder: "frameBorder"
};

jQuery.fn.extend({
	attr: function( name, value ) {
		return jQuery.access( this, name, value, true, jQuery.attr );
	},

	removeAttr: function( name, fn ) {
		return this.each(function(){
			jQuery.attr( this, name, "" );
			if ( this.nodeType === 1 ) {
				this.removeAttribute( name );
			}
		});
	},

	addClass: function( value ) {
		if ( jQuery.isFunction(value) ) {
			return this.each(function(i) {
				var self = jQuery(this);
				self.addClass( value.call(this, i, self.attr("class")) );
			});
		}

		if ( value && typeof value === "string" ) {
			var classNames = (value || "").split( rspaces );

			for ( var i = 0, l = this.length; i < l; i++ ) {
				var elem = this[i];

				if ( elem.nodeType === 1 ) {
					if ( !elem.className ) {
						elem.className = value;

					} else {
						var className = " " + elem.className + " ",
							setClass = elem.className;

						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
								setClass += " " + classNames[c];
							}
						}
						elem.className = jQuery.trim( setClass );
					}
				}
			}
		}

		return this;
	},

	removeClass: function( value ) {
		if ( jQuery.isFunction(value) ) {
			return this.each(function(i) {
				var self = jQuery(this);
				self.removeClass( value.call(this, i, self.attr("class")) );
			});
		}

		if ( (value && typeof value === "string") || value === undefined ) {
			var classNames = (value || "").split( rspaces );

			for ( var i = 0, l = this.length; i < l; i++ ) {
				var elem = this[i];

				if ( elem.nodeType === 1 && elem.className ) {
					if ( value ) {
						var className = (" " + elem.className + " ").replace(rclass, " ");
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
							className = className.replace(" " + classNames[c] + " ", " ");
						}
						elem.className = jQuery.trim( className );

					} else {
						elem.className = "";
					}
				}
			}
		}

		return this;
	},

	toggleClass: function( value, stateVal ) {
		var type = typeof value,
			isBool = typeof stateVal === "boolean";

		if ( jQuery.isFunction( value ) ) {
			return this.each(function(i) {
				var self = jQuery(this);
				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
			});
		}

		return this.each(function() {
			if ( type === "string" ) {
				// toggle individual class names
				var className,
					i = 0,
					self = jQuery( this ),
					state = stateVal,
					classNames = value.split( rspaces );

				while ( (className = classNames[ i++ ]) ) {
					// check each className given, space seperated list
					state = isBool ? state : !self.hasClass( className );
					self[ state ? "addClass" : "removeClass" ]( className );
				}

			} else if ( type === "undefined" || type === "boolean" ) {
				if ( this.className ) {
					// store className if set
					jQuery._data( this, "__className__", this.className );
				}

				// toggle whole className
				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
			}
		});
	},

	hasClass: function( selector ) {
		var className = " " + selector + " ";
		for ( var i = 0, l = this.length; i < l; i++ ) {
			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
				return true;
			}
		}

		return false;
	},

	val: function( value ) {
		if ( !arguments.length ) {
			var elem = this[0];

			if ( elem ) {
				if ( jQuery.nodeName( elem, "option" ) ) {
					// attributes.value is undefined in Blackberry 4.7 but
					// uses .value. See #6932
					var val = elem.attributes.value;
					return !val || val.specified ? elem.value : elem.text;
				}

				// We need to handle select boxes special
				if ( jQuery.nodeName( elem, "select" ) ) {
					var index = elem.selectedIndex,
						values = [],
						options = elem.options,
						one = elem.type === "select-one";

					// Nothing was selected
					if ( index < 0 ) {
						return null;
					}

					// Loop through all the selected options
					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
						var option = options[ i ];

						// Don't return options that are disabled or in a disabled optgroup
						if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
								(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {

							// Get the specific value for the option
							value = jQuery(option).val();

							// We don't need an array for one selects
							if ( one ) {
								return value;
							}

							// Multi-Selects return an array
							values.push( value );
						}
					}

					// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
					if ( one && !values.length && options.length ) {
						return jQuery( options[ index ] ).val();
					}

					return values;
				}

				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
					return elem.getAttribute("value") === null ? "on" : elem.value;
				}

				// Everything else, we just grab the value
				return (elem.value || "").replace(rreturn, "");

			}

			return undefined;
		}

		var isFunction = jQuery.isFunction(value);

		return this.each(function(i) {
			var self = jQuery(this), val = value;

			if ( this.nodeType !== 1 ) {
				return;
			}

			if ( isFunction ) {
				val = value.call(this, i, self.val());
			}

			// Treat null/undefined as ""; convert numbers to string
			if ( val == null ) {
				val = "";
			} else if ( typeof val === "number" ) {
				val += "";
			} else if ( jQuery.isArray(val) ) {
				val = jQuery.map(val, function (value) {
					return value == null ? "" : value + "";
				});
			}

			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
				this.checked = jQuery.inArray( self.val(), val ) >= 0;

			} else if ( jQuery.nodeName( this, "select" ) ) {
				var values = jQuery.makeArray(val);

				jQuery( "option", this ).each(function() {
					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
				});

				if ( !values.length ) {
					this.selectedIndex = -1;
				}

			} else {
				this.value = val;
			}
		});
	}
});

jQuery.extend({
	attrFn: {
		val: true,
		css: true,
		html: true,
		text: true,
		data: true,
		width: true,
		height: true,
		offset: true
	},

	attr: function( elem, name, value, pass ) {
		// don't get/set attributes on text, comment and attribute nodes
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
			return undefined;
		}

		if ( pass && name in jQuery.attrFn ) {
			return jQuery(elem)[name](value);
		}

		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
			// Whether we are setting (or getting)
			set = value !== undefined;

		// Try to normalize/fix the name
		name = notxml && jQuery.props[ name ] || name;

		// Only do all the following if this is a node (faster for style)
		if ( elem.nodeType === 1 ) {
			// These attributes require special treatment
			var special = rspecialurl.test( name );

			// Safari mis-reports the default selected property of an option
			// Accessing the parent's selectedIndex property fixes it
			if ( name === "selected" && !jQuery.support.optSelected ) {
				var parent = elem.parentNode;
				if ( parent ) {
					parent.selectedIndex;

					// Make sure that it also works with optgroups, see #5701
					if ( parent.parentNode ) {
						parent.parentNode.selectedIndex;
					}
				}
			}

			// If applicable, access the attribute via the DOM 0 way
			// 'in' checks fail in Blackberry 4.7 #6931
			if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
				if ( set ) {
					// We can't allow the type property to be changed (since it causes problems in IE)
					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
						jQuery.error( "type property can't be changed" );
					}

					if ( value === null ) {
						if ( elem.nodeType === 1 ) {
							elem.removeAttribute( name );
						}

					} else {
						elem[ name ] = value;
					}
				}

				// browsers index elements by id/name on forms, give priority to attributes.
				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
					return elem.getAttributeNode( name ).nodeValue;
				}

				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
				if ( name === "tabIndex" ) {
					var attributeNode = elem.getAttributeNode( "tabIndex" );

					return attributeNode && attributeNode.specified ?
						attributeNode.value :
						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
							0 :
							undefined;
				}

				return elem[ name ];
			}

			if ( !jQuery.support.style && notxml && name === "style" ) {
				if ( set ) {
					elem.style.cssText = "" + value;
				}

				return elem.style.cssText;
			}

			if ( set ) {
				// convert the value to a string (all browsers do this but IE) see #1070
				elem.setAttribute( name, "" + value );
			}

			// Ensure that missing attributes return undefined
			// Blackberry 4.7 returns "" from getAttribute #6938
			if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
				return undefined;
			}

			var attr = !jQuery.support.hrefNormalized && notxml && special ?
					// Some attributes require a special call on IE
					elem.getAttribute( name, 2 ) :
					elem.getAttribute( name );

			// Non-existent attributes return null, we normalize to undefined
			return attr === null ? undefined : attr;
		}
		// Handle everything which isn't a DOM element node
		if ( set ) {
			elem[ name ] = value;
		}
		return elem[ name ];
	}
});




var rnamespaces = /\.(.*)$/,
	rformElems = /^(?:textarea|input|select)$/i,
	rperiod = /\./g,
	rspace = / /g,
	rescape = /[^\w\s.|`]/g,
	fcleanup = function( nm ) {
		return nm.replace(rescape, "\\$&");
	};

/*
 * A number of helper functions used for managing events.
 * Many of the ideas behind this code originated from
 * Dean Edwards' addEvent library.
 */
jQuery.event = {

	// Bind an event to an element
	// Original by Dean Edwards
	add: function( elem, types, handler, data ) {
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
			return;
		}

		// TODO :: Use a try/catch until it's safe to pull this out (likely 1.6)
		// Minor release fix for bug #8018
		try {
			// For whatever reason, IE has trouble passing the window object
			// around, causing it to be cloned in the process
			if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
				elem = window;
			}
		}
		catch ( e ) {}

		if ( handler === false ) {
			handler = returnFalse;
		} else if ( !handler ) {
			// Fixes bug #7229. Fix recommended by jdalton
			return;
		}

		var handleObjIn, handleObj;

		if ( handler.handler ) {
			handleObjIn = handler;
			handler = handleObjIn.handler;
		}

		// Make sure that the function being executed has a unique ID
		if ( !handler.guid ) {
			handler.guid = jQuery.guid++;
		}

		// Init the element's event structure
		var elemData = jQuery._data( elem );

		// If no elemData is found then we must be trying to bind to one of the
		// banned noData elements
		if ( !elemData ) {
			return;
		}

		var events = elemData.events,
			eventHandle = elemData.handle;

		if ( !events ) {
			elemData.events = events = {};
		}

		if ( !eventHandle ) {
			elemData.handle = eventHandle = function() {
				// Handle the second event of a trigger and when
				// an event is called after a page has unloaded
				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
					undefined;
			};
		}

		// Add elem as a property of the handle function
		// This is to prevent a memory leak with non-native events in IE.
		eventHandle.elem = elem;

		// Handle multiple events separated by a space
		// jQuery(...).bind("mouseover mouseout", fn);
		types = types.split(" ");

		var type, i = 0, namespaces;

		while ( (type = types[ i++ ]) ) {
			handleObj = handleObjIn ?
				jQuery.extend({}, handleObjIn) :
				{ handler: handler, data: data };

			// Namespaced event handlers
			if ( type.indexOf(".") > -1 ) {
				namespaces = type.split(".");
				type = namespaces.shift();
				handleObj.namespace = namespaces.slice(0).sort().join(".");

			} else {
				namespaces = [];
				handleObj.namespace = "";
			}

			handleObj.type = type;
			if ( !handleObj.guid ) {
				handleObj.guid = handler.guid;
			}

			// Get the current list of functions bound to this event
			var handlers = events[ type ],
				special = jQuery.event.special[ type ] || {};

			// Init the event handler queue
			if ( !handlers ) {
				handlers = events[ type ] = [];

				// Check for a special event handler
				// Only use addEventListener/attachEvent if the special
				// events handler returns false
				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
					// Bind the global event handler to the element
					if ( elem.addEventListener ) {
						elem.addEventListener( type, eventHandle, false );

					} else if ( elem.attachEvent ) {
						elem.attachEvent( "on" + type, eventHandle );
					}
				}
			}

			if ( special.add ) {
				special.add.call( elem, handleObj );

				if ( !handleObj.handler.guid ) {
					handleObj.handler.guid = handler.guid;
				}
			}

			// Add the function to the element's handler list
			handlers.push( handleObj );

			// Keep track of which events have been used, for global triggering
			jQuery.event.global[ type ] = true;
		}

		// Nullify elem to prevent memory leaks in IE
		elem = null;
	},

	global: {},

	// Detach an event or set of events from an element
	remove: function( elem, types, handler, pos ) {
		// don't do events on text and comment nodes
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
			return;
		}

		if ( handler === false ) {
			handler = returnFalse;
		}

		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
			elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
			events = elemData && elemData.events;

		if ( !elemData || !events ) {
			return;
		}

		// types is actually an event object here
		if ( types && types.type ) {
			handler = types.handler;
			types = types.type;
		}

		// Unbind all events for the element
		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
			types = types || "";

			for ( type in events ) {
				jQuery.event.remove( elem, type + types );
			}

			return;
		}

		// Handle multiple events separated by a space
		// jQuery(...).unbind("mouseover mouseout", fn);
		types = types.split(" ");

		while ( (type = types[ i++ ]) ) {
			origType = type;
			handleObj = null;
			all = type.indexOf(".") < 0;
			namespaces = [];

			if ( !all ) {
				// Namespaced event handlers
				namespaces = type.split(".");
				type = namespaces.shift();

				namespace = new RegExp("(^|\\.)" +
					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
			}

			eventType = events[ type ];

			if ( !eventType ) {
				continue;
			}

			if ( !handler ) {
				for ( j = 0; j < eventType.length; j++ ) {
					handleObj = eventType[ j ];

					if ( all || namespace.test( handleObj.namespace ) ) {
						jQuery.event.remove( elem, origType, handleObj.handler, j );
						eventType.splice( j--, 1 );
					}
				}

				continue;
			}

			special = jQuery.event.special[ type ] || {};

			for ( j = pos || 0; j < eventType.length; j++ ) {
				handleObj = eventType[ j ];

				if ( handler.guid === handleObj.guid ) {
					// remove the given handler for the given type
					if ( all || namespace.test( handleObj.namespace ) ) {
						if ( pos == null ) {
							eventType.splice( j--, 1 );
						}

						if ( special.remove ) {
							special.remove.call( elem, handleObj );
						}
					}

					if ( pos != null ) {
						break;
					}
				}
			}

			// remove generic event handler if no more handlers exist
			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
					jQuery.removeEvent( elem, type, elemData.handle );
				}

				ret = null;
				delete events[ type ];
			}
		}

		// Remove the expando if it's no longer used
		if ( jQuery.isEmptyObject( events ) ) {
			var handle = elemData.handle;
			if ( handle ) {
				handle.elem = null;
			}

			delete elemData.events;
			delete elemData.handle;

			if ( jQuery.isEmptyObject( elemData ) ) {
				jQuery.removeData( elem, undefined, true );
			}
		}
	},

	// bubbling is internal
	trigger: function( event, data, elem /*, bubbling */ ) {
		// Event object or event type
		var type = event.type || event,
			bubbling = arguments[3];

		if ( !bubbling ) {
			event = typeof event === "object" ?
				// jQuery.Event object
				event[ jQuery.expando ] ? event :
				// Object literal
				jQuery.extend( jQuery.Event(type), event ) :
				// Just the event type (string)
				jQuery.Event(type);

			if ( type.indexOf("!") >= 0 ) {
				event.type = type = type.slice(0, -1);
				event.exclusive = true;
			}

			// Handle a global trigger
			if ( !elem ) {
				// Don't bubble custom events when global (to avoid too much overhead)
				event.stopPropagation();

				// Only trigger if we've ever bound an event for it
				if ( jQuery.event.global[ type ] ) {
					// XXX This code smells terrible. event.js should not be directly
					// inspecting the data cache
					jQuery.each( jQuery.cache, function() {
						// internalKey variable is just used to make it easier to find
						// and potentially change this stuff later; currently it just
						// points to jQuery.expando
						var internalKey = jQuery.expando,
							internalCache = this[ internalKey ];
						if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
							jQuery.event.trigger( event, data, internalCache.handle.elem );
						}
					});
				}
			}

			// Handle triggering a single element

			// don't do events on text and comment nodes
			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
				return undefined;
			}

			// Clean up in case it is reused
			event.result = undefined;
			event.target = elem;

			// Clone the incoming data, if any
			data = jQuery.makeArray( data );
			data.unshift( event );
		}

		event.currentTarget = elem;

		// Trigger the event, it is assumed that "handle" is a function
		var handle = jQuery._data( elem, "handle" );

		if ( handle ) {
			handle.apply( elem, data );
		}

		var parent = elem.parentNode || elem.ownerDocument;

		// Trigger an inline bound script
		try {
			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
					event.result = false;
					event.preventDefault();
				}
			}

		// prevent IE from throwing an error for some elements with some event types, see #3533
		} catch (inlineError) {}

		if ( !event.isPropagationStopped() && parent ) {
			jQuery.event.trigger( event, data, parent, true );

		} else if ( !event.isDefaultPrevented() ) {
			var old,
				target = event.target,
				targetType = type.replace( rnamespaces, "" ),
				isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
				special = jQuery.event.special[ targetType ] || {};

			if ( (!special._default || special._default.call( elem, event ) === false) &&
				!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {

				try {
					if ( target[ targetType ] ) {
						// Make sure that we don't accidentally re-trigger the onFOO events
						old = target[ "on" + targetType ];

						if ( old ) {
							target[ "on" + targetType ] = null;
						}

						jQuery.event.triggered = true;
						target[ targetType ]();
					}

				// prevent IE from throwing an error for some elements with some event types, see #3533
				} catch (triggerError) {}

				if ( old ) {
					target[ "on" + targetType ] = old;
				}

				jQuery.event.triggered = false;
			}
		}
	},

	handle: function( event ) {
		var all, handlers, namespaces, namespace_re, events,
			namespace_sort = [],
			args = jQuery.makeArray( arguments );

		event = args[0] = jQuery.event.fix( event || window.event );
		event.currentTarget = this;

		// Namespaced event handlers
		all = event.type.indexOf(".") < 0 && !event.exclusive;

		if ( !all ) {
			namespaces = event.type.split(".");
			event.type = namespaces.shift();
			namespace_sort = namespaces.slice(0).sort();
			namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
		}

		event.namespace = event.namespace || namespace_sort.join(".");

		events = jQuery._data(this, "events");

		handlers = (events || {})[ event.type ];

		if ( events && handlers ) {
			// Clone the handlers to prevent manipulation
			handlers = handlers.slice(0);

			for ( var j = 0, l = handlers.length; j < l; j++ ) {
				var handleObj = handlers[ j ];

				// Filter the functions by class
				if ( all || namespace_re.test( handleObj.namespace ) ) {
					// Pass in a reference to the handler function itself
					// So that we can later remove it
					event.handler = handleObj.handler;
					event.data = handleObj.data;
					event.handleObj = handleObj;

					var ret = handleObj.handler.apply( this, args );

					if ( ret !== undefined ) {
						event.result = ret;
						if ( ret === false ) {
							event.preventDefault();
							event.stopPropagation();
						}
					}

					if ( event.isImmediatePropagationStopped() ) {
						break;
					}
				}
			}
		}

		return event.result;
	},

	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),

	fix: function( event ) {
		if ( event[ jQuery.expando ] ) {
			return event;
		}

		// store a copy of the original event object
		// and "clone" to set read-only properties
		var originalEvent = event;
		event = jQuery.Event( originalEvent );

		for ( var i = this.props.length, prop; i; ) {
			prop = this.props[ --i ];
			event[ prop ] = originalEvent[ prop ];
		}

		// Fix target property, if necessary
		if ( !event.target ) {
			// Fixes #1925 where srcElement might not be defined either
			event.target = event.srcElement || document;
		}

		// check if target is a textnode (safari)
		if ( event.target.nodeType === 3 ) {
			event.target = event.target.parentNode;
		}

		// Add relatedTarget, if necessary
		if ( !event.relatedTarget && event.fromElement ) {
			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
		}

		// Calculate pageX/Y if missing and clientX/Y available
		if ( event.pageX == null && event.clientX != null ) {
			var doc = document.documentElement,
				body = document.body;

			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
		}

		// Add which for key events
		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
			event.which = event.charCode != null ? event.charCode : event.keyCode;
		}

		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
		if ( !event.metaKey && event.ctrlKey ) {
			event.metaKey = event.ctrlKey;
		}

		// Add which for click: 1 === left; 2 === middle; 3 === right
		// Note: button is not normalized, so don't use it
		if ( !event.which && event.button !== undefined ) {
			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
		}

		return event;
	},

	// Deprecated, use jQuery.guid instead
	guid: 1E8,

	// Deprecated, use jQuery.proxy instead
	proxy: jQuery.proxy,

	special: {
		ready: {
			// Make sure the ready event is setup
			setup: jQuery.bindReady,
			teardown: jQuery.noop
		},

		live: {
			add: function( handleObj ) {
				jQuery.event.add( this,
					liveConvert( handleObj.origType, handleObj.selector ),
					jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
			},

			remove: function( handleObj ) {
				jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
			}
		},

		beforeunload: {
			setup: function( data, namespaces, eventHandle ) {
				// We only want to do this special case on windows
				if ( jQuery.isWindow( this ) ) {
					this.onbeforeunload = eventHandle;
				}
			},

			teardown: function( namespaces, eventHandle ) {
				if ( this.onbeforeunload === eventHandle ) {
					this.onbeforeunload = null;
				}
			}
		}
	}
};

jQuery.removeEvent = document.removeEventListener ?
	function( elem, type, handle ) {
		if ( elem.removeEventListener ) {
			elem.removeEventListener( type, handle, false );
		}
	} :
	function( elem, type, handle ) {
		if ( elem.detachEvent ) {
			elem.detachEvent( "on" + type, handle );
		}
	};

jQuery.Event = function( src ) {
	// Allow instantiation without the 'new' keyword
	if ( !this.preventDefault ) {
		return new jQuery.Event( src );
	}

	// Event object
	if ( src && src.type ) {
		this.originalEvent = src;
		this.type = src.type;

		// Events bubbling up the document may have been marked as prevented
		// by a handler lower down the tree; reflect the correct value.
		this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
			src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;

	// Event type
	} else {
		this.type = src;
	}

	// timeStamp is buggy for some events on Firefox(#3843)
	// So we won't rely on the native value
	this.timeStamp = jQuery.now();

	// Mark it as fixed
	this[ jQuery.expando ] = true;
};

function returnFalse() {
	return false;
}
function returnTrue() {
	return true;
}

// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
	preventDefault: function() {
		this.isDefaultPrevented = returnTrue;

		var e = this.originalEvent;
		if ( !e ) {
			return;
		}

		// if preventDefault exists run it on the original event
		if ( e.preventDefault ) {
			e.preventDefault();

		// otherwise set the returnValue property of the original event to false (IE)
		} else {
			e.returnValue = false;
		}
	},
	stopPropagation: function() {
		this.isPropagationStopped = returnTrue;

		var e = this.originalEvent;
		if ( !e ) {
			return;
		}
		// if stopPropagation exists run it on the original event
		if ( e.stopPropagation ) {
			e.stopPropagation();
		}
		// otherwise set the cancelBubble property of the original event to true (IE)
		e.cancelBubble = true;
	},
	stopImmediatePropagation: function() {
		this.isImmediatePropagationStopped = returnTrue;
		this.stopPropagation();
	},
	isDefaultPrevented: returnFalse,
	isPropagationStopped: returnFalse,
	isImmediatePropagationStopped: returnFalse
};

// Checks if an event happened on an element within another element
// Used in jQuery.event.special.mouseenter and mouseleave handlers
var withinElement = function( event ) {
	// Check if mouse(over|out) are still within the same parent element
	var parent = event.relatedTarget;

	// Firefox sometimes assigns relatedTarget a XUL element
	// which we cannot access the parentNode property of
	try {

		// Chrome does something similar, the parentNode property
		// can be accessed but is null.
		if ( parent !== document && !parent.parentNode ) {
			return;
		}
		// Traverse up the tree
		while ( parent && parent !== this ) {
			parent = parent.parentNode;
		}

		if ( parent !== this ) {
			// set the correct event type
			event.type = event.data;

			// handle event if we actually just moused on to a non sub-element
			jQuery.event.handle.apply( this, arguments );
		}

	// assuming we've left the element since we most likely mousedover a xul element
	} catch(e) { }
},

// In case of event delegation, we only need to rename the event.type,
// liveHandler will take care of the rest.
delegate = function( event ) {
	event.type = event.data;
	jQuery.event.handle.apply( this, arguments );
};

// Create mouseenter and mouseleave events
jQuery.each({
	mouseenter: "mouseover",
	mouseleave: "mouseout"
}, function( orig, fix ) {
	jQuery.event.special[ orig ] = {
		setup: function( data ) {
			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
		},
		teardown: function( data ) {
			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
		}
	};
});

// submit delegation
if ( !jQuery.support.submitBubbles ) {

	jQuery.event.special.submit = {
		setup: function( data, namespaces ) {
			if ( this.nodeName && this.nodeName.toLowerCase() !== "form" ) {
				jQuery.event.add(this, "click.specialSubmit", function( e ) {
					var elem = e.target,
						type = elem.type;

					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
						trigger( "submit", this, arguments );
					}
				});

				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
					var elem = e.target,
						type = elem.type;

					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
						trigger( "submit", this, arguments );
					}
				});

			} else {
				return false;
			}
		},

		teardown: function( namespaces ) {
			jQuery.event.remove( this, ".specialSubmit" );
		}
	};

}

// change delegation, happens here so we have bind.
if ( !jQuery.support.changeBubbles ) {

	var changeFilters,

	getVal = function( elem ) {
		var type = elem.type, val = elem.value;

		if ( type === "radio" || type === "checkbox" ) {
			val = elem.checked;

		} else if ( type === "select-multiple" ) {
			val = elem.selectedIndex > -1 ?
				jQuery.map( elem.options, function( elem ) {
					return elem.selected;
				}).join("-") :
				"";

		} else if ( elem.nodeName.toLowerCase() === "select" ) {
			val = elem.selectedIndex;
		}

		return val;
	},

	testChange = function testChange( e ) {
		var elem = e.target, data, val;

		if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
			return;
		}

		data = jQuery._data( elem, "_change_data" );
		val = getVal(elem);

		// the current data will be also retrieved by beforeactivate
		if ( e.type !== "focusout" || elem.type !== "radio" ) {
			jQuery._data( elem, "_change_data", val );
		}

		if ( data === undefined || val === data ) {
			return;
		}

		if ( data != null || val ) {
			e.type = "change";
			e.liveFired = undefined;
			jQuery.event.trigger( e, arguments[1], elem );
		}
	};

	jQuery.event.special.change = {
		filters: {
			focusout: testChange,

			beforedeactivate: testChange,

			click: function( e ) {
				var elem = e.target, type = elem.type;

				if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
					testChange.call( this, e );
				}
			},

			// Change has to be called before submit
			// Keydown will be called before keypress, which is used in submit-event delegation
			keydown: function( e ) {
				var elem = e.target, type = elem.type;

				if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
					type === "select-multiple" ) {
					testChange.call( this, e );
				}
			},

			// Beforeactivate happens also before the previous element is blurred
			// with this event you can't trigger a change event, but you can store
			// information
			beforeactivate: function( e ) {
				var elem = e.target;
				jQuery._data( elem, "_change_data", getVal(elem) );
			}
		},

		setup: function( data, namespaces ) {
			if ( this.type === "file" ) {
				return false;
			}

			for ( var type in changeFilters ) {
				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
			}

			return rformElems.test( this.nodeName );
		},

		teardown: function( namespaces ) {
			jQuery.event.remove( this, ".specialChange" );

			return rformElems.test( this.nodeName );
		}
	};

	changeFilters = jQuery.event.special.change.filters;

	// Handle when the input is .focus()'d
	changeFilters.focus = changeFilters.beforeactivate;
}

function trigger( type, elem, args ) {
	// Piggyback on a donor event to simulate a different one.
	// Fake originalEvent to avoid donor's stopPropagation, but if the
	// simulated event prevents default then we do the same on the donor.
	// Don't pass args or remember liveFired; they apply to the donor event.
	var event = jQuery.extend( {}, args[ 0 ] );
	event.type = type;
	event.originalEvent = {};
	event.liveFired = undefined;
	jQuery.event.handle.call( elem, event );
	if ( event.isDefaultPrevented() ) {
		args[ 0 ].preventDefault();
	}
}

// Create "bubbling" focus and blur events
if ( document.addEventListener ) {
	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
		jQuery.event.special[ fix ] = {
			setup: function() {
				this.addEventListener( orig, handler, true );
			},
			teardown: function() {
				this.removeEventListener( orig, handler, true );
			}
		};

		function handler( e ) {
			e = jQuery.event.fix( e );
			e.type = fix;
			return jQuery.event.handle.call( this, e );
		}
	});
}

jQuery.each(["bind", "one"], function( i, name ) {
	jQuery.fn[ name ] = function( type, data, fn ) {
		// Handle object literals
		if ( typeof type === "object" ) {
			for ( var key in type ) {
				this[ name ](key, data, type[key], fn);
			}
			return this;
		}

		if ( jQuery.isFunction( data ) || data === false ) {
			fn = data;
			data = undefined;
		}

		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
			jQuery( this ).unbind( event, handler );
			return fn.apply( this, arguments );
		}) : fn;

		if ( type === "unload" && name !== "one" ) {
			this.one( type, data, fn );

		} else {
			for ( var i = 0, l = this.length; i < l; i++ ) {
				jQuery.event.add( this[i], type, handler, data );
			}
		}

		return this;
	};
});

jQuery.fn.extend({
	unbind: function( type, fn ) {
		// Handle object literals
		if ( typeof type === "object" && !type.preventDefault ) {
			for ( var key in type ) {
				this.unbind(key, type[key]);
			}

		} else {
			for ( var i = 0, l = this.length; i < l; i++ ) {
				jQuery.event.remove( this[i], type, fn );
			}
		}

		return this;
	},

	delegate: function( selector, types, data, fn ) {
		return this.live( types, data, fn, selector );
	},

	undelegate: function( selector, types, fn ) {
		if ( arguments.length === 0 ) {
				return this.unbind( "live" );

		} else {
			return this.die( types, null, fn, selector );
		}
	},

	trigger: function( type, data ) {
		return this.each(function() {
			jQuery.event.trigger( type, data, this );
		});
	},

	triggerHandler: function( type, data ) {
		if ( this[0] ) {
			var event = jQuery.Event( type );
			event.preventDefault();
			event.stopPropagation();
			jQuery.event.trigger( event, data, this[0] );
			return event.result;
		}
	},

	toggle: function( fn ) {
		// Save reference to arguments for access in closure
		var args = arguments,
			i = 1;

		// link all the functions, so any of them can unbind this click handler
		while ( i < args.length ) {
			jQuery.proxy( fn, args[ i++ ] );
		}

		return this.click( jQuery.proxy( fn, function( event ) {
			// Figure out which function to execute
			var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
			jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );

			// Make sure that clicks stop
			event.preventDefault();

			// and execute the function
			return args[ lastToggle ].apply( this, arguments ) || false;
		}));
	},

	hover: function( fnOver, fnOut ) {
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
	}
});

var liveMap = {
	focus: "focusin",
	blur: "focusout",
	mouseenter: "mouseover",
	mouseleave: "mouseout"
};

jQuery.each(["live", "die"], function( i, name ) {
	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
		var type, i = 0, match, namespaces, preType,
			selector = origSelector || this.selector,
			context = origSelector ? this : jQuery( this.context );

		if ( typeof types === "object" && !types.preventDefault ) {
			for ( var key in types ) {
				context[ name ]( key, data, types[key], selector );
			}

			return this;
		}

		if ( jQuery.isFunction( data ) ) {
			fn = data;
			data = undefined;
		}

		types = (types || "").split(" ");

		while ( (type = types[ i++ ]) != null ) {
			match = rnamespaces.exec( type );
			namespaces = "";

			if ( match )  {
				namespaces = match[0];
				type = type.replace( rnamespaces, "" );
			}

			if ( type === "hover" ) {
				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
				continue;
			}

			preType = type;

			if ( type === "focus" || type === "blur" ) {
				types.push( liveMap[ type ] + namespaces );
				type = type + namespaces;

			} else {
				type = (liveMap[ type ] || type) + namespaces;
			}

			if ( name === "live" ) {
				// bind live handler
				for ( var j = 0, l = context.length; j < l; j++ ) {
					jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
				}

			} else {
				// unbind live handler
				context.unbind( "live." + liveConvert( type, selector ), fn );
			}
		}

		return this;
	};
});

function liveHandler( event ) {
	var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
		elems = [],
		selectors = [],
		events = jQuery._data( this, "events" );

	// Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
	if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
		return;
	}

	if ( event.namespace ) {
		namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
	}

	event.liveFired = this;

	var live = events.live.slice(0);

	for ( j = 0; j < live.length; j++ ) {
		handleObj = live[j];

		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
			selectors.push( handleObj.selector );

		} else {
			live.splice( j--, 1 );
		}
	}

	match = jQuery( event.target ).closest( selectors, event.currentTarget );

	for ( i = 0, l = match.length; i < l; i++ ) {
		close = match[i];

		for ( j = 0; j < live.length; j++ ) {
			handleObj = live[j];

			if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
				elem = close.elem;
				related = null;

				// Those two events require additional checking
				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
					event.type = handleObj.preType;
					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
				}

				if ( !related || related !== elem ) {
					elems.push({ elem: elem, handleObj: handleObj, level: close.level });
				}
			}
		}
	}

	for ( i = 0, l = elems.length; i < l; i++ ) {
		match = elems[i];

		if ( maxLevel && match.level > maxLevel ) {
			break;
		}

		event.currentTarget = match.elem;
		event.data = match.handleObj.data;
		event.handleObj = match.handleObj;

		ret = match.handleObj.origHandler.apply( match.elem, arguments );

		if ( ret === false || event.isPropagationStopped() ) {
			maxLevel = match.level;

			if ( ret === false ) {
				stop = false;
			}
			if ( event.isImmediatePropagationStopped() ) {
				break;
			}
		}
	}

	return stop;
}

function liveConvert( type, selector ) {
	return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
}

jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {

	// Handle event binding
	jQuery.fn[ name ] = function( data, fn ) {
		if ( fn == null ) {
			fn = data;
			data = null;
		}

		return arguments.length > 0 ?
			this.bind( name, data, fn ) :
			this.trigger( name );
	};

	if ( jQuery.attrFn ) {
		jQuery.attrFn[ name ] = true;
	}
});


/*!
 * Sizzle CSS Selector Engine
 *  Copyright 2011, The Dojo Foundation
 *  Released under the MIT, BSD, and GPL Licenses.
 *  More information: http://sizzlejs.com/
 */
(function(){

var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
	done = 0,
	toString = Object.prototype.toString,
	hasDuplicate = false,
	baseHasDuplicate = true,
	rBackslash = /\\/g,
	rNonWord = /\W/;

// Here we check if the JavaScript engine is using some sort of
// optimization where it does not always call our comparision
// function. If that is the case, discard the hasDuplicate value.
//   Thus far that includes Google Chrome.
[0, 0].sort(function() {
	baseHasDuplicate = false;
	return 0;
});

var Sizzle = function( selector, context, results, seed ) {
	results = results || [];
	context = context || document;

	var origContext = context;

	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
		return [];
	}
	
	if ( !selector || typeof selector !== "string" ) {
		return results;
	}

	var m, set, checkSet, extra, ret, cur, pop, i,
		prune = true,
		contextXML = Sizzle.isXML( context ),
		parts = [],
		soFar = selector;
	
	// Reset the position of the chunker regexp (start from head)
	do {
		chunker.exec( "" );
		m = chunker.exec( soFar );

		if ( m ) {
			soFar = m[3];
		
			parts.push( m[1] );
		
			if ( m[2] ) {
				extra = m[3];
				break;
			}
		}
	} while ( m );

	if ( parts.length > 1 && origPOS.exec( selector ) ) {

		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
			set = posProcess( parts[0] + parts[1], context );

		} else {
			set = Expr.relative[ parts[0] ] ?
				[ context ] :
				Sizzle( parts.shift(), context );

			while ( parts.length ) {
				selector = parts.shift();

				if ( Expr.relative[ selector ] ) {
					selector += parts.shift();
				}
				
				set = posProcess( selector, set );
			}
		}

	} else {
		// Take a shortcut and set the context if the root selector is an ID
		// (but not if it'll be faster if the inner selector is an ID)
		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {

			ret = Sizzle.find( parts.shift(), context, contextXML );
			context = ret.expr ?
				Sizzle.filter( ret.expr, ret.set )[0] :
				ret.set[0];
		}

		if ( context ) {
			ret = seed ?
				{ expr: parts.pop(), set: makeArray(seed) } :
				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );

			set = ret.expr ?
				Sizzle.filter( ret.expr, ret.set ) :
				ret.set;

			if ( parts.length > 0 ) {
				checkSet = makeArray( set );

			} else {
				prune = false;
			}

			while ( parts.length ) {
				cur = parts.pop();
				pop = cur;

				if ( !Expr.relative[ cur ] ) {
					cur = "";
				} else {
					pop = parts.pop();
				}

				if ( pop == null ) {
					pop = context;
				}

				Expr.relative[ cur ]( checkSet, pop, contextXML );
			}

		} else {
			checkSet = parts = [];
		}
	}

	if ( !checkSet ) {
		checkSet = set;
	}

	if ( !checkSet ) {
		Sizzle.error( cur || selector );
	}

	if ( toString.call(checkSet) === "[object Array]" ) {
		if ( !prune ) {
			results.push.apply( results, checkSet );

		} else if ( context && context.nodeType === 1 ) {
			for ( i = 0; checkSet[i] != null; i++ ) {
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
					results.push( set[i] );
				}
			}

		} else {
			for ( i = 0; checkSet[i] != null; i++ ) {
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
					results.push( set[i] );
				}
			}
		}

	} else {
		makeArray( checkSet, results );
	}

	if ( extra ) {
		Sizzle( extra, origContext, results, seed );
		Sizzle.uniqueSort( results );
	}

	return results;
};

Sizzle.uniqueSort = function( results ) {
	if ( sortOrder ) {
		hasDuplicate = baseHasDuplicate;
		results.sort( sortOrder );

		if ( hasDuplicate ) {
			for ( var i = 1; i < results.length; i++ ) {
				if ( results[i] === results[ i - 1 ] ) {
					results.splice( i--, 1 );
				}
			}
		}
	}

	return results;
};

Sizzle.matches = function( expr, set ) {
	return Sizzle( expr, null, null, set );
};

Sizzle.matchesSelector = function( node, expr ) {
	return Sizzle( expr, null, null, [node] ).length > 0;
};

Sizzle.find = function( expr, context, isXML ) {
	var set;

	if ( !expr ) {
		return [];
	}

	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
		var match,
			type = Expr.order[i];
		
		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
			var left = match[1];
			match.splice( 1, 1 );

			if ( left.substr( left.length - 1 ) !== "\\" ) {
				match[1] = (match[1] || "").replace( rBackslash, "" );
				set = Expr.find[ type ]( match, context, isXML );

				if ( set != null ) {
					expr = expr.replace( Expr.match[ type ], "" );
					break;
				}
			}
		}
	}

	if ( !set ) {
		set = typeof context.getElementsByTagName !== "undefined" ?
			context.getElementsByTagName( "*" ) :
			[];
	}

	return { set: set, expr: expr };
};

Sizzle.filter = function( expr, set, inplace, not ) {
	var match, anyFound,
		old = expr,
		result = [],
		curLoop = set,
		isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );

	while ( expr && set.length ) {
		for ( var type in Expr.filter ) {
			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
				var found, item,
					filter = Expr.filter[ type ],
					left = match[1];

				anyFound = false;

				match.splice(1,1);

				if ( left.substr( left.length - 1 ) === "\\" ) {
					continue;
				}

				if ( curLoop === result ) {
					result = [];
				}

				if ( Expr.preFilter[ type ] ) {
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );

					if ( !match ) {
						anyFound = found = true;

					} else if ( match === true ) {
						continue;
					}
				}

				if ( match ) {
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
						if ( item ) {
							found = filter( item, match, i, curLoop );
							var pass = not ^ !!found;

							if ( inplace && found != null ) {
								if ( pass ) {
									anyFound = true;

								} else {
									curLoop[i] = false;
								}

							} else if ( pass ) {
								result.push( item );
								anyFound = true;
							}
						}
					}
				}

				if ( found !== undefined ) {
					if ( !inplace ) {
						curLoop = result;
					}

					expr = expr.replace( Expr.match[ type ], "" );

					if ( !anyFound ) {
						return [];
					}

					break;
				}
			}
		}

		// Improper expression
		if ( expr === old ) {
			if ( anyFound == null ) {
				Sizzle.error( expr );

			} else {
				break;
			}
		}

		old = expr;
	}

	return curLoop;
};

Sizzle.error = function( msg ) {
	throw "Syntax error, unrecognized expression: " + msg;
};

var Expr = Sizzle.selectors = {
	order: [ "ID", "NAME", "TAG" ],

	match: {
		ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
		CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
		TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
		CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
		PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
	},

	leftMatch: {},

	attrMap: {
		"class": "className",
		"for": "htmlFor"
	},

	attrHandle: {
		href: function( elem ) {
			return elem.getAttribute( "href" );
		},
		type: function( elem ) {
			return elem.getAttribute( "type" );
		}
	},

	relative: {
		"+": function(checkSet, part){
			var isPartStr = typeof part === "string",
				isTag = isPartStr && !rNonWord.test( part ),
				isPartStrNotTag = isPartStr && !isTag;

			if ( isTag ) {
				part = part.toLowerCase();
			}

			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
				if ( (elem = checkSet[i]) ) {
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}

					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
						elem || false :
						elem === part;
				}
			}

			if ( isPartStrNotTag ) {
				Sizzle.filter( part, checkSet, true );
			}
		},

		">": function( checkSet, part ) {
			var elem,
				isPartStr = typeof part === "string",
				i = 0,
				l = checkSet.length;

			if ( isPartStr && !rNonWord.test( part ) ) {
				part = part.toLowerCase();

				for ( ; i < l; i++ ) {
					elem = checkSet[i];

					if ( elem ) {
						var parent = elem.parentNode;
						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
					}
				}

			} else {
				for ( ; i < l; i++ ) {
					elem = checkSet[i];

					if ( elem ) {
						checkSet[i] = isPartStr ?
							elem.parentNode :
							elem.parentNode === part;
					}
				}

				if ( isPartStr ) {
					Sizzle.filter( part, checkSet, true );
				}
			}
		},

		"": function(checkSet, part, isXML){
			var nodeCheck,
				doneName = done++,
				checkFn = dirCheck;

			if ( typeof part === "string" && !rNonWord.test( part ) ) {
				part = part.toLowerCase();
				nodeCheck = part;
				checkFn = dirNodeCheck;
			}

			checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
		},

		"~": function( checkSet, part, isXML ) {
			var nodeCheck,
				doneName = done++,
				checkFn = dirCheck;

			if ( typeof part === "string" && !rNonWord.test( part ) ) {
				part = part.toLowerCase();
				nodeCheck = part;
				checkFn = dirNodeCheck;
			}

			checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
		}
	},

	find: {
		ID: function( match, context, isXML ) {
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
				var m = context.getElementById(match[1]);
				// Check parentNode to catch when Blackberry 4.6 returns
				// nodes that are no longer in the document #6963
				return m && m.parentNode ? [m] : [];
			}
		},

		NAME: function( match, context ) {
			if ( typeof context.getElementsByName !== "undefined" ) {
				var ret = [],
					results = context.getElementsByName( match[1] );

				for ( var i = 0, l = results.length; i < l; i++ ) {
					if ( results[i].getAttribute("name") === match[1] ) {
						ret.push( results[i] );
					}
				}

				return ret.length === 0 ? null : ret;
			}
		},

		TAG: function( match, context ) {
			if ( typeof context.getElementsByTagName !== "undefined" ) {
				return context.getElementsByTagName( match[1] );
			}
		}
	},
	preFilter: {
		CLASS: function( match, curLoop, inplace, result, not, isXML ) {
			match = " " + match[1].replace( rBackslash, "" ) + " ";

			if ( isXML ) {
				return match;
			}

			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
				if ( elem ) {
					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
						if ( !inplace ) {
							result.push( elem );
						}

					} else if ( inplace ) {
						curLoop[i] = false;
					}
				}
			}

			return false;
		},

		ID: function( match ) {
			return match[1].replace( rBackslash, "" );
		},

		TAG: function( match, curLoop ) {
			return match[1].replace( rBackslash, "" ).toLowerCase();
		},

		CHILD: function( match ) {
			if ( match[1] === "nth" ) {
				if ( !match[2] ) {
					Sizzle.error( match[0] );
				}

				match[2] = match[2].replace(/^\+|\s*/g, '');

				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
				var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);

				// calculate the numbers (first)n+(last) including if they are negative
				match[2] = (test[1] + (test[2] || 1)) - 0;
				match[3] = test[3] - 0;
			}
			else if ( match[2] ) {
				Sizzle.error( match[0] );
			}

			// TODO: Move to normal caching system
			match[0] = done++;

			return match;
		},

		ATTR: function( match, curLoop, inplace, result, not, isXML ) {
			var name = match[1] = match[1].replace( rBackslash, "" );
			
			if ( !isXML && Expr.attrMap[name] ) {
				match[1] = Expr.attrMap[name];
			}

			// Handle if an un-quoted value was used
			match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );

			if ( match[2] === "~=" ) {
				match[4] = " " + match[4] + " ";
			}

			return match;
		},

		PSEUDO: function( match, curLoop, inplace, result, not ) {
			if ( match[1] === "not" ) {
				// If we're dealing with a complex expression, or a simple one
				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
					match[3] = Sizzle(match[3], null, null, curLoop);

				} else {
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);

					if ( !inplace ) {
						result.push.apply( result, ret );
					}

					return false;
				}

			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
				return true;
			}
			
			return match;
		},

		POS: function( match ) {
			match.unshift( true );

			return match;
		}
	},
	
	filters: {
		enabled: function( elem ) {
			return elem.disabled === false && elem.type !== "hidden";
		},

		disabled: function( elem ) {
			return elem.disabled === true;
		},

		checked: function( elem ) {
			return elem.checked === true;
		},
		
		selected: function( elem ) {
			// Accessing this property makes selected-by-default
			// options in Safari work properly
			if ( elem.parentNode ) {
				elem.parentNode.selectedIndex;
			}
			
			return elem.selected === true;
		},

		parent: function( elem ) {
			return !!elem.firstChild;
		},

		empty: function( elem ) {
			return !elem.firstChild;
		},

		has: function( elem, i, match ) {
			return !!Sizzle( match[3], elem ).length;
		},

		header: function( elem ) {
			return (/h\d/i).test( elem.nodeName );
		},

		text: function( elem ) {
			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
			// use getAttribute instead to test this case
			return "text" === elem.getAttribute( 'type' );
		},
		radio: function( elem ) {
			return "radio" === elem.type;
		},

		checkbox: function( elem ) {
			return "checkbox" === elem.type;
		},

		file: function( elem ) {
			return "file" === elem.type;
		},
		password: function( elem ) {
			return "password" === elem.type;
		},

		submit: function( elem ) {
			return "submit" === elem.type;
		},

		image: function( elem ) {
			return "image" === elem.type;
		},

		reset: function( elem ) {
			return "reset" === elem.type;
		},

		button: function( elem ) {
			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
		},

		input: function( elem ) {
			return (/input|select|textarea|button/i).test( elem.nodeName );
		}
	},
	setFilters: {
		first: function( elem, i ) {
			return i === 0;
		},

		last: function( elem, i, match, array ) {
			return i === array.length - 1;
		},

		even: function( elem, i ) {
			return i % 2 === 0;
		},

		odd: function( elem, i ) {
			return i % 2 === 1;
		},

		lt: function( elem, i, match ) {
			return i < match[3] - 0;
		},

		gt: function( elem, i, match ) {
			return i > match[3] - 0;
		},

		nth: function( elem, i, match ) {
			return match[3] - 0 === i;
		},

		eq: function( elem, i, match ) {
			return match[3] - 0 === i;
		}
	},
	filter: {
		PSEUDO: function( elem, match, i, array ) {
			var name = match[1],
				filter = Expr.filters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );

			} else if ( name === "contains" ) {
				return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;

			} else if ( name === "not" ) {
				var not = match[3];

				for ( var j = 0, l = not.length; j < l; j++ ) {
					if ( not[j] === elem ) {
						return false;
					}
				}

				return true;

			} else {
				Sizzle.error( name );
			}
		},

		CHILD: function( elem, match ) {
			var type = match[1],
				node = elem;

			switch ( type ) {
				case "only":
				case "first":
					while ( (node = node.previousSibling) )	 {
						if ( node.nodeType === 1 ) { 
							return false; 
						}
					}

					if ( type === "first" ) { 
						return true; 
					}

					node = elem;

				case "last":
					while ( (node = node.nextSibling) )	 {
						if ( node.nodeType === 1 ) { 
							return false; 
						}
					}

					return true;

				case "nth":
					var first = match[2],
						last = match[3];

					if ( first === 1 && last === 0 ) {
						return true;
					}
					
					var doneName = match[0],
						parent = elem.parentNode;
	
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
						var count = 0;
						
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
							if ( node.nodeType === 1 ) {
								node.nodeIndex = ++count;
							}
						} 

						parent.sizcache = doneName;
					}
					
					var diff = elem.nodeIndex - last;

					if ( first === 0 ) {
						return diff === 0;

					} else {
						return ( diff % first === 0 && diff / first >= 0 );
					}
			}
		},

		ID: function( elem, match ) {
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
		},

		TAG: function( elem, match ) {
			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
		},
		
		CLASS: function( elem, match ) {
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
				.indexOf( match ) > -1;
		},

		ATTR: function( elem, match ) {
			var name = match[1],
				result = Expr.attrHandle[ name ] ?
					Expr.attrHandle[ name ]( elem ) :
					elem[ name ] != null ?
						elem[ name ] :
						elem.getAttribute( name ),
				value = result + "",
				type = match[2],
				check = match[4];

			return result == null ?
				type === "!=" :
				type === "=" ?
				value === check :
				type === "*=" ?
				value.indexOf(check) >= 0 :
				type === "~=" ?
				(" " + value + " ").indexOf(check) >= 0 :
				!check ?
				value && result !== false :
				type === "!=" ?
				value !== check :
				type === "^=" ?
				value.indexOf(check) === 0 :
				type === "$=" ?
				value.substr(value.length - check.length) === check :
				type === "|=" ?
				value === check || value.substr(0, check.length + 1) === check + "-" :
				false;
		},

		POS: function( elem, match, i, array ) {
			var name = match[2],
				filter = Expr.setFilters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );
			}
		}
	}
};

var origPOS = Expr.match.POS,
	fescape = function(all, num){
		return "\\" + (num - 0 + 1);
	};

for ( var type in Expr.match ) {
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
}

var makeArray = function( array, results ) {
	array = Array.prototype.slice.call( array, 0 );

	if ( results ) {
		results.push.apply( results, array );
		return results;
	}
	
	return array;
};

// Perform a simple check to determine if the browser is capable of
// converting a NodeList to an array using builtin methods.
// Also verifies that the returned array holds DOM nodes
// (which is not the case in the Blackberry browser)
try {
	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;

// Provide a fallback method if it does not work
} catch( e ) {
	makeArray = function( array, results ) {
		var i = 0,
			ret = results || [];

		if ( toString.call(array) === "[object Array]" ) {
			Array.prototype.push.apply( ret, array );

		} else {
			if ( typeof array.length === "number" ) {
				for ( var l = array.length; i < l; i++ ) {
					ret.push( array[i] );
				}

			} else {
				for ( ; array[i]; i++ ) {
					ret.push( array[i] );
				}
			}
		}

		return ret;
	};
}

var sortOrder, siblingCheck;

if ( document.documentElement.compareDocumentPosition ) {
	sortOrder = function( a, b ) {
		if ( a === b ) {
			hasDuplicate = true;
			return 0;
		}

		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
			return a.compareDocumentPosition ? -1 : 1;
		}

		return a.compareDocumentPosition(b) & 4 ? -1 : 1;
	};

} else {
	sortOrder = function( a, b ) {
		var al, bl,
			ap = [],
			bp = [],
			aup = a.parentNode,
			bup = b.parentNode,
			cur = aup;

		// The nodes are identical, we can exit early
		if ( a === b ) {
			hasDuplicate = true;
			return 0;

		// If the nodes are siblings (or identical) we can do a quick check
		} else if ( aup === bup ) {
			return siblingCheck( a, b );

		// If no parents were found then the nodes are disconnected
		} else if ( !aup ) {
			return -1;

		} else if ( !bup ) {
			return 1;
		}

		// Otherwise they're somewhere else in the tree so we need
		// to build up a full list of the parentNodes for comparison
		while ( cur ) {
			ap.unshift( cur );
			cur = cur.parentNode;
		}

		cur = bup;

		while ( cur ) {
			bp.unshift( cur );
			cur = cur.parentNode;
		}

		al = ap.length;
		bl = bp.length;

		// Start walking down the tree looking for a discrepancy
		for ( var i = 0; i < al && i < bl; i++ ) {
			if ( ap[i] !== bp[i] ) {
				return siblingCheck( ap[i], bp[i] );
			}
		}

		// We ended someplace up the tree so do a sibling check
		return i === al ?
			siblingCheck( a, bp[i], -1 ) :
			siblingCheck( ap[i], b, 1 );
	};

	siblingCheck = function( a, b, ret ) {
		if ( a === b ) {
			return ret;
		}

		var cur = a.nextSibling;

		while ( cur ) {
			if ( cur === b ) {
				return -1;
			}

			cur = cur.nextSibling;
		}

		return 1;
	};
}

// Utility function for retreiving the text value of an array of DOM nodes
Sizzle.getText = function( elems ) {
	var ret = "", elem;

	for ( var i = 0; elems[i]; i++ ) {
		elem = elems[i];

		// Get the text from text nodes and CDATA nodes
		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
			ret += elem.nodeValue;

		// Traverse everything else, except comment nodes
		} else if ( elem.nodeType !== 8 ) {
			ret += Sizzle.getText( elem.childNodes );
		}
	}

	return ret;
};

// Check to see if the browser returns elements by name when
// querying by getElementById (and provide a workaround)
(function(){
	// We're going to inject a fake input element with a specified name
	var form = document.createElement("div"),
		id = "script" + (new Date()).getTime(),
		root = document.documentElement;

	form.innerHTML = "<a name='" + id + "'/>";

	// Inject it into the root element, check its status, and remove it quickly
	root.insertBefore( form, root.firstChild );

	// The workaround has to do additional checks after a getElementById
	// Which slows things down for other browsers (hence the branching)
	if ( document.getElementById( id ) ) {
		Expr.find.ID = function( match, context, isXML ) {
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
				var m = context.getElementById(match[1]);

				return m ?
					m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
						[m] :
						undefined :
					[];
			}
		};

		Expr.filter.ID = function( elem, match ) {
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");

			return elem.nodeType === 1 && node && node.nodeValue === match;
		};
	}

	root.removeChild( form );

	// release memory in IE
	root = form = null;
})();

(function(){
	// Check to see if the browser returns only elements
	// when doing getElementsByTagName("*")

	// Create a fake element
	var div = document.createElement("div");
	div.appendChild( document.createComment("") );

	// Make sure no comments are found
	if ( div.getElementsByTagName("*").length > 0 ) {
		Expr.find.TAG = function( match, context ) {
			var results = context.getElementsByTagName( match[1] );

			// Filter out possible comments
			if ( match[1] === "*" ) {
				var tmp = [];

				for ( var i = 0; results[i]; i++ ) {
					if ( results[i].nodeType === 1 ) {
						tmp.push( results[i] );
					}
				}

				results = tmp;
			}

			return results;
		};
	}

	// Check to see if an attribute returns normalized href attributes
	div.innerHTML = "<a href='#'></a>";

	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
			div.firstChild.getAttribute("href") !== "#" ) {

		Expr.attrHandle.href = function( elem ) {
			return elem.getAttribute( "href", 2 );
		};
	}

	// release memory in IE
	div = null;
})();

if ( document.querySelectorAll ) {
	(function(){
		var oldSizzle = Sizzle,
			div = document.createElement("div"),
			id = "__sizzle__";

		div.innerHTML = "<p class='TEST'></p>";

		// Safari can't handle uppercase or unicode characters when
		// in quirks mode.
		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
			return;
		}
	
		Sizzle = function( query, context, extra, seed ) {
			context = context || document;

			// Only use querySelectorAll on non-XML documents
			// (ID selectors don't work in non-HTML documents)
			if ( !seed && !Sizzle.isXML(context) ) {
				// See if we find a selector to speed up
				var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
				
				if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
					// Speed-up: Sizzle("TAG")
					if ( match[1] ) {
						return makeArray( context.getElementsByTagName( query ), extra );
					
					// Speed-up: Sizzle(".CLASS")
					} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
						return makeArray( context.getElementsByClassName( match[2] ), extra );
					}
				}
				
				if ( context.nodeType === 9 ) {
					// Speed-up: Sizzle("body")
					// The body element only exists once, optimize finding it
					if ( query === "body" && context.body ) {
						return makeArray( [ context.body ], extra );
						
					// Speed-up: Sizzle("#ID")
					} else if ( match && match[3] ) {
						var elem = context.getElementById( match[3] );

						// Check parentNode to catch when Blackberry 4.6 returns
						// nodes that are no longer in the document #6963
						if ( elem && elem.parentNode ) {
							// Handle the case where IE and Opera return items
							// by name instead of ID
							if ( elem.id === match[3] ) {
								return makeArray( [ elem ], extra );
							}
							
						} else {
							return makeArray( [], extra );
						}
					}
					
					try {
						return makeArray( context.querySelectorAll(query), extra );
					} catch(qsaError) {}

				// qSA works strangely on Element-rooted queries
				// We can work around this by specifying an extra ID on the root
				// and working up from there (Thanks to Andrew Dupont for the technique)
				// IE 8 doesn't work on object elements
				} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
					var oldContext = context,
						old = context.getAttribute( "id" ),
						nid = old || id,
						hasParent = context.parentNode,
						relativeHierarchySelector = /^\s*[+~]/.test( query );

					if ( !old ) {
						context.setAttribute( "id", nid );
					} else {
						nid = nid.replace( /'/g, "\\$&" );
					}
					if ( relativeHierarchySelector && hasParent ) {
						context = context.parentNode;
					}

					try {
						if ( !relativeHierarchySelector || hasParent ) {
							return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
						}

					} catch(pseudoError) {
					} finally {
						if ( !old ) {
							oldContext.removeAttribute( "id" );
						}
					}
				}
			}
		
			return oldSizzle(query, context, extra, seed);
		};

		for ( var prop in oldSizzle ) {
			Sizzle[ prop ] = oldSizzle[ prop ];
		}

		// release memory in IE
		div = null;
	})();
}

(function(){
	var html = document.documentElement,
		matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
		pseudoWorks = false;

	try {
		// This should fail with an exception
		// Gecko does not error, returns false instead
		matches.call( document.documentElement, "[test!='']:sizzle" );
	
	} catch( pseudoError ) {
		pseudoWorks = true;
	}

	if ( matches ) {
		Sizzle.matchesSelector = function( node, expr ) {
			// Make sure that attribute selectors are quoted
			expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");

			if ( !Sizzle.isXML( node ) ) {
				try { 
					if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
						return matches.call( node, expr );
					}
				} catch(e) {}
			}

			return Sizzle(expr, null, null, [node]).length > 0;
		};
	}
})();

(function(){
	var div = document.createElement("div");

	div.innerHTML = "<div class='test e'></div><div class='test'></div>";

	// Opera can't find a second classname (in 9.6)
	// Also, make sure that getElementsByClassName actually exists
	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
		return;
	}

	// Safari caches class attributes, doesn't catch changes (in 3.2)
	div.lastChild.className = "e";

	if ( div.getElementsByClassName("e").length === 1 ) {
		return;
	}
	
	Expr.order.splice(1, 0, "CLASS");
	Expr.find.CLASS = function( match, context, isXML ) {
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
			return context.getElementsByClassName(match[1]);
		}
	};

	// release memory in IE
	div = null;
})();

function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];

		if ( elem ) {
			var match = false;

			elem = elem[dir];

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 && !isXML ){
					elem.sizcache = doneName;
					elem.sizset = i;
				}

				if ( elem.nodeName.toLowerCase() === cur ) {
					match = elem;
					break;
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];

		if ( elem ) {
			var match = false;
			
			elem = elem[dir];

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 ) {
					if ( !isXML ) {
						elem.sizcache = doneName;
						elem.sizset = i;
					}

					if ( typeof cur !== "string" ) {
						if ( elem === cur ) {
							match = true;
							break;
						}

					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
						match = elem;
						break;
					}
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

if ( document.documentElement.contains ) {
	Sizzle.contains = function( a, b ) {
		return a !== b && (a.contains ? a.contains(b) : true);
	};

} else if ( document.documentElement.compareDocumentPosition ) {
	Sizzle.contains = function( a, b ) {
		return !!(a.compareDocumentPosition(b) & 16);
	};

} else {
	Sizzle.contains = function() {
		return false;
	};
}

Sizzle.isXML = function( elem ) {
	// documentElement is verified for cases where it doesn't yet exist
	// (such as loading iframes in IE - #4833) 
	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;

	return documentElement ? documentElement.nodeName !== "HTML" : false;
};

var posProcess = function( selector, context ) {
	var match,
		tmpSet = [],
		later = "",
		root = context.nodeType ? [context] : context;

	// Position selectors must be done after the filter
	// And so must :not(positional) so we move all PSEUDOs to the end
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
		later += match[0];
		selector = selector.replace( Expr.match.PSEUDO, "" );
	}

	selector = Expr.relative[selector] ? selector + "*" : selector;

	for ( var i = 0, l = root.length; i < l; i++ ) {
		Sizzle( selector, root[i], tmpSet );
	}

	return Sizzle.filter( later, tmpSet );
};

// EXPOSE
jQuery.find = Sizzle;
jQuery.expr = Sizzle.selectors;
jQuery.expr[":"] = jQuery.expr.filters;
jQuery.unique = Sizzle.uniqueSort;
jQuery.text = Sizzle.getText;
jQuery.isXMLDoc = Sizzle.isXML;
jQuery.contains = Sizzle.contains;


})();


var runtil = /Until$/,
	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
	// Note: This RegExp should be improved, or likely pulled from Sizzle
	rmultiselector = /,/,
	isSimple = /^.[^:#\[\.,]*$/,
	slice = Array.prototype.slice,
	POS = jQuery.expr.match.POS,
	// methods guaranteed to produce a unique set when starting from a unique set
	guaranteedUnique = {
		children: true,
		contents: true,
		next: true,
		prev: true
	};

jQuery.fn.extend({
	find: function( selector ) {
		var ret = this.pushStack( "", "find", selector ),
			length = 0;

		for ( var i = 0, l = this.length; i < l; i++ ) {
			length = ret.length;
			jQuery.find( selector, this[i], ret );

			if ( i > 0 ) {
				// Make sure that the results are unique
				for ( var n = length; n < ret.length; n++ ) {
					for ( var r = 0; r < length; r++ ) {
						if ( ret[r] === ret[n] ) {
							ret.splice(n--, 1);
							break;
						}
					}
				}
			}
		}

		return ret;
	},

	has: function( target ) {
		var targets = jQuery( target );
		return this.filter(function() {
			for ( var i = 0, l = targets.length; i < l; i++ ) {
				if ( jQuery.contains( this, targets[i] ) ) {
					return true;
				}
			}
		});
	},

	not: function( selector ) {
		return this.pushStack( winnow(this, selector, false), "not", selector);
	},

	filter: function( selector ) {
		return this.pushStack( winnow(this, selector, true), "filter", selector );
	},

	is: function( selector ) {
		return !!selector && jQuery.filter( selector, this ).length > 0;
	},

	closest: function( selectors, context ) {
		var ret = [], i, l, cur = this[0];

		if ( jQuery.isArray( selectors ) ) {
			var match, selector,
				matches = {},
				level = 1;

			if ( cur && selectors.length ) {
				for ( i = 0, l = selectors.length; i < l; i++ ) {
					selector = selectors[i];

					if ( !matches[selector] ) {
						matches[selector] = jQuery.expr.match.POS.test( selector ) ?
							jQuery( selector, context || this.context ) :
							selector;
					}
				}

				while ( cur && cur.ownerDocument && cur !== context ) {
					for ( selector in matches ) {
						match = matches[selector];

						if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
							ret.push({ selector: selector, elem: cur, level: level });
						}
					}

					cur = cur.parentNode;
					level++;
				}
			}

			return ret;
		}

		var pos = POS.test( selectors ) ?
			jQuery( selectors, context || this.context ) : null;

		for ( i = 0, l = this.length; i < l; i++ ) {
			cur = this[i];

			while ( cur ) {
				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
					ret.push( cur );
					break;

				} else {
					cur = cur.parentNode;
					if ( !cur || !cur.ownerDocument || cur === context ) {
						break;
					}
				}
			}
		}

		ret = ret.length > 1 ? jQuery.unique(ret) : ret;

		return this.pushStack( ret, "closest", selectors );
	},

	// Determine the position of an element within
	// the matched set of elements
	index: function( elem ) {
		if ( !elem || typeof elem === "string" ) {
			return jQuery.inArray( this[0],
				// If it receives a string, the selector is used
				// If it receives nothing, the siblings are used
				elem ? jQuery( elem ) : this.parent().children() );
		}
		// Locate the position of the desired element
		return jQuery.inArray(
			// If it receives a jQuery object, the first element is used
			elem.jquery ? elem[0] : elem, this );
	},

	add: function( selector, context ) {
		var set = typeof selector === "string" ?
				jQuery( selector, context ) :
				jQuery.makeArray( selector ),
			all = jQuery.merge( this.get(), set );

		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
			all :
			jQuery.unique( all ) );
	},

	andSelf: function() {
		return this.add( this.prevObject );
	}
});

// A painfully simple check to see if an element is disconnected
// from a document (should be improved, where feasible).
function isDisconnected( node ) {
	return !node || !node.parentNode || node.parentNode.nodeType === 11;
}

jQuery.each({
	parent: function( elem ) {
		var parent = elem.parentNode;
		return parent && parent.nodeType !== 11 ? parent : null;
	},
	parents: function( elem ) {
		return jQuery.dir( elem, "parentNode" );
	},
	parentsUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "parentNode", until );
	},
	next: function( elem ) {
		return jQuery.nth( elem, 2, "nextSibling" );
	},
	prev: function( elem ) {
		return jQuery.nth( elem, 2, "previousSibling" );
	},
	nextAll: function( elem ) {
		return jQuery.dir( elem, "nextSibling" );
	},
	prevAll: function( elem ) {
		return jQuery.dir( elem, "previousSibling" );
	},
	nextUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "nextSibling", until );
	},
	prevUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "previousSibling", until );
	},
	siblings: function( elem ) {
		return jQuery.sibling( elem.parentNode.firstChild, elem );
	},
	children: function( elem ) {
		return jQuery.sibling( elem.firstChild );
	},
	contents: function( elem ) {
		return jQuery.nodeName( elem, "iframe" ) ?
			elem.contentDocument || elem.contentWindow.document :
			jQuery.makeArray( elem.childNodes );
	}
}, function( name, fn ) {
	jQuery.fn[ name ] = function( until, selector ) {
		var ret = jQuery.map( this, fn, until ),
			// The variable 'args' was introduced in
			// https://github.com/jquery/jquery/commit/52a0238
			// to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
			// http://code.google.com/p/v8/issues/detail?id=1050
			args = slice.call(arguments);

		if ( !runtil.test( name ) ) {
			selector = until;
		}

		if ( selector && typeof selector === "string" ) {
			ret = jQuery.filter( selector, ret );
		}

		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;

		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
			ret = ret.reverse();
		}

		return this.pushStack( ret, name, args.join(",") );
	};
});

jQuery.extend({
	filter: function( expr, elems, not ) {
		if ( not ) {
			expr = ":not(" + expr + ")";
		}

		return elems.length === 1 ?
			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
			jQuery.find.matches(expr, elems);
	},

	dir: function( elem, dir, until ) {
		var matched = [],
			cur = elem[ dir ];

		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
			if ( cur.nodeType === 1 ) {
				matched.push( cur );
			}
			cur = cur[dir];
		}
		return matched;
	},

	nth: function( cur, result, dir, elem ) {
		result = result || 1;
		var num = 0;

		for ( ; cur; cur = cur[dir] ) {
			if ( cur.nodeType === 1 && ++num === result ) {
				break;
			}
		}

		return cur;
	},

	sibling: function( n, elem ) {
		var r = [];

		for ( ; n; n = n.nextSibling ) {
			if ( n.nodeType === 1 && n !== elem ) {
				r.push( n );
			}
		}

		return r;
	}
});

// Implement the identical functionality for filter and not
function winnow( elements, qualifier, keep ) {
	if ( jQuery.isFunction( qualifier ) ) {
		return jQuery.grep(elements, function( elem, i ) {
			var retVal = !!qualifier.call( elem, i, elem );
			return retVal === keep;
		});

	} else if ( qualifier.nodeType ) {
		return jQuery.grep(elements, function( elem, i ) {
			return (elem === qualifier) === keep;
		});

	} else if ( typeof qualifier === "string" ) {
		var filtered = jQuery.grep(elements, function( elem ) {
			return elem.nodeType === 1;
		});

		if ( isSimple.test( qualifier ) ) {
			return jQuery.filter(qualifier, filtered, !keep);
		} else {
			qualifier = jQuery.filter( qualifier, filtered );
		}
	}

	return jQuery.grep(elements, function( elem, i ) {
		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
	});
}




var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
	rleadingWhitespace = /^\s+/,
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
	rtagName = /<([\w:]+)/,
	rtbody = /<tbody/i,
	rhtml = /<|&#?\w+;/,
	rnocache = /<(?:script|object|embed|option|style)/i,
	// checked="checked" or checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
	wrapMap = {
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
		legend: [ 1, "<fieldset>", "</fieldset>" ],
		thead: [ 1, "<table>", "</table>" ],
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
		area: [ 1, "<map>", "</map>" ],
		_default: [ 0, "", "" ]
	};

wrapMap.optgroup = wrapMap.option;
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;

// IE can't serialize <link> and <script> tags normally
if ( !jQuery.support.htmlSerialize ) {
	wrapMap._default = [ 1, "div<div>", "</div>" ];
}

jQuery.fn.extend({
	text: function( text ) {
		if ( jQuery.isFunction(text) ) {
			return this.each(function(i) {
				var self = jQuery( this );

				self.text( text.call(this, i, self.text()) );
			});
		}

		if ( typeof text !== "object" && text !== undefined ) {
			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
		}

		return jQuery.text( this );
	},

	wrapAll: function( html ) {
		if ( jQuery.isFunction( html ) ) {
			return this.each(function(i) {
				jQuery(this).wrapAll( html.call(this, i) );
			});
		}

		if ( this[0] ) {
			// The elements to wrap the target around
			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);

			if ( this[0].parentNode ) {
				wrap.insertBefore( this[0] );
			}

			wrap.map(function() {
				var elem = this;

				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
					elem = elem.firstChild;
				}

				return elem;
			}).append(this);
		}

		return this;
	},

	wrapInner: function( html ) {
		if ( jQuery.isFunction( html ) ) {
			return this.each(function(i) {
				jQuery(this).wrapInner( html.call(this, i) );
			});
		}

		return this.each(function() {
			var self = jQuery( this ),
				contents = self.contents();

			if ( contents.length ) {
				contents.wrapAll( html );

			} else {
				self.append( html );
			}
		});
	},

	wrap: function( html ) {
		return this.each(function() {
			jQuery( this ).wrapAll( html );
		});
	},

	unwrap: function() {
		return this.parent().each(function() {
			if ( !jQuery.nodeName( this, "body" ) ) {
				jQuery( this ).replaceWith( this.childNodes );
			}
		}).end();
	},

	append: function() {
		return this.domManip(arguments, true, function( elem ) {
			if ( this.nodeType === 1 ) {
				this.appendChild( elem );
			}
		});
	},

	prepend: function() {
		return this.domManip(arguments, true, function( elem ) {
			if ( this.nodeType === 1 ) {
				this.insertBefore( elem, this.firstChild );
			}
		});
	},

	before: function() {
		if ( this[0] && this[0].parentNode ) {
			return this.domManip(arguments, false, function( elem ) {
				this.parentNode.insertBefore( elem, this );
			});
		} else if ( arguments.length ) {
			var set = jQuery(arguments[0]);
			set.push.apply( set, this.toArray() );
			return this.pushStack( set, "before", arguments );
		}
	},

	after: function() {
		if ( this[0] && this[0].parentNode ) {
			return this.domManip(arguments, false, function( elem ) {
				this.parentNode.insertBefore( elem, this.nextSibling );
			});
		} else if ( arguments.length ) {
			var set = this.pushStack( this, "after", arguments );
			set.push.apply( set, jQuery(arguments[0]).toArray() );
			return set;
		}
	},

	// keepData is for internal use only--do not document
	remove: function( selector, keepData ) {
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
				if ( !keepData && elem.nodeType === 1 ) {
					jQuery.cleanData( elem.getElementsByTagName("*") );
					jQuery.cleanData( [ elem ] );
				}

				if ( elem.parentNode ) {
					elem.parentNode.removeChild( elem );
				}
			}
		}

		return this;
	},

	empty: function() {
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
			// Remove element nodes and prevent memory leaks
			if ( elem.nodeType === 1 ) {
				jQuery.cleanData( elem.getElementsByTagName("*") );
			}

			// Remove any remaining nodes
			while ( elem.firstChild ) {
				elem.removeChild( elem.firstChild );
			}
		}

		return this;
	},

	clone: function( dataAndEvents, deepDataAndEvents ) {
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

		return this.map( function () {
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
		});
	},

	html: function( value ) {
		if ( value === undefined ) {
			return this[0] && this[0].nodeType === 1 ?
				this[0].innerHTML.replace(rinlinejQuery, "") :
				null;

		// See if we can take a shortcut and just use innerHTML
		} else if ( typeof value === "string" && !rnocache.test( value ) &&
			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {

			value = value.replace(rxhtmlTag, "<$1></$2>");

			try {
				for ( var i = 0, l = this.length; i < l; i++ ) {
					// Remove element nodes and prevent memory leaks
					if ( this[i].nodeType === 1 ) {
						jQuery.cleanData( this[i].getElementsByTagName("*") );
						this[i].innerHTML = value;
					}
				}

			// If using innerHTML throws an exception, use the fallback method
			} catch(e) {
				this.empty().append( value );
			}

		} else if ( jQuery.isFunction( value ) ) {
			this.each(function(i){
				var self = jQuery( this );

				self.html( value.call(this, i, self.html()) );
			});

		} else {
			this.empty().append( value );
		}

		return this;
	},

	replaceWith: function( value ) {
		if ( this[0] && this[0].parentNode ) {
			// Make sure that the elements are removed from the DOM before they are inserted
			// this can help fix replacing a parent with child elements
			if ( jQuery.isFunction( value ) ) {
				return this.each(function(i) {
					var self = jQuery(this), old = self.html();
					self.replaceWith( value.call( this, i, old ) );
				});
			}

			if ( typeof value !== "string" ) {
				value = jQuery( value ).detach();
			}

			return this.each(function() {
				var next = this.nextSibling,
					parent = this.parentNode;

				jQuery( this ).remove();

				if ( next ) {
					jQuery(next).before( value );
				} else {
					jQuery(parent).append( value );
				}
			});
		} else {
			return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
		}
	},

	detach: function( selector ) {
		return this.remove( selector, true );
	},

	domManip: function( args, table, callback ) {
		var results, first, fragment, parent,
			value = args[0],
			scripts = [];

		// We can't cloneNode fragments that contain checked, in WebKit
		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
			return this.each(function() {
				jQuery(this).domManip( args, table, callback, true );
			});
		}

		if ( jQuery.isFunction(value) ) {
			return this.each(function(i) {
				var self = jQuery(this);
				args[0] = value.call(this, i, table ? self.html() : undefined);
				self.domManip( args, table, callback );
			});
		}

		if ( this[0] ) {
			parent = value && value.parentNode;

			// If we're in a fragment, just use that instead of building a new one
			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
				results = { fragment: parent };

			} else {
				results = jQuery.buildFragment( args, this, scripts );
			}

			fragment = results.fragment;

			if ( fragment.childNodes.length === 1 ) {
				first = fragment = fragment.firstChild;
			} else {
				first = fragment.firstChild;
			}

			if ( first ) {
				table = table && jQuery.nodeName( first, "tr" );

				for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
					callback.call(
						table ?
							root(this[i], first) :
							this[i],
						// Make sure that we do not leak memory by inadvertently discarding
						// the original fragment (which might have attached data) instead of
						// using it; in addition, use the original fragment object for the last
						// item instead of first because it can end up being emptied incorrectly
						// in certain situations (Bug #8070).
						// Fragments from the fragment cache must always be cloned and never used
						// in place.
						results.cacheable || (l > 1 && i < lastIndex) ?
							jQuery.clone( fragment, true, true ) :
							fragment
					);
				}
			}

			if ( scripts.length ) {
				jQuery.each( scripts, evalScript );
			}
		}

		return this;
	}
});

function root( elem, cur ) {
	return jQuery.nodeName(elem, "table") ?
		(elem.getElementsByTagName("tbody")[0] ||
		elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
		elem;
}

function cloneCopyEvent( src, dest ) {

	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
		return;
	}

	var internalKey = jQuery.expando,
		oldData = jQuery.data( src ),
		curData = jQuery.data( dest, oldData );

	// Switch to use the internal data object, if it exists, for the next
	// stage of data copying
	if ( (oldData = oldData[ internalKey ]) ) {
		var events = oldData.events;
				curData = curData[ internalKey ] = jQuery.extend({}, oldData);

		if ( events ) {
			delete curData.handle;
			curData.events = {};

			for ( var type in events ) {
				for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
					jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
				}
			}
		}
	}
}

function cloneFixAttributes(src, dest) {
	// We do not need to do anything for non-Elements
	if ( dest.nodeType !== 1 ) {
		return;
	}

	var nodeName = dest.nodeName.toLowerCase();

	// clearAttributes removes the attributes, which we don't want,
	// but also removes the attachEvent events, which we *do* want
	dest.clearAttributes();

	// mergeAttributes, in contrast, only merges back on the
	// original attributes, not the events
	dest.mergeAttributes(src);

	// IE6-8 fail to clone children inside object elements that use
	// the proprietary classid attribute value (rather than the type
	// attribute) to identify the type of content to display
	if ( nodeName === "object" ) {
		dest.outerHTML = src.outerHTML;

	} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
		// IE6-8 fails to persist the checked state of a cloned checkbox
		// or radio button. Worse, IE6-7 fail to give the cloned element
		// a checked appearance if the defaultChecked value isn't also set
		if ( src.checked ) {
			dest.defaultChecked = dest.checked = src.checked;
		}

		// IE6-7 get confused and end up setting the value of a cloned
		// checkbox/radio button to an empty string instead of "on"
		if ( dest.value !== src.value ) {
			dest.value = src.value;
		}

	// IE6-8 fails to return the selected option to the default selected
	// state when cloning options
	} else if ( nodeName === "option" ) {
		dest.selected = src.defaultSelected;

	// IE6-8 fails to set the defaultValue to the correct value when
	// cloning other types of input fields
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
		dest.defaultValue = src.defaultValue;
	}

	// Event data gets referenced instead of copied if the expando
	// gets copied too
	dest.removeAttribute( jQuery.expando );
}

jQuery.buildFragment = function( args, nodes, scripts ) {
	var fragment, cacheable, cacheresults,
		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);

	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
	// Cloning options loses the selected state, so don't cache them
	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
		args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {

		cacheable = true;
		cacheresults = jQuery.fragments[ args[0] ];
		if ( cacheresults ) {
			if ( cacheresults !== 1 ) {
				fragment = cacheresults;
			}
		}
	}

	if ( !fragment ) {
		fragment = doc.createDocumentFragment();
		jQuery.clean( args, doc, fragment, scripts );
	}

	if ( cacheable ) {
		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
	}

	return { fragment: fragment, cacheable: cacheable };
};

jQuery.fragments = {};

jQuery.each({
	appendTo: "append",
	prependTo: "prepend",
	insertBefore: "before",
	insertAfter: "after",
	replaceAll: "replaceWith"
}, function( name, original ) {
	jQuery.fn[ name ] = function( selector ) {
		var ret = [],
			insert = jQuery( selector ),
			parent = this.length === 1 && this[0].parentNode;

		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
			insert[ original ]( this[0] );
			return this;

		} else {
			for ( var i = 0, l = insert.length; i < l; i++ ) {
				var elems = (i > 0 ? this.clone(true) : this).get();
				jQuery( insert[i] )[ original ]( elems );
				ret = ret.concat( elems );
			}

			return this.pushStack( ret, name, insert.selector );
		}
	};
});

function getAll( elem ) {
	if ( "getElementsByTagName" in elem ) {
		return elem.getElementsByTagName( "*" );
	
	} else if ( "querySelectorAll" in elem ) {
		return elem.querySelectorAll( "*" );

	} else {
		return [];
	}
}

jQuery.extend({
	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
		var clone = elem.cloneNode(true),
				srcElements,
				destElements,
				i;

		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
			// IE copies events bound via attachEvent when using cloneNode.
			// Calling detachEvent on the clone will also remove the events
			// from the original. In order to get around this, we use some
			// proprietary methods to clear the events. Thanks to MooTools
			// guys for this hotness.

			cloneFixAttributes( elem, clone );

			// Using Sizzle here is crazy slow, so we use getElementsByTagName
			// instead
			srcElements = getAll( elem );
			destElements = getAll( clone );

			// Weird iteration because IE will replace the length property
			// with an element if you are cloning the body and one of the
			// elements on the page has a name or id of "length"
			for ( i = 0; srcElements[i]; ++i ) {
				cloneFixAttributes( srcElements[i], destElements[i] );
			}
		}

		// Copy the events from the original to the clone
		if ( dataAndEvents ) {
			cloneCopyEvent( elem, clone );

			if ( deepDataAndEvents ) {
				srcElements = getAll( elem );
				destElements = getAll( clone );

				for ( i = 0; srcElements[i]; ++i ) {
					cloneCopyEvent( srcElements[i], destElements[i] );
				}
			}
		}

		// Return the cloned set
		return clone;
},
	clean: function( elems, context, fragment, scripts ) {
		context = context || document;

		// !context.createElement fails in IE with an error but returns typeof 'object'
		if ( typeof context.createElement === "undefined" ) {
			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
		}

		var ret = [];

		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
			if ( typeof elem === "number" ) {
				elem += "";
			}

			if ( !elem ) {
				continue;
			}

			// Convert html string into DOM nodes
			if ( typeof elem === "string" && !rhtml.test( elem ) ) {
				elem = context.createTextNode( elem );

			} else if ( typeof elem === "string" ) {
				// Fix "XHTML"-style tags in all browsers
				elem = elem.replace(rxhtmlTag, "<$1></$2>");

				// Trim whitespace, otherwise indexOf won't work as expected
				var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
					wrap = wrapMap[ tag ] || wrapMap._default,
					depth = wrap[0],
					div = context.createElement("div");

				// Go to html and back, then peel off extra wrappers
				div.innerHTML = wrap[1] + elem + wrap[2];

				// Move to the right depth
				while ( depth-- ) {
					div = div.lastChild;
				}

				// Remove IE's autoinserted <tbody> from table fragments
				if ( !jQuery.support.tbody ) {

					// String was a <table>, *may* have spurious <tbody>
					var hasBody = rtbody.test(elem),
						tbody = tag === "table" && !hasBody ?
							div.firstChild && div.firstChild.childNodes :

							// String was a bare <thead> or <tfoot>
							wrap[1] === "<table>" && !hasBody ?
								div.childNodes :
								[];

					for ( var j = tbody.length - 1; j >= 0 ; --j ) {
						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
							tbody[ j ].parentNode.removeChild( tbody[ j ] );
						}
					}

				}

				// IE completely kills leading whitespace when innerHTML is used
				if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
					div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
				}

				elem = div.childNodes;
			}

			if ( elem.nodeType ) {
				ret.push( elem );
			} else {
				ret = jQuery.merge( ret, elem );
			}
		}

		if ( fragment ) {
			for ( i = 0; ret[i]; i++ ) {
				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );

				} else {
					if ( ret[i].nodeType === 1 ) {
						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
					}
					fragment.appendChild( ret[i] );
				}
			}
		}

		return ret;
	},

	cleanData: function( elems ) {
		var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
			deleteExpando = jQuery.support.deleteExpando;

		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
			if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
				continue;
			}

			id = elem[ jQuery.expando ];

			if ( id ) {
				data = cache[ id ] && cache[ id ][ internalKey ];

				if ( data && data.events ) {
					for ( var type in data.events ) {
						if ( special[ type ] ) {
							jQuery.event.remove( elem, type );

						// This is a shortcut to avoid jQuery.event.remove's overhead
						} else {
							jQuery.removeEvent( elem, type, data.handle );
						}
					}

					// Null the DOM reference to avoid IE6/7/8 leak (#7054)
					if ( data.handle ) {
						data.handle.elem = null;
					}
				}

				if ( deleteExpando ) {
					delete elem[ jQuery.expando ];

				} else if ( elem.removeAttribute ) {
					elem.removeAttribute( jQuery.expando );
				}

				delete cache[ id ];
			}
		}
	}
});

function evalScript( i, elem ) {
	if ( elem.src ) {
		jQuery.ajax({
			url: elem.src,
			async: false,
			dataType: "script"
		});
	} else {
		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
	}

	if ( elem.parentNode ) {
		elem.parentNode.removeChild( elem );
	}
}




var ralpha = /alpha\([^)]*\)/i,
	ropacity = /opacity=([^)]*)/,
	rdashAlpha = /-([a-z])/ig,
	rupper = /([A-Z])/g,
	rnumpx = /^-?\d+(?:px)?$/i,
	rnum = /^-?\d/,

	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
	cssWidth = [ "Left", "Right" ],
	cssHeight = [ "Top", "Bottom" ],
	curCSS,

	getComputedStyle,
	currentStyle,

	fcamelCase = function( all, letter ) {
		return letter.toUpperCase();
	};

jQuery.fn.css = function( name, value ) {
	// Setting 'undefined' is a no-op
	if ( arguments.length === 2 && value === undefined ) {
		return this;
	}

	return jQuery.access( this, name, value, true, function( elem, name, value ) {
		return value !== undefined ?
			jQuery.style( elem, name, value ) :
			jQuery.css( elem, name );
	});
};

jQuery.extend({
	// Add in style property hooks for overriding the default
	// behavior of getting and setting a style property
	cssHooks: {
		opacity: {
			get: function( elem, computed ) {
				if ( computed ) {
					// We should always get a number back from opacity
					var ret = curCSS( elem, "opacity", "opacity" );
					return ret === "" ? "1" : ret;

				} else {
					return elem.style.opacity;
				}
			}
		}
	},

	// Exclude the following css properties to add px
	cssNumber: {
		"zIndex": true,
		"fontWeight": true,
		"opacity": true,
		"zoom": true,
		"lineHeight": true
	},

	// Add in properties whose names you wish to fix before
	// setting or getting the value
	cssProps: {
		// normalize float css property
		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
	},

	// Get and set the style property on a DOM Node
	style: function( elem, name, value, extra ) {
		// Don't set styles on text and comment nodes
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
			return;
		}

		// Make sure that we're working with the right name
		var ret, origName = jQuery.camelCase( name ),
			style = elem.style, hooks = jQuery.cssHooks[ origName ];

		name = jQuery.cssProps[ origName ] || origName;

		// Check if we're setting a value
		if ( value !== undefined ) {
			// Make sure that NaN and null values aren't set. See: #7116
			if ( typeof value === "number" && isNaN( value ) || value == null ) {
				return;
			}

			// If a number was passed in, add 'px' to the (except for certain CSS properties)
			if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
				value += "px";
			}

			// If a hook was provided, use that value, otherwise just set the specified value
			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
				// Fixes bug #5509
				try {
					style[ name ] = value;
				} catch(e) {}
			}

		} else {
			// If a hook was provided get the non-computed value from there
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
				return ret;
			}

			// Otherwise just get the value from the style object
			return style[ name ];
		}
	},

	css: function( elem, name, extra ) {
		// Make sure that we're working with the right name
		var ret, origName = jQuery.camelCase( name ),
			hooks = jQuery.cssHooks[ origName ];

		name = jQuery.cssProps[ origName ] || origName;

		// If a hook was provided get the computed value from there
		if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
			return ret;

		// Otherwise, if a way to get the computed value exists, use that
		} else if ( curCSS ) {
			return curCSS( elem, name, origName );
		}
	},

	// A method for quickly swapping in/out CSS properties to get correct calculations
	swap: function( elem, options, callback ) {
		var old = {};

		// Remember the old values, and insert the new ones
		for ( var name in options ) {
			old[ name ] = elem.style[ name ];
			elem.style[ name ] = options[ name ];
		}

		callback.call( elem );

		// Revert the old values
		for ( name in options ) {
			elem.style[ name ] = old[ name ];
		}
	},

	camelCase: function( string ) {
		return string.replace( rdashAlpha, fcamelCase );
	}
});

// DEPRECATED, Use jQuery.css() instead
jQuery.curCSS = jQuery.css;

jQuery.each(["height", "width"], function( i, name ) {
	jQuery.cssHooks[ name ] = {
		get: function( elem, computed, extra ) {
			var val;

			if ( computed ) {
				if ( elem.offsetWidth !== 0 ) {
					val = getWH( elem, name, extra );

				} else {
					jQuery.swap( elem, cssShow, function() {
						val = getWH( elem, name, extra );
					});
				}

				if ( val <= 0 ) {
					val = curCSS( elem, name, name );

					if ( val === "0px" && currentStyle ) {
						val = currentStyle( elem, name, name );
					}

					if ( val != null ) {
						// Should return "auto" instead of 0, use 0 for
						// temporary backwards-compat
						return val === "" || val === "auto" ? "0px" : val;
					}
				}

				if ( val < 0 || val == null ) {
					val = elem.style[ name ];

					// Should return "auto" instead of 0, use 0 for
					// temporary backwards-compat
					return val === "" || val === "auto" ? "0px" : val;
				}

				return typeof val === "string" ? val : val + "px";
			}
		},

		set: function( elem, value ) {
			if ( rnumpx.test( value ) ) {
				// ignore negative width and height values #1599
				value = parseFloat(value);

				if ( value >= 0 ) {
					return value + "px";
				}

			} else {
				return value;
			}
		}
	};
});

if ( !jQuery.support.opacity ) {
	jQuery.cssHooks.opacity = {
		get: function( elem, computed ) {
			// IE uses filters for opacity
			return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
				(parseFloat(RegExp.$1) / 100) + "" :
				computed ? "1" : "";
		},

		set: function( elem, value ) {
			var style = elem.style;

			// IE has trouble with opacity if it does not have layout
			// Force it by setting the zoom level
			style.zoom = 1;

			// Set the alpha filter to set the opacity
			var opacity = jQuery.isNaN(value) ?
				"" :
				"alpha(opacity=" + value * 100 + ")",
				filter = style.filter || "";

			style.filter = ralpha.test(filter) ?
				filter.replace(ralpha, opacity) :
				style.filter + ' ' + opacity;
		}
	};
}

if ( document.defaultView && document.defaultView.getComputedStyle ) {
	getComputedStyle = function( elem, newName, name ) {
		var ret, defaultView, computedStyle;

		name = name.replace( rupper, "-$1" ).toLowerCase();

		if ( !(defaultView = elem.ownerDocument.defaultView) ) {
			return undefined;
		}

		if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
			ret = computedStyle.getPropertyValue( name );
			if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
				ret = jQuery.style( elem, name );
			}
		}

		return ret;
	};
}

if ( document.documentElement.currentStyle ) {
	currentStyle = function( elem, name ) {
		var left,
			ret = elem.currentStyle && elem.currentStyle[ name ],
			rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
			style = elem.style;

		// From the awesome hack by Dean Edwards
		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

		// If we're not dealing with a regular pixel number
		// but a number that has a weird ending, we need to convert it to pixels
		if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
			// Remember the original values
			left = style.left;

			// Put in the new values to get a computed value out
			if ( rsLeft ) {
				elem.runtimeStyle.left = elem.currentStyle.left;
			}
			style.left = name === "fontSize" ? "1em" : (ret || 0);
			ret = style.pixelLeft + "px";

			// Revert the changed values
			style.left = left;
			if ( rsLeft ) {
				elem.runtimeStyle.left = rsLeft;
			}
		}

		return ret === "" ? "auto" : ret;
	};
}

curCSS = getComputedStyle || currentStyle;

function getWH( elem, name, extra ) {
	var which = name === "width" ? cssWidth : cssHeight,
		val = name === "width" ? elem.offsetWidth : elem.offsetHeight;

	if ( extra === "border" ) {
		return val;
	}

	jQuery.each( which, function() {
		if ( !extra ) {
			val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
		}

		if ( extra === "margin" ) {
			val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;

		} else {
			val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
		}
	});

	return val;
}

if ( jQuery.expr && jQuery.expr.filters ) {
	jQuery.expr.filters.hidden = function( elem ) {
		var width = elem.offsetWidth,
			height = elem.offsetHeight;

		return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
	};

	jQuery.expr.filters.visible = function( elem ) {
		return !jQuery.expr.filters.hidden( elem );
	};
}




var r20 = /%20/g,
	rbracket = /\[\]$/,
	rCRLF = /\r?\n/g,
	rhash = /#.*$/,
	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
	rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
	// #7653, #8125, #8152: local protocol detection
	rlocalProtocol = /(?:^file|^widget|\-extension):$/,
	rnoContent = /^(?:GET|HEAD)$/,
	rprotocol = /^\/\//,
	rquery = /\?/,
	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
	rselectTextarea = /^(?:select|textarea)/i,
	rspacesAjax = /\s+/,
	rts = /([?&])_=[^&]*/,
	rucHeaders = /(^|\-)([a-z])/g,
	rucHeadersFunc = function( _, $1, $2 ) {
		return $1 + $2.toUpperCase();
	},
	rurl = /^([\w\+\.\-]+:)\/\/([^\/?#:]*)(?::(\d+))?/,

	// Keep a copy of the old load method
	_load = jQuery.fn.load,

	/* Prefilters
	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
	 * 2) These are called:
	 *    - BEFORE asking for a transport
	 *    - AFTER param serialization (s.data is a string if s.processData is true)
	 * 3) key is the dataType
	 * 4) the catchall symbol "*" can be used
	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
	 */
	prefilters = {},

	/* Transports bindings
	 * 1) key is the dataType
	 * 2) the catchall symbol "*" can be used
	 * 3) selection will start with transport dataType and THEN go to "*" if needed
	 */
	transports = {},

	// Document location
	ajaxLocation,

	// Document location segments
	ajaxLocParts;

// #8138, IE may throw an exception when accessing
// a field from document.location if document.domain has been set
try {
	ajaxLocation = document.location.href;
} catch( e ) {
	// Use the href attribute of an A element
	// since IE will modify it given document.location
	ajaxLocation = document.createElement( "a" );
	ajaxLocation.href = "";
	ajaxLocation = ajaxLocation.href;
}

// Segment location into parts
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() );

// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports( structure ) {

	// dataTypeExpression is optional and defaults to "*"
	return function( dataTypeExpression, func ) {

		if ( typeof dataTypeExpression !== "string" ) {
			func = dataTypeExpression;
			dataTypeExpression = "*";
		}

		if ( jQuery.isFunction( func ) ) {
			var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
				i = 0,
				length = dataTypes.length,
				dataType,
				list,
				placeBefore;

			// For each dataType in the dataTypeExpression
			for(; i < length; i++ ) {
				dataType = dataTypes[ i ];
				// We control if we're asked to add before
				// any existing element
				placeBefore = /^\+/.test( dataType );
				if ( placeBefore ) {
					dataType = dataType.substr( 1 ) || "*";
				}
				list = structure[ dataType ] = structure[ dataType ] || [];
				// then we add to the structure accordingly
				list[ placeBefore ? "unshift" : "push" ]( func );
			}
		}
	};
}

//Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
		dataType /* internal */, inspected /* internal */ ) {

	dataType = dataType || options.dataTypes[ 0 ];
	inspected = inspected || {};

	inspected[ dataType ] = true;

	var list = structure[ dataType ],
		i = 0,
		length = list ? list.length : 0,
		executeOnly = ( structure === prefilters ),
		selection;

	for(; i < length && ( executeOnly || !selection ); i++ ) {
		selection = list[ i ]( options, originalOptions, jqXHR );
		// If we got redirected to another dataType
		// we try there if executing only and not done already
		if ( typeof selection === "string" ) {
			if ( !executeOnly || inspected[ selection ] ) {
				selection = undefined;
			} else {
				options.dataTypes.unshift( selection );
				selection = inspectPrefiltersOrTransports(
						structure, options, originalOptions, jqXHR, selection, inspected );
			}
		}
	}
	// If we're only executing or nothing was selected
	// we try the catchall dataType if not done already
	if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
		selection = inspectPrefiltersOrTransports(
				structure, options, originalOptions, jqXHR, "*", inspected );
	}
	// unnecessary when only executing (prefilters)
	// but it'll be ignored by the caller in that case
	return selection;
}

jQuery.fn.extend({
	load: function( url, params, callback ) {
		if ( typeof url !== "string" && _load ) {
			return _load.apply( this, arguments );

		// Don't do a request if no elements are being requested
		} else if ( !this.length ) {
			return this;
		}

		var off = url.indexOf( " " );
		if ( off >= 0 ) {
			var selector = url.slice( off, url.length );
			url = url.slice( 0, off );
		}

		// Default to a GET request
		var type = "GET";

		// If the second parameter was provided
		if ( params ) {
			// If it's a function
			if ( jQuery.isFunction( params ) ) {
				// We assume that it's the callback
				callback = params;
				params = undefined;

			// Otherwise, build a param string
			} else if ( typeof params === "object" ) {
				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
				type = "POST";
			}
		}

		var self = this;

		// Request the remote document
		jQuery.ajax({
			url: url,
			type: type,
			dataType: "html",
			data: params,
			// Complete callback (responseText is used internally)
			complete: function( jqXHR, status, responseText ) {
				// Store the response as specified by the jqXHR object
				responseText = jqXHR.responseText;
				// If successful, inject the HTML into all the matched elements
				if ( jqXHR.isResolved() ) {
					// #4825: Get the actual response in case
					// a dataFilter is present in ajaxSettings
					jqXHR.done(function( r ) {
						responseText = r;
					});
					// See if a selector was specified
					self.html( selector ?
						// Create a dummy div to hold the results
						jQuery("<div>")
							// inject the contents of the document in, removing the scripts
							// to avoid any 'Permission Denied' errors in IE
							.append(responseText.replace(rscript, ""))

							// Locate the specified elements
							.find(selector) :

						// If not, just inject the full result
						responseText );
				}

				if ( callback ) {
					self.each( callback, [ responseText, status, jqXHR ] );
				}
			}
		});

		return this;
	},

	serialize: function() {
		return jQuery.param( this.serializeArray() );
	},

	serializeArray: function() {
		return this.map(function(){
			return this.elements ? jQuery.makeArray( this.elements ) : this;
		})
		.filter(function(){
			return this.name && !this.disabled &&
				( this.checked || rselectTextarea.test( this.nodeName ) ||
					rinput.test( this.type ) );
		})
		.map(function( i, elem ){
			var val = jQuery( this ).val();

			return val == null ?
				null :
				jQuery.isArray( val ) ?
					jQuery.map( val, function( val, i ){
						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
					}) :
					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
		}).get();
	}
});

// Attach a bunch of functions for handling common AJAX events
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
	jQuery.fn[ o ] = function( f ){
		return this.bind( o, f );
	};
} );

jQuery.each( [ "get", "post" ], function( i, method ) {
	jQuery[ method ] = function( url, data, callback, type ) {
		// shift arguments if data argument was omitted
		if ( jQuery.isFunction( data ) ) {
			type = type || callback;
			callback = data;
			data = undefined;
		}

		return jQuery.ajax({
			type: method,
			url: url,
			data: data,
			success: callback,
			dataType: type
		});
	};
} );

jQuery.extend({

	getScript: function( url, callback ) {
		return jQuery.get( url, undefined, callback, "script" );
	},

	getJSON: function( url, data, callback ) {
		return jQuery.get( url, data, callback, "json" );
	},

	// Creates a full fledged settings object into target
	// with both ajaxSettings and settings fields.
	// If target is omitted, writes into ajaxSettings.
	ajaxSetup: function ( target, settings ) {
		if ( !settings ) {
			// Only one parameter, we extend ajaxSettings
			settings = target;
			target = jQuery.extend( true, jQuery.ajaxSettings, settings );
		} else {
			// target was provided, we extend into it
			jQuery.extend( true, target, jQuery.ajaxSettings, settings );
		}
		// Flatten fields we don't want deep extended
		for( var field in { context: 1, url: 1 } ) {
			if ( field in settings ) {
				target[ field ] = settings[ field ];
			} else if( field in jQuery.ajaxSettings ) {
				target[ field ] = jQuery.ajaxSettings[ field ];
			}
		}
		return target;
	},

	ajaxSettings: {
		url: ajaxLocation,
		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
		global: true,
		type: "GET",
		contentType: "application/x-www-form-urlencoded",
		processData: true,
		async: true,
		/*
		timeout: 0,
		data: null,
		dataType: null,
		username: null,
		password: null,
		cache: null,
		traditional: false,
		headers: {},
		crossDomain: null,
		*/

		accepts: {
			xml: "application/xml, text/xml",
			html: "text/html",
			text: "text/plain",
			json: "application/json, text/javascript",
			"*": "*/*"
		},

		contents: {
			xml: /xml/,
			html: /html/,
			json: /json/
		},

		responseFields: {
			xml: "responseXML",
			text: "responseText"
		},

		// List of data converters
		// 1) key format is "source_type destination_type" (a single space in-between)
		// 2) the catchall symbol "*" can be used for source_type
		converters: {

			// Convert anything to text
			"* text": window.String,

			// Text to html (true = no transformation)
			"text html": true,

			// Evaluate text as a json expression
			"text json": jQuery.parseJSON,

			// Parse text as xml
			"text xml": jQuery.parseXML
		}
	},

	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
	ajaxTransport: addToPrefiltersOrTransports( transports ),

	// Main method
	ajax: function( url, options ) {

		// If url is an object, simulate pre-1.5 signature
		if ( typeof url === "object" ) {
			options = url;
			url = undefined;
		}

		// Force options to be an object
		options = options || {};

		var // Create the final options object
			s = jQuery.ajaxSetup( {}, options ),
			// Callbacks context
			callbackContext = s.context || s,
			// Context for global events
			// It's the callbackContext if one was provided in the options
			// and if it's a DOM node or a jQuery collection
			globalEventContext = callbackContext !== s &&
				( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
						jQuery( callbackContext ) : jQuery.event,
			// Deferreds
			deferred = jQuery.Deferred(),
			completeDeferred = jQuery._Deferred(),
			// Status-dependent callbacks
			statusCode = s.statusCode || {},
			// ifModified key
			ifModifiedKey,
			// Headers (they are sent all at once)
			requestHeaders = {},
			// Response headers
			responseHeadersString,
			responseHeaders,
			// transport
			transport,
			// timeout handle
			timeoutTimer,
			// Cross-domain detection vars
			parts,
			// The jqXHR state
			state = 0,
			// To know if global events are to be dispatched
			fireGlobals,
			// Loop variable
			i,
			// Fake xhr
			jqXHR = {

				readyState: 0,

				// Caches the header
				setRequestHeader: function( name, value ) {
					if ( !state ) {
						requestHeaders[ name.toLowerCase().replace( rucHeaders, rucHeadersFunc ) ] = value;
					}
					return this;
				},

				// Raw string
				getAllResponseHeaders: function() {
					return state === 2 ? responseHeadersString : null;
				},

				// Builds headers hashtable if needed
				getResponseHeader: function( key ) {
					var match;
					if ( state === 2 ) {
						if ( !responseHeaders ) {
							responseHeaders = {};
							while( ( match = rheaders.exec( responseHeadersString ) ) ) {
								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
							}
						}
						match = responseHeaders[ key.toLowerCase() ];
					}
					return match === undefined ? null : match;
				},

				// Overrides response content-type header
				overrideMimeType: function( type ) {
					if ( !state ) {
						s.mimeType = type;
					}
					return this;
				},

				// Cancel the request
				abort: function( statusText ) {
					statusText = statusText || "abort";
					if ( transport ) {
						transport.abort( statusText );
					}
					done( 0, statusText );
					return this;
				}
			};

		// Callback for when everything is done
		// It is defined here because jslint complains if it is declared
		// at the end of the function (which would be more logical and readable)
		function done( status, statusText, responses, headers ) {

			// Called once
			if ( state === 2 ) {
				return;
			}

			// State is "done" now
			state = 2;

			// Clear timeout if it exists
			if ( timeoutTimer ) {
				clearTimeout( timeoutTimer );
			}

			// Dereference transport for early garbage collection
			// (no matter how long the jqXHR object will be used)
			transport = undefined;

			// Cache response headers
			responseHeadersString = headers || "";

			// Set readyState
			jqXHR.readyState = status ? 4 : 0;

			var isSuccess,
				success,
				error,
				response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
				lastModified,
				etag;

			// If successful, handle type chaining
			if ( status >= 200 && status < 300 || status === 304 ) {

				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
				if ( s.ifModified ) {

					if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
						jQuery.lastModified[ ifModifiedKey ] = lastModified;
					}
					if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
						jQuery.etag[ ifModifiedKey ] = etag;
					}
				}

				// If not modified
				if ( status === 304 ) {

					statusText = "notmodified";
					isSuccess = true;

				// If we have data
				} else {

					try {
						success = ajaxConvert( s, response );
						statusText = "success";
						isSuccess = true;
					} catch(e) {
						// We have a parsererror
						statusText = "parsererror";
						error = e;
					}
				}
			} else {
				// We extract error from statusText
				// then normalize statusText and status for non-aborts
				error = statusText;
				if( !statusText || status ) {
					statusText = "error";
					if ( status < 0 ) {
						status = 0;
					}
				}
			}

			// Set data for the fake xhr object
			jqXHR.status = status;
			jqXHR.statusText = statusText;

			// Success/Error
			if ( isSuccess ) {
				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
			} else {
				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
			}

			// Status-dependent callbacks
			jqXHR.statusCode( statusCode );
			statusCode = undefined;

			if ( fireGlobals ) {
				globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
						[ jqXHR, s, isSuccess ? success : error ] );
			}

			// Complete
			completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );

			if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
				// Handle the global AJAX counter
				if ( !( --jQuery.active ) ) {
					jQuery.event.trigger( "ajaxStop" );
				}
			}
		}

		// Attach deferreds
		deferred.promise( jqXHR );
		jqXHR.success = jqXHR.done;
		jqXHR.error = jqXHR.fail;
		jqXHR.complete = completeDeferred.done;

		// Status-dependent callbacks
		jqXHR.statusCode = function( map ) {
			if ( map ) {
				var tmp;
				if ( state < 2 ) {
					for( tmp in map ) {
						statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
					}
				} else {
					tmp = map[ jqXHR.status ];
					jqXHR.then( tmp, tmp );
				}
			}
			return this;
		};

		// Remove hash character (#7531: and string promotion)
		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
		// We also use the url parameter if available
		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );

		// Extract dataTypes list
		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );

		// Determine if a cross-domain request is in order
		if ( !s.crossDomain ) {
			parts = rurl.exec( s.url.toLowerCase() );
			s.crossDomain = !!( parts &&
				( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
			);
		}

		// Convert data if not already a string
		if ( s.data && s.processData && typeof s.data !== "string" ) {
			s.data = jQuery.param( s.data, s.traditional );
		}

		// Apply prefilters
		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

		// If request was aborted inside a prefiler, stop there
		if ( state === 2 ) {
			return false;
		}

		// We can fire global events as of now if asked to
		fireGlobals = s.global;

		// Uppercase the type
		s.type = s.type.toUpperCase();

		// Determine if request has content
		s.hasContent = !rnoContent.test( s.type );

		// Watch for a new set of requests
		if ( fireGlobals && jQuery.active++ === 0 ) {
			jQuery.event.trigger( "ajaxStart" );
		}

		// More options handling for requests with no content
		if ( !s.hasContent ) {

			// If data is available, append data to url
			if ( s.data ) {
				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
			}

			// Get ifModifiedKey before adding the anti-cache parameter
			ifModifiedKey = s.url;

			// Add anti-cache in url if needed
			if ( s.cache === false ) {

				var ts = jQuery.now(),
					// try replacing _= if it is there
					ret = s.url.replace( rts, "$1_=" + ts );

				// if nothing was replaced, add timestamp to the end
				s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
			}
		}

		// Set the correct header, if data is being sent
		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
			requestHeaders[ "Content-Type" ] = s.contentType;
		}

		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
		if ( s.ifModified ) {
			ifModifiedKey = ifModifiedKey || s.url;
			if ( jQuery.lastModified[ ifModifiedKey ] ) {
				requestHeaders[ "If-Modified-Since" ] = jQuery.lastModified[ ifModifiedKey ];
			}
			if ( jQuery.etag[ ifModifiedKey ] ) {
				requestHeaders[ "If-None-Match" ] = jQuery.etag[ ifModifiedKey ];
			}
		}

		// Set the Accepts header for the server, depending on the dataType
		requestHeaders.Accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
			s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
			s.accepts[ "*" ];

		// Check for headers option
		for ( i in s.headers ) {
			jqXHR.setRequestHeader( i, s.headers[ i ] );
		}

		// Allow custom headers/mimetypes and early abort
		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
				// Abort if not done already
				jqXHR.abort();
				return false;

		}

		// Install callbacks on deferreds
		for ( i in { success: 1, error: 1, complete: 1 } ) {
			jqXHR[ i ]( s[ i ] );
		}

		// Get transport
		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

		// If no transport, we auto-abort
		if ( !transport ) {
			done( -1, "No Transport" );
		} else {
			jqXHR.readyState = 1;
			// Send global event
			if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
			}
			// Timeout
			if ( s.async && s.timeout > 0 ) {
				timeoutTimer = setTimeout( function(){
					jqXHR.abort( "timeout" );
				}, s.timeout );
			}

			try {
				state = 1;
				transport.send( requestHeaders, done );
			} catch (e) {
				// Propagate exception as error if not done
				if ( status < 2 ) {
					done( -1, e );
				// Simply rethrow otherwise
				} else {
					jQuery.error( e );
				}
			}
		}

		return jqXHR;
	},

	// Serialize an array of form elements or a set of
	// key/values into a query string
	param: function( a, traditional ) {
		var s = [],
			add = function( key, value ) {
				// If value is a function, invoke it and return its value
				value = jQuery.isFunction( value ) ? value() : value;
				s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
			};

		// Set traditional to true for jQuery <= 1.3.2 behavior.
		if ( traditional === undefined ) {
			traditional = jQuery.ajaxSettings.traditional;
		}

		// If an array was passed in, assume that it is an array of form elements.
		if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
			// Serialize the form elements
			jQuery.each( a, function() {
				add( this.name, this.value );
			} );

		} else {
			// If traditional, encode the "old" way (the way 1.3.2 or older
			// did it), otherwise encode params recursively.
			for ( var prefix in a ) {
				buildParams( prefix, a[ prefix ], traditional, add );
			}
		}

		// Return the resulting serialization
		return s.join( "&" ).replace( r20, "+" );
	}
});

function buildParams( prefix, obj, traditional, add ) {
	if ( jQuery.isArray( obj ) && obj.length ) {
		// Serialize array item.
		jQuery.each( obj, function( i, v ) {
			if ( traditional || rbracket.test( prefix ) ) {
				// Treat each array item as a scalar.
				add( prefix, v );

			} else {
				// If array item is non-scalar (array or object), encode its
				// numeric index to resolve deserialization ambiguity issues.
				// Note that rack (as of 1.0.0) can't currently deserialize
				// nested arrays properly, and attempting to do so may cause
				// a server error. Possible fixes are to modify rack's
				// deserialization algorithm or to provide an option or flag
				// to force array serialization to be shallow.
				buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
			}
		});

	} else if ( !traditional && obj != null && typeof obj === "object" ) {
		// If we see an array here, it is empty and should be treated as an empty
		// object
		if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) {
			add( prefix, "" );

		// Serialize object item.
		} else {
			for ( var name in obj ) {
				buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
			}
		}

	} else {
		// Serialize scalar item.
		add( prefix, obj );
	}
}

// This is still on the jQuery object... for now
// Want to move this to jQuery.ajax some day
jQuery.extend({

	// Counter for holding the number of active queries
	active: 0,

	// Last-Modified header cache for next request
	lastModified: {},
	etag: {}

});

/* Handles responses to an ajax request:
 * - sets all responseXXX fields accordingly
 * - finds the right dataType (mediates between content-type and expected dataType)
 * - returns the corresponding response
 */
function ajaxHandleResponses( s, jqXHR, responses ) {

	var contents = s.contents,
		dataTypes = s.dataTypes,
		responseFields = s.responseFields,
		ct,
		type,
		finalDataType,
		firstDataType;

	// Fill responseXXX fields
	for( type in responseFields ) {
		if ( type in responses ) {
			jqXHR[ responseFields[type] ] = responses[ type ];
		}
	}

	// Remove auto dataType and get content-type in the process
	while( dataTypes[ 0 ] === "*" ) {
		dataTypes.shift();
		if ( ct === undefined ) {
			ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
		}
	}

	// Check if we're dealing with a known content-type
	if ( ct ) {
		for ( type in contents ) {
			if ( contents[ type ] && contents[ type ].test( ct ) ) {
				dataTypes.unshift( type );
				break;
			}
		}
	}

	// Check to see if we have a response for the expected dataType
	if ( dataTypes[ 0 ] in responses ) {
		finalDataType = dataTypes[ 0 ];
	} else {
		// Try convertible dataTypes
		for ( type in responses ) {
			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
				finalDataType = type;
				break;
			}
			if ( !firstDataType ) {
				firstDataType = type;
			}
		}
		// Or just use first one
		finalDataType = finalDataType || firstDataType;
	}

	// If we found a dataType
	// We add the dataType to the list if needed
	// and return the corresponding response
	if ( finalDataType ) {
		if ( finalDataType !== dataTypes[ 0 ] ) {
			dataTypes.unshift( finalDataType );
		}
		return responses[ finalDataType ];
	}
}

// Chain conversions given the request and the original response
function ajaxConvert( s, response ) {

	// Apply the dataFilter if provided
	if ( s.dataFilter ) {
		response = s.dataFilter( response, s.dataType );
	}

	var dataTypes = s.dataTypes,
		converters = {},
		i,
		key,
		length = dataTypes.length,
		tmp,
		// Current and previous dataTypes
		current = dataTypes[ 0 ],
		prev,
		// Conversion expression
		conversion,
		// Conversion function
		conv,
		// Conversion functions (transitive conversion)
		conv1,
		conv2;

	// For each dataType in the chain
	for( i = 1; i < length; i++ ) {

		// Create converters map
		// with lowercased keys
		if ( i === 1 ) {
			for( key in s.converters ) {
				if( typeof key === "string" ) {
					converters[ key.toLowerCase() ] = s.converters[ key ];
				}
			}
		}

		// Get the dataTypes
		prev = current;
		current = dataTypes[ i ];

		// If current is auto dataType, update it to prev
		if( current === "*" ) {
			current = prev;
		// If no auto and dataTypes are actually different
		} else if ( prev !== "*" && prev !== current ) {

			// Get the converter
			conversion = prev + " " + current;
			conv = converters[ conversion ] || converters[ "* " + current ];

			// If there is no direct converter, search transitively
			if ( !conv ) {
				conv2 = undefined;
				for( conv1 in converters ) {
					tmp = conv1.split( " " );
					if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
						conv2 = converters[ tmp[1] + " " + current ];
						if ( conv2 ) {
							conv1 = converters[ conv1 ];
							if ( conv1 === true ) {
								conv = conv2;
							} else if ( conv2 === true ) {
								conv = conv1;
							}
							break;
						}
					}
				}
			}
			// If we found no converter, dispatch an error
			if ( !( conv || conv2 ) ) {
				jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
			}
			// If found converter is not an equivalence
			if ( conv !== true ) {
				// Convert with 1 or 2 converters accordingly
				response = conv ? conv( response ) : conv2( conv1(response) );
			}
		}
	}
	return response;
}




var jsc = jQuery.now(),
	jsre = /(\=)\?(&|$)|()\?\?()/i;

// Default jsonp settings
jQuery.ajaxSetup({
	jsonp: "callback",
	jsonpCallback: function() {
		return jQuery.expando + "_" + ( jsc++ );
	}
});

// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

	var dataIsString = ( typeof s.data === "string" );

	if ( s.dataTypes[ 0 ] === "jsonp" ||
		originalSettings.jsonpCallback ||
		originalSettings.jsonp != null ||
		s.jsonp !== false && ( jsre.test( s.url ) ||
				dataIsString && jsre.test( s.data ) ) ) {

		var responseContainer,
			jsonpCallback = s.jsonpCallback =
				jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
			previous = window[ jsonpCallback ],
			url = s.url,
			data = s.data,
			replace = "$1" + jsonpCallback + "$2",
			cleanUp = function() {
				// Set callback back to previous value
				window[ jsonpCallback ] = previous;
				// Call if it was a function and we have a response
				if ( responseContainer && jQuery.isFunction( previous ) ) {
					window[ jsonpCallback ]( responseContainer[ 0 ] );
				}
			};

		if ( s.jsonp !== false ) {
			url = url.replace( jsre, replace );
			if ( s.url === url ) {
				if ( dataIsString ) {
					data = data.replace( jsre, replace );
				}
				if ( s.data === data ) {
					// Add callback manually
					url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
				}
			}
		}

		s.url = url;
		s.data = data;

		// Install callback
		window[ jsonpCallback ] = function( response ) {
			responseContainer = [ response ];
		};

		// Install cleanUp function
		jqXHR.then( cleanUp, cleanUp );

		// Use data converter to retrieve json after script execution
		s.converters["script json"] = function() {
			if ( !responseContainer ) {
				jQuery.error( jsonpCallback + " was not called" );
			}
			return responseContainer[ 0 ];
		};

		// force json dataType
		s.dataTypes[ 0 ] = "json";

		// Delegate to script
		return "script";
	}
} );




// Install script dataType
jQuery.ajaxSetup({
	accepts: {
		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /javascript|ecmascript/
	},
	converters: {
		"text script": function( text ) {
			jQuery.globalEval( text );
			return text;
		}
	}
});

// Handle cache's special case and global
jQuery.ajaxPrefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossDomain ) {
		s.type = "GET";
		s.global = false;
	}
} );

// Bind script tag hack transport
jQuery.ajaxTransport( "script", function(s) {

	// This transport only deals with cross domain requests
	if ( s.crossDomain ) {

		var script,
			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;

		return {

			send: function( _, callback ) {

				script = document.createElement( "script" );

				script.async = "async";

				if ( s.scriptCharset ) {
					script.charset = s.scriptCharset;
				}

				script.src = s.url;

				// Attach handlers for all browsers
				script.onload = script.onreadystatechange = function( _, isAbort ) {

					if ( !script.readyState || /loaded|complete/.test( script.readyState ) ) {

						// Handle memory leak in IE
						script.onload = script.onreadystatechange = null;

						// Remove the script
						if ( head && script.parentNode ) {
							head.removeChild( script );
						}

						// Dereference the script
						script = undefined;

						// Callback if not abort
						if ( !isAbort ) {
							callback( 200, "success" );
						}
					}
				};
				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
				// This arises when a base node is used (#2709 and #4378).
				head.insertBefore( script, head.firstChild );
			},

			abort: function() {
				if ( script ) {
					script.onload( 0, 1 );
				}
			}
		};
	}
} );




var // #5280: next active xhr id and list of active xhrs' callbacks
	xhrId = jQuery.now(),
	xhrCallbacks,

	// XHR used to determine supports properties
	testXHR;

// #5280: Internet Explorer will keep connections alive if we don't abort on unload
function xhrOnUnloadAbort() {
	jQuery( window ).unload(function() {
		// Abort all pending requests
		for ( var key in xhrCallbacks ) {
			xhrCallbacks[ key ]( 0, 1 );
		}
	});
}

// Functions to create xhrs
function createStandardXHR() {
	try {
		return new window.XMLHttpRequest();
	} catch( e ) {}
}

function createActiveXHR() {
	try {
		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
	} catch( e ) {}
}

// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
	/* Microsoft failed to properly
	 * implement the XMLHttpRequest in IE7 (can't request local files),
	 * so we use the ActiveXObject when it is available
	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
	 * we need a fallback.
	 */
	function() {
		return !this.isLocal && createStandardXHR() || createActiveXHR();
	} :
	// For all other browsers, use the standard XMLHttpRequest object
	createStandardXHR;

// Test if we can create an xhr object
testXHR = jQuery.ajaxSettings.xhr();
jQuery.support.ajax = !!testXHR;

// Does this browser support crossDomain XHR requests
jQuery.support.cors = testXHR && ( "withCredentials" in testXHR );

// No need for the temporary xhr anymore
testXHR = undefined;

// Create transport if the browser can provide an xhr
if ( jQuery.support.ajax ) {

	jQuery.ajaxTransport(function( s ) {
		// Cross domain only allowed if supported through XMLHttpRequest
		if ( !s.crossDomain || jQuery.support.cors ) {

			var callback;

			return {
				send: function( headers, complete ) {

					// Get a new xhr
					var xhr = s.xhr(),
						handle,
						i;

					// Open the socket
					// Passing null username, generates a login popup on Opera (#2865)
					if ( s.username ) {
						xhr.open( s.type, s.url, s.async, s.username, s.password );
					} else {
						xhr.open( s.type, s.url, s.async );
					}

					// Apply custom fields if provided
					if ( s.xhrFields ) {
						for ( i in s.xhrFields ) {
							xhr[ i ] = s.xhrFields[ i ];
						}
					}

					// Override mime type if needed
					if ( s.mimeType && xhr.overrideMimeType ) {
						xhr.overrideMimeType( s.mimeType );
					}

					// Requested-With header
					// Not set for crossDomain requests with no content
					// (see why at http://trac.dojotoolkit.org/ticket/9486)
					// Won't change header if already provided
					if ( !( s.crossDomain && !s.hasContent ) && !headers["X-Requested-With"] ) {
						headers[ "X-Requested-With" ] = "XMLHttpRequest";
					}

					// Need an extra try/catch for cross domain requests in Firefox 3
					try {
						for ( i in headers ) {
							xhr.setRequestHeader( i, headers[ i ] );
						}
					} catch( _ ) {}

					// Do send the request
					// This may raise an exception which is actually
					// handled in jQuery.ajax (so no try/catch here)
					xhr.send( ( s.hasContent && s.data ) || null );

					// Listener
					callback = function( _, isAbort ) {

						var status,
							statusText,
							responseHeaders,
							responses,
							xml;

						// Firefox throws exceptions when accessing properties
						// of an xhr when a network error occured
						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
						try {

							// Was never called and is aborted or complete
							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {

								// Only called once
								callback = undefined;

								// Do not keep as active anymore
								if ( handle ) {
									xhr.onreadystatechange = jQuery.noop;
									delete xhrCallbacks[ handle ];
								}

								// If it's an abort
								if ( isAbort ) {
									// Abort it manually if needed
									if ( xhr.readyState !== 4 ) {
										xhr.abort();
									}
								} else {
									status = xhr.status;
									responseHeaders = xhr.getAllResponseHeaders();
									responses = {};
									xml = xhr.responseXML;

									// Construct response list
									if ( xml && xml.documentElement /* #4958 */ ) {
										responses.xml = xml;
									}
									responses.text = xhr.responseText;

									// Firefox throws an exception when accessing
									// statusText for faulty cross-domain requests
									try {
										statusText = xhr.statusText;
									} catch( e ) {
										// We normalize with Webkit giving an empty statusText
										statusText = "";
									}

									// Filter status for non standard behaviors

									// If the request is local and we have data: assume a success
									// (success with no data won't get notified, that's the best we
									// can do given current implementations)
									if ( !status && s.isLocal && !s.crossDomain ) {
										status = responses.text ? 200 : 404;
									// IE - #1450: sometimes returns 1223 when it should be 204
									} else if ( status === 1223 ) {
										status = 204;
									}
								}
							}
						} catch( firefoxAccessException ) {
							if ( !isAbort ) {
								complete( -1, firefoxAccessException );
							}
						}

						// Call complete if needed
						if ( responses ) {
							complete( status, statusText, responses, responseHeaders );
						}
					};

					// if we're in sync mode or it's in cache
					// and has been retrieved directly (IE6 & IE7)
					// we need to manually fire the callback
					if ( !s.async || xhr.readyState === 4 ) {
						callback();
					} else {
						// Create the active xhrs callbacks list if needed
						// and attach the unload handler
						if ( !xhrCallbacks ) {
							xhrCallbacks = {};
							xhrOnUnloadAbort();
						}
						// Add to list of active xhrs callbacks
						handle = xhrId++;
						xhr.onreadystatechange = xhrCallbacks[ handle ] = callback;
					}
				},

				abort: function() {
					if ( callback ) {
						callback(0,1);
					}
				}
			};
		}
	});
}




var elemdisplay = {},
	rfxtypes = /^(?:toggle|show|hide)$/,
	rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
	timerId,
	fxAttrs = [
		// height animations
		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
		// width animations
		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
		// opacity animations
		[ "opacity" ]
	];

jQuery.fn.extend({
	show: function( speed, easing, callback ) {
		var elem, display;

		if ( speed || speed === 0 ) {
			return this.animate( genFx("show", 3), speed, easing, callback);

		} else {
			for ( var i = 0, j = this.length; i < j; i++ ) {
				elem = this[i];
				display = elem.style.display;

				// Reset the inline display of this element to learn if it is
				// being hidden by cascaded rules or not
				if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
					display = elem.style.display = "";
				}

				// Set elements which have been overridden with display: none
				// in a stylesheet to whatever the default browser style is
				// for such an element
				if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
					jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
				}
			}

			// Set the display of most of the elements in a second loop
			// to avoid the constant reflow
			for ( i = 0; i < j; i++ ) {
				elem = this[i];
				display = elem.style.display;

				if ( display === "" || display === "none" ) {
					elem.style.display = jQuery._data(elem, "olddisplay") || "";
				}
			}

			return this;
		}
	},

	hide: function( speed, easing, callback ) {
		if ( speed || speed === 0 ) {
			return this.animate( genFx("hide", 3), speed, easing, callback);

		} else {
			for ( var i = 0, j = this.length; i < j; i++ ) {
				var display = jQuery.css( this[i], "display" );

				if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
					jQuery._data( this[i], "olddisplay", display );
				}
			}

			// Set the display of the elements in a second loop
			// to avoid the constant reflow
			for ( i = 0; i < j; i++ ) {
				this[i].style.display = "none";
			}

			return this;
		}
	},

	// Save the old toggle function
	_toggle: jQuery.fn.toggle,

	toggle: function( fn, fn2, callback ) {
		var bool = typeof fn === "boolean";

		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
			this._toggle.apply( this, arguments );

		} else if ( fn == null || bool ) {
			this.each(function() {
				var state = bool ? fn : jQuery(this).is(":hidden");
				jQuery(this)[ state ? "show" : "hide" ]();
			});

		} else {
			this.animate(genFx("toggle", 3), fn, fn2, callback);
		}

		return this;
	},

	fadeTo: function( speed, to, easing, callback ) {
		return this.filter(":hidden").css("opacity", 0).show().end()
					.animate({opacity: to}, speed, easing, callback);
	},

	animate: function( prop, speed, easing, callback ) {
		var optall = jQuery.speed(speed, easing, callback);

		if ( jQuery.isEmptyObject( prop ) ) {
			return this.each( optall.complete );
		}

		return this[ optall.queue === false ? "each" : "queue" ](function() {
			// XXX 'this' does not always have a nodeName when running the
			// test suite

			var opt = jQuery.extend({}, optall), p,
				isElement = this.nodeType === 1,
				hidden = isElement && jQuery(this).is(":hidden"),
				self = this;

			for ( p in prop ) {
				var name = jQuery.camelCase( p );

				if ( p !== name ) {
					prop[ name ] = prop[ p ];
					delete prop[ p ];
					p = name;
				}

				if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
					return opt.complete.call(this);
				}

				if ( isElement && ( p === "height" || p === "width" ) ) {
					// Make sure that nothing sneaks out
					// Record all 3 overflow attributes because IE does not
					// change the overflow attribute when overflowX and
					// overflowY are set to the same value
					opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];

					// Set display property to inline-block for height/width
					// animations on inline elements that are having width/height
					// animated
					if ( jQuery.css( this, "display" ) === "inline" &&
							jQuery.css( this, "float" ) === "none" ) {
						if ( !jQuery.support.inlineBlockNeedsLayout ) {
							this.style.display = "inline-block";

						} else {
							var display = defaultDisplay(this.nodeName);

							// inline-level elements accept inline-block;
							// block-level elements need to be inline with layout
							if ( display === "inline" ) {
								this.style.display = "inline-block";

							} else {
								this.style.display = "inline";
								this.style.zoom = 1;
							}
						}
					}
				}

				if ( jQuery.isArray( prop[p] ) ) {
					// Create (if needed) and add to specialEasing
					(opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
					prop[p] = prop[p][0];
				}
			}

			if ( opt.overflow != null ) {
				this.style.overflow = "hidden";
			}

			opt.curAnim = jQuery.extend({}, prop);

			jQuery.each( prop, function( name, val ) {
				var e = new jQuery.fx( self, opt, name );

				if ( rfxtypes.test(val) ) {
					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );

				} else {
					var parts = rfxnum.exec(val),
						start = e.cur();

					if ( parts ) {
						var end = parseFloat( parts[2] ),
							unit = parts[3] || ( jQuery.cssNumber[ name ] ? "" : "px" );

						// We need to compute starting value
						if ( unit !== "px" ) {
							jQuery.style( self, name, (end || 1) + unit);
							start = ((end || 1) / e.cur()) * start;
							jQuery.style( self, name, start + unit);
						}

						// If a +=/-= token was provided, we're doing a relative animation
						if ( parts[1] ) {
							end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
						}

						e.custom( start, end, unit );

					} else {
						e.custom( start, val, "" );
					}
				}
			});

			// For JS strict compliance
			return true;
		});
	},

	stop: function( clearQueue, gotoEnd ) {
		var timers = jQuery.timers;

		if ( clearQueue ) {
			this.queue([]);
		}

		this.each(function() {
			// go in reverse order so anything added to the queue during the loop is ignored
			for ( var i = timers.length - 1; i >= 0; i-- ) {
				if ( timers[i].elem === this ) {
					if (gotoEnd) {
						// force the next step to be the last
						timers[i](true);
					}

					timers.splice(i, 1);
				}
			}
		});

		// start the next in the queue if the last step wasn't forced
		if ( !gotoEnd ) {
			this.dequeue();
		}

		return this;
	}

});

function genFx( type, num ) {
	var obj = {};

	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
		obj[ this ] = type;
	});

	return obj;
}

// Generate shortcuts for custom animations
jQuery.each({
	slideDown: genFx("show", 1),
	slideUp: genFx("hide", 1),
	slideToggle: genFx("toggle", 1),
	fadeIn: { opacity: "show" },
	fadeOut: { opacity: "hide" },
	fadeToggle: { opacity: "toggle" }
}, function( name, props ) {
	jQuery.fn[ name ] = function( speed, easing, callback ) {
		return this.animate( props, speed, easing, callback );
	};
});

jQuery.extend({
	speed: function( speed, easing, fn ) {
		var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
			complete: fn || !fn && easing ||
				jQuery.isFunction( speed ) && speed,
			duration: speed,
			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
		};

		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;

		// Queueing
		opt.old = opt.complete;
		opt.complete = function() {
			if ( opt.queue !== false ) {
				jQuery(this).dequeue();
			}
			if ( jQuery.isFunction( opt.old ) ) {
				opt.old.call( this );
			}
		};

		return opt;
	},

	easing: {
		linear: function( p, n, firstNum, diff ) {
			return firstNum + diff * p;
		},
		swing: function( p, n, firstNum, diff ) {
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
		}
	},

	timers: [],

	fx: function( elem, options, prop ) {
		this.options = options;
		this.elem = elem;
		this.prop = prop;

		if ( !options.orig ) {
			options.orig = {};
		}
	}

});

jQuery.fx.prototype = {
	// Simple function for setting a style value
	update: function() {
		if ( this.options.step ) {
			this.options.step.call( this.elem, this.now, this );
		}

		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
	},

	// Get the current size
	cur: function() {
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
			return this.elem[ this.prop ];
		}

		var parsed,
			r = jQuery.css( this.elem, this.prop );
		// Empty strings, null, undefined and "auto" are converted to 0,
		// complex values such as "rotate(1rad)" are returned as is,
		// simple values such as "10px" are parsed to Float.
		return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
	},

	// Start an animation from one number to another
	custom: function( from, to, unit ) {
		var self = this,
			fx = jQuery.fx;

		this.startTime = jQuery.now();
		this.start = from;
		this.end = to;
		this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
		this.now = this.start;
		this.pos = this.state = 0;

		function t( gotoEnd ) {
			return self.step(gotoEnd);
		}

		t.elem = this.elem;

		if ( t() && jQuery.timers.push(t) && !timerId ) {
			timerId = setInterval(fx.tick, fx.interval);
		}
	},

	// Simple 'show' function
	show: function() {
		// Remember where we started, so that we can go back to it later
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
		this.options.show = true;

		// Begin the animation
		// Make sure that we start at a small width/height to avoid any
		// flash of content
		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());

		// Start by showing the element
		jQuery( this.elem ).show();
	},

	// Simple 'hide' function
	hide: function() {
		// Remember where we started, so that we can go back to it later
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
		this.options.hide = true;

		// Begin the animation
		this.custom(this.cur(), 0);
	},

	// Each step of an animation
	step: function( gotoEnd ) {
		var t = jQuery.now(), done = true;

		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
			this.now = this.end;
			this.pos = this.state = 1;
			this.update();

			this.options.curAnim[ this.prop ] = true;

			for ( var i in this.options.curAnim ) {
				if ( this.options.curAnim[i] !== true ) {
					done = false;
				}
			}

			if ( done ) {
				// Reset the overflow
				if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
					var elem = this.elem,
						options = this.options;

					jQuery.each( [ "", "X", "Y" ], function (index, value) {
						elem.style[ "overflow" + value ] = options.overflow[index];
					} );
				}

				// Hide the element if the "hide" operation was done
				if ( this.options.hide ) {
					jQuery(this.elem).hide();
				}

				// Reset the properties, if the item has been hidden or shown
				if ( this.options.hide || this.options.show ) {
					for ( var p in this.options.curAnim ) {
						jQuery.style( this.elem, p, this.options.orig[p] );
					}
				}

				// Execute the complete function
				this.options.complete.call( this.elem );
			}

			return false;

		} else {
			var n = t - this.startTime;
			this.state = n / this.options.duration;

			// Perform the easing function, defaults to swing
			var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
			var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
			this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
			this.now = this.start + ((this.end - this.start) * this.pos);

			// Perform the next step of the animation
			this.update();
		}

		return true;
	}
};

jQuery.extend( jQuery.fx, {
	tick: function() {
		var timers = jQuery.timers;

		for ( var i = 0; i < timers.length; i++ ) {
			if ( !timers[i]() ) {
				timers.splice(i--, 1);
			}
		}

		if ( !timers.length ) {
			jQuery.fx.stop();
		}
	},

	interval: 13,

	stop: function() {
		clearInterval( timerId );
		timerId = null;
	},

	speeds: {
		slow: 600,
		fast: 200,
		// Default speed
		_default: 400
	},

	step: {
		opacity: function( fx ) {
			jQuery.style( fx.elem, "opacity", fx.now );
		},

		_default: function( fx ) {
			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
			} else {
				fx.elem[ fx.prop ] = fx.now;
			}
		}
	}
});

if ( jQuery.expr && jQuery.expr.filters ) {
	jQuery.expr.filters.animated = function( elem ) {
		return jQuery.grep(jQuery.timers, function( fn ) {
			return elem === fn.elem;
		}).length;
	};
}

function defaultDisplay( nodeName ) {
	if ( !elemdisplay[ nodeName ] ) {
		var elem = jQuery("<" + nodeName + ">").appendTo("body"),
			display = elem.css("display");

		elem.remove();

		if ( display === "none" || display === "" ) {
			display = "block";
		}

		elemdisplay[ nodeName ] = display;
	}

	return elemdisplay[ nodeName ];
}




var rtable = /^t(?:able|d|h)$/i,
	rroot = /^(?:body|html)$/i;

if ( "getBoundingClientRect" in document.documentElement ) {
	jQuery.fn.offset = function( options ) {
		var elem = this[0], box;

		if ( options ) {
			return this.each(function( i ) {
				jQuery.offset.setOffset( this, options, i );
			});
		}

		if ( !elem || !elem.ownerDocument ) {
			return null;
		}

		if ( elem === elem.ownerDocument.body ) {
			return jQuery.offset.bodyOffset( elem );
		}

		try {
			box = elem.getBoundingClientRect();
		} catch(e) {}

		var doc = elem.ownerDocument,
			docElem = doc.documentElement;

		// Make sure we're not dealing with a disconnected DOM node
		if ( !box || !jQuery.contains( docElem, elem ) ) {
			return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
		}

		var body = doc.body,
			win = getWindow(doc),
			clientTop  = docElem.clientTop  || body.clientTop  || 0,
			clientLeft = docElem.clientLeft || body.clientLeft || 0,
			scrollTop  = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ),
			scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
			top  = box.top  + scrollTop  - clientTop,
			left = box.left + scrollLeft - clientLeft;

		return { top: top, left: left };
	};

} else {
	jQuery.fn.offset = function( options ) {
		var elem = this[0];

		if ( options ) {
			return this.each(function( i ) {
				jQuery.offset.setOffset( this, options, i );
			});
		}

		if ( !elem || !elem.ownerDocument ) {
			return null;
		}

		if ( elem === elem.ownerDocument.body ) {
			return jQuery.offset.bodyOffset( elem );
		}

		jQuery.offset.initialize();

		var computedStyle,
			offsetParent = elem.offsetParent,
			prevOffsetParent = elem,
			doc = elem.ownerDocument,
			docElem = doc.documentElement,
			body = doc.body,
			defaultView = doc.defaultView,
			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
			top = elem.offsetTop,
			left = elem.offsetLeft;

		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
				break;
			}

			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
			top  -= elem.scrollTop;
			left -= elem.scrollLeft;

			if ( elem === offsetParent ) {
				top  += elem.offsetTop;
				left += elem.offsetLeft;

				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
				}

				prevOffsetParent = offsetParent;
				offsetParent = elem.offsetParent;
			}

			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
			}

			prevComputedStyle = computedStyle;
		}

		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
			top  += body.offsetTop;
			left += body.offsetLeft;
		}

		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
			top  += Math.max( docElem.scrollTop, body.scrollTop );
			left += Math.max( docElem.scrollLeft, body.scrollLeft );
		}

		return { top: top, left: left };
	};
}

jQuery.offset = {
	initialize: function() {
		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
			html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";

		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );

		container.innerHTML = html;
		body.insertBefore( container, body.firstChild );
		innerDiv = container.firstChild;
		checkDiv = innerDiv.firstChild;
		td = innerDiv.nextSibling.firstChild.firstChild;

		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);

		checkDiv.style.position = "fixed";
		checkDiv.style.top = "20px";

		// safari subtracts parent border width here which is 5px
		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
		checkDiv.style.position = checkDiv.style.top = "";

		innerDiv.style.overflow = "hidden";
		innerDiv.style.position = "relative";

		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);

		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);

		body.removeChild( container );
		body = container = innerDiv = checkDiv = table = td = null;
		jQuery.offset.initialize = jQuery.noop;
	},

	bodyOffset: function( body ) {
		var top = body.offsetTop,
			left = body.offsetLeft;

		jQuery.offset.initialize();

		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
			top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
			left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
		}

		return { top: top, left: left };
	},

	setOffset: function( elem, options, i ) {
		var position = jQuery.css( elem, "position" );

		// set position first, in-case top/left are set even on static elem
		if ( position === "static" ) {
			elem.style.position = "relative";
		}

		var curElem = jQuery( elem ),
			curOffset = curElem.offset(),
			curCSSTop = jQuery.css( elem, "top" ),
			curCSSLeft = jQuery.css( elem, "left" ),
			calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
			props = {}, curPosition = {}, curTop, curLeft;

		// need to be able to calculate position if either top or left is auto and position is absolute
		if ( calculatePosition ) {
			curPosition = curElem.position();
		}

		curTop  = calculatePosition ? curPosition.top  : parseInt( curCSSTop,  10 ) || 0;
		curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0;

		if ( jQuery.isFunction( options ) ) {
			options = options.call( elem, i, curOffset );
		}

		if (options.top != null) {
			props.top = (options.top - curOffset.top) + curTop;
		}
		if (options.left != null) {
			props.left = (options.left - curOffset.left) + curLeft;
		}

		if ( "using" in options ) {
			options.using.call( elem, props );
		} else {
			curElem.css( props );
		}
	}
};


jQuery.fn.extend({
	position: function() {
		if ( !this[0] ) {
			return null;
		}

		var elem = this[0],

		// Get *real* offsetParent
		offsetParent = this.offsetParent(),

		// Get correct offsets
		offset       = this.offset(),
		parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();

		// Subtract element margins
		// note: when an element has margin: auto the offsetLeft and marginLeft
		// are the same in Safari causing offset.left to incorrectly be 0
		offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
		offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;

		// Add offsetParent borders
		parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
		parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;

		// Subtract the two offsets
		return {
			top:  offset.top  - parentOffset.top,
			left: offset.left - parentOffset.left
		};
	},

	offsetParent: function() {
		return this.map(function() {
			var offsetParent = this.offsetParent || document.body;
			while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
				offsetParent = offsetParent.offsetParent;
			}
			return offsetParent;
		});
	}
});


// Create scrollLeft and scrollTop methods
jQuery.each( ["Left", "Top"], function( i, name ) {
	var method = "scroll" + name;

	jQuery.fn[ method ] = function(val) {
		var elem = this[0], win;

		if ( !elem ) {
			return null;
		}

		if ( val !== undefined ) {
			// Set the scroll offset
			return this.each(function() {
				win = getWindow( this );

				if ( win ) {
					win.scrollTo(
						!i ? val : jQuery(win).scrollLeft(),
						i ? val : jQuery(win).scrollTop()
					);

				} else {
					this[ method ] = val;
				}
			});
		} else {
			win = getWindow( elem );

			// Return the scroll offset
			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
				jQuery.support.boxModel && win.document.documentElement[ method ] ||
					win.document.body[ method ] :
				elem[ method ];
		}
	};
});

function getWindow( elem ) {
	return jQuery.isWindow( elem ) ?
		elem :
		elem.nodeType === 9 ?
			elem.defaultView || elem.parentWindow :
			false;
}




// Create innerHeight, innerWidth, outerHeight and outerWidth methods
jQuery.each([ "Height", "Width" ], function( i, name ) {

	var type = name.toLowerCase();

	// innerHeight and innerWidth
	jQuery.fn["inner" + name] = function() {
		return this[0] ?
			parseFloat( jQuery.css( this[0], type, "padding" ) ) :
			null;
	};

	// outerHeight and outerWidth
	jQuery.fn["outer" + name] = function( margin ) {
		return this[0] ?
			parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
			null;
	};

	jQuery.fn[ type ] = function( size ) {
		// Get window width or height
		var elem = this[0];
		if ( !elem ) {
			return size == null ? null : this;
		}

		if ( jQuery.isFunction( size ) ) {
			return this.each(function( i ) {
				var self = jQuery( this );
				self[ type ]( size.call( this, i, self[ type ]() ) );
			});
		}

		if ( jQuery.isWindow( elem ) ) {
			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
			// 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
			var docElemProp = elem.document.documentElement[ "client" + name ];
			return elem.document.compatMode === "CSS1Compat" && docElemProp ||
				elem.document.body[ "client" + name ] || docElemProp;

		// Get document width or height
		} else if ( elem.nodeType === 9 ) {
			// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
			return Math.max(
				elem.documentElement["client" + name],
				elem.body["scroll" + name], elem.documentElement["scroll" + name],
				elem.body["offset" + name], elem.documentElement["offset" + name]
			);

		// Get or set width or height on the element
		} else if ( size === undefined ) {
			var orig = jQuery.css( elem, type ),
				ret = parseFloat( orig );

			return jQuery.isNaN( ret ) ? orig : ret;

		// Set the width or height on the element (default to pixels if value is unitless)
		} else {
			return this.css( type, typeof size === "string" ? size : size + "px" );
		}
	};

});


window.jQuery = window.$ = jQuery;
})(window);
;
/*!
 * jQuery resize event - v1.1 - 3/14/2010
 * http://benalman.com/projects/jquery-resize-plugin/
 * 
 * Copyright (c) 2010 "Cowboy" Ben Alman
 * Dual licensed under the MIT and GPL licenses.
 * http://benalman.com/about/license/
 */

// Script: jQuery resize event
//
// *Version: 1.1, Last updated: 3/14/2010*
// 
// Project Home - http://benalman.com/projects/jquery-resize-plugin/
// GitHub       - http://github.com/cowboy/jquery-resize/
// Source       - http://github.com/cowboy/jquery-resize/raw/master/jquery.ba-resize.js
// (Minified)   - http://github.com/cowboy/jquery-resize/raw/master/jquery.ba-resize.min.js (1.0kb)
// 
// About: License
// 
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
// 
// About: Examples
// 
// This working example, complete with fully commented code, illustrates a few
// ways in which this plugin can be used.
// 
// resize event - http://benalman.com/code/projects/jquery-resize/examples/resize/
// 
// About: Support and Testing
// 
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
// 
// jQuery Versions - 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-3.6, Safari 3-4, Chrome, Opera 9.6-10.1.
// Unit Tests      - http://benalman.com/code/projects/jquery-resize/unit/
// 
// About: Release History
// 
// 1.1 - (3/14/2010) Fixed a minor bug that was causing the event to trigger
//       immediately after bind in some circumstances. Also changed $.fn.data
//       to $.data to improve performance.
// 1.0 - (2/10/2010) Initial release

(function($,window,undefined){
  '$:nomunge'; // Used by YUI compressor.
  
  // A jQuery object containing all non-window elements to which the resize
  // event is bound.
  var elems = $([]),
    
    // Extend $.resize if it already exists, otherwise create it.
    jq_resize = $.resize = $.extend( $.resize, {} ),
    
    timeout_id,
    
    // Reused strings.
    str_setTimeout = 'setTimeout',
    str_resize = 'resize',
    str_data = str_resize + '-special-event',
    str_delay = 'delay',
    str_throttle = 'throttleWindow';
  
  // Property: jQuery.resize.delay
  // 
  // The numeric interval (in milliseconds) at which the resize event polling
  // loop executes. Defaults to 250.
  
  jq_resize[ str_delay ] = 250;
  
  // Property: jQuery.resize.throttleWindow
  // 
  // Throttle the native window object resize event to fire no more than once
  // every <jQuery.resize.delay> milliseconds. Defaults to true.
  // 
  // Because the window object has its own resize event, it doesn't need to be
  // provided by this plugin, and its execution can be left entirely up to the
  // browser. However, since certain browsers fire the resize event continuously
  // while others do not, enabling this will throttle the window resize event,
  // making event behavior consistent across all elements in all browsers.
  // 
  // While setting this property to false will disable window object resize
  // event throttling, please note that this property must be changed before any
  // window object resize event callbacks are bound.
  
  jq_resize[ str_throttle ] = true;
  
  // Event: resize event
  // 
  // Fired when an element's width or height changes. Because browsers only
  // provide this event for the window element, for other elements a polling
  // loop is initialized, running every <jQuery.resize.delay> milliseconds
  // to see if elements' dimensions have changed. You may bind with either
  // .resize( fn ) or .bind( "resize", fn ), and unbind with .unbind( "resize" ).
  // 
  // Usage:
  // 
  // > jQuery('selector').bind( 'resize', function(e) {
  // >   // element's width or height has changed!
  // >   ...
  // > });
  // 
  // Additional Notes:
  // 
  // * The polling loop is not created until at least one callback is actually
  //   bound to the 'resize' event, and this single polling loop is shared
  //   across all elements.
  // 
  // Double firing issue in jQuery 1.3.2:
  // 
  // While this plugin works in jQuery 1.3.2, if an element's event callbacks
  // are manually triggered via .trigger( 'resize' ) or .resize() those
  // callbacks may double-fire, due to limitations in the jQuery 1.3.2 special
  // events system. This is not an issue when using jQuery 1.4+.
  // 
  // > // While this works in jQuery 1.4+
  // > $(elem).css({ width: new_w, height: new_h }).resize();
  // > 
  // > // In jQuery 1.3.2, you need to do this:
  // > var elem = $(elem);
  // > elem.css({ width: new_w, height: new_h });
  // > elem.data( 'resize-special-event', { width: elem.width(), height: elem.height() } );
  // > elem.resize();
      
  $.event.special[ str_resize ] = {
    
    // Called only when the first 'resize' event callback is bound per element.
    setup: function() {
      // Since window has its own native 'resize' event, return false so that
      // jQuery will bind the event using DOM methods. Since only 'window'
      // objects have a .setTimeout method, this should be a sufficient test.
      // Unless, of course, we're throttling the 'resize' event for window.
      if ( !jq_resize[ str_throttle ] && this[ str_setTimeout ] ) { return false; }
      
      var elem = $(this);
      
      // Add this element to the list of internal elements to monitor.
      elems = elems.add( elem );
      
      // Initialize data store on the element.
      $.data( this, str_data, { w: elem.width(), h: elem.height() } );
      
      // If this is the first element added, start the polling loop.
      if ( elems.length === 1 ) {
        loopy();
      }
    },
    
    // Called only when the last 'resize' event callback is unbound per element.
    teardown: function() {
      // Since window has its own native 'resize' event, return false so that
      // jQuery will unbind the event using DOM methods. Since only 'window'
      // objects have a .setTimeout method, this should be a sufficient test.
      // Unless, of course, we're throttling the 'resize' event for window.
      if ( !jq_resize[ str_throttle ] && this[ str_setTimeout ] ) { return false; }
      
      var elem = $(this);
      
      // Remove this element from the list of internal elements to monitor.
      elems = elems.not( elem );
      
      // Remove any data stored on the element.
      elem.removeData( str_data );
      
      // If this is the last element removed, stop the polling loop.
      if ( !elems.length ) {
        clearTimeout( timeout_id );
      }
    },
    
    // Called every time a 'resize' event callback is bound per element (new in
    // jQuery 1.4).
    add: function( handleObj ) {
      // Since window has its own native 'resize' event, return false so that
      // jQuery doesn't modify the event object. Unless, of course, we're
      // throttling the 'resize' event for window.
      if ( !jq_resize[ str_throttle ] && this[ str_setTimeout ] ) { return false; }
      
      var old_handler;
      
      // The new_handler function is executed every time the event is triggered.
      // This is used to update the internal element data store with the width
      // and height when the event is triggered manually, to avoid double-firing
      // of the event callback. See the "Double firing issue in jQuery 1.3.2"
      // comments above for more information.
      
      function new_handler( e, w, h ) {
        var elem = $(this),
          data = $.data( this, str_data );
        
        // If called from the polling loop, w and h will be passed in as
        // arguments. If called manually, via .trigger( 'resize' ) or .resize(),
        // those values will need to be computed.
        data.w = w !== undefined ? w : elem.width();
        data.h = h !== undefined ? h : elem.height();
        
        old_handler.apply( this, arguments );
      };
      
      // This may seem a little complicated, but it normalizes the special event
      // .add method between jQuery 1.4/1.4.1 and 1.4.2+
      if ( $.isFunction( handleObj ) ) {
        // 1.4, 1.4.1
        old_handler = handleObj;
        return new_handler;
      } else {
        // 1.4.2+
        old_handler = handleObj.handler;
        handleObj.handler = new_handler;
      }
    }
    
  };
  
  function loopy() {
    
    // Start the polling loop, asynchronously.
    timeout_id = window[ str_setTimeout ](function(){
      
      // Iterate over all elements to which the 'resize' event is bound.
      elems.each(function(){
        var elem = $(this),
          width = elem.width(),
          height = elem.height(),
          data = $.data( this, str_data );
        
        // If element size has changed since the last time, update the element
        // data store and trigger the 'resize' event.
        if ( width !== data.w || height !== data.h ) {
          elem.trigger( str_resize, [ data.w = width, data.h = height ] );
        }
        
      });
      
      // Loop.
      loopy();
      
    }, jq_resize[ str_delay ] );
    
  };
  
})(jQuery,this);
;
/*!
 * jQuery BBQ: Back Button & Query Library - v1.2.1 - 2/17/2010
 * http://benalman.com/projects/jquery-bbq-plugin/
 * 
 * Copyright (c) 2010 "Cowboy" Ben Alman
 * Dual licensed under the MIT and GPL licenses.
 * http://benalman.com/about/license/
 */

// Script: jQuery BBQ: Back Button & Query Library
//
// *Version: 1.2.1, Last updated: 2/17/2010*
// 
// Project Home - http://benalman.com/projects/jquery-bbq-plugin/
// GitHub       - http://github.com/cowboy/jquery-bbq/
// Source       - http://github.com/cowboy/jquery-bbq/raw/master/jquery.ba-bbq.js
// (Minified)   - http://github.com/cowboy/jquery-bbq/raw/master/jquery.ba-bbq.min.js (4.0kb)
// 
// About: License
// 
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
// 
// About: Examples
// 
// These working examples, complete with fully commented code, illustrate a few
// ways in which this plugin can be used.
// 
// Basic AJAX     - http://benalman.com/code/projects/jquery-bbq/examples/fragment-basic/
// Advanced AJAX  - http://benalman.com/code/projects/jquery-bbq/examples/fragment-advanced/
// jQuery UI Tabs - http://benalman.com/code/projects/jquery-bbq/examples/fragment-jquery-ui-tabs/
// Deparam        - http://benalman.com/code/projects/jquery-bbq/examples/deparam/
// 
// About: Support and Testing
// 
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
// 
// jQuery Versions - 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-3.7, Safari 3-4,
//                   Chrome 4-5, Opera 9.6-10.1.
// Unit Tests      - http://benalman.com/code/projects/jquery-bbq/unit/
// 
// About: Release History
// 
// 1.2.1 - (2/17/2010) Actually fixed the stale window.location Safari bug from
//         <jQuery hashchange event> in BBQ, which was the main reason for the
//         previous release!
// 1.2   - (2/16/2010) Integrated <jQuery hashchange event> v1.2, which fixes a
//         Safari bug, the event can now be bound before DOM ready, and IE6/7
//         page should no longer scroll when the event is first bound. Also
//         added the <jQuery.param.fragment.noEscape> method, and reworked the
//         <hashchange event (BBQ)> internal "add" method to be compatible with
//         changes made to the jQuery 1.4.2 special events API.
// 1.1.1 - (1/22/2010) Integrated <jQuery hashchange event> v1.1, which fixes an
//         obscure IE8 EmulateIE7 meta tag compatibility mode bug.
// 1.1   - (1/9/2010) Broke out the jQuery BBQ event.special <hashchange event>
//         functionality into a separate plugin for users who want just the
//         basic event & back button support, without all the extra awesomeness
//         that BBQ provides. This plugin will be included as part of jQuery BBQ,
//         but also be available separately. See <jQuery hashchange event>
//         plugin for more information. Also added the <jQuery.bbq.removeState>
//         method and added additional <jQuery.deparam> examples.
// 1.0.3 - (12/2/2009) Fixed an issue in IE 6 where location.search and
//         location.hash would report incorrectly if the hash contained the ?
//         character. Also <jQuery.param.querystring> and <jQuery.param.fragment>
//         will no longer parse params out of a URL that doesn't contain ? or #,
//         respectively.
// 1.0.2 - (10/10/2009) Fixed an issue in IE 6/7 where the hidden IFRAME caused
//         a "This page contains both secure and nonsecure items." warning when
//         used on an https:// page.
// 1.0.1 - (10/7/2009) Fixed an issue in IE 8. Since both "IE7" and "IE8
//         Compatibility View" modes erroneously report that the browser
//         supports the native window.onhashchange event, a slightly more
//         robust test needed to be added.
// 1.0   - (10/2/2009) Initial release

(function($,window){
  '$:nomunge'; // Used by YUI compressor.
  
  // Some convenient shortcuts.
  var undefined,
    aps = Array.prototype.slice,
    decode = decodeURIComponent,
    
    // Method / object references.
    jq_param = $.param,
    jq_param_fragment,
    jq_deparam,
    jq_deparam_fragment,
    jq_bbq = $.bbq = $.bbq || {},
    jq_bbq_pushState,
    jq_bbq_getState,
    jq_elemUrlAttr,
    jq_event_special = $.event.special,
    
    // Reused strings.
    str_hashchange = 'hashchange',
    str_querystring = 'querystring',
    str_fragment = 'fragment',
    str_elemUrlAttr = 'elemUrlAttr',
    str_location = 'location',
    str_href = 'href',
    str_src = 'src',
    
    // Reused RegExp.
    re_trim_querystring = /^.*\?|#.*$/g,
    re_trim_fragment = /^.*\#/,
    re_no_escape,
    
    // Used by jQuery.elemUrlAttr.
    elemUrlAttr_cache = {};
  
  // A few commonly used bits, broken out to help reduce minified file size.
  
  function is_string( arg ) {
    return typeof arg === 'string';
  };
  
  // Why write the same function twice? Let's curry! Mmmm, curry..
  
  function curry( func ) {
    var args = aps.call( arguments, 1 );
    
    return function() {
      return func.apply( this, args.concat( aps.call( arguments ) ) );
    };
  };
  
  // Get location.hash (or what you'd expect location.hash to be) sans any
  // leading #. Thanks for making this necessary, Firefox!
  function get_fragment( url ) {
    return url.replace( /^[^#]*#?(.*)$/, '$1' );
  };
  
  // Get location.search (or what you'd expect location.search to be) sans any
  // leading #. Thanks for making this necessary, IE6!
  function get_querystring( url ) {
    return url.replace( /(?:^[^?#]*\?([^#]*).*$)?.*/, '$1' );
  };
  
  // Section: Param (to string)
  // 
  // Method: jQuery.param.querystring
  // 
  // Retrieve the query string from a URL or if no arguments are passed, the
  // current window.location.
  // 
  // Usage:
  // 
  // > jQuery.param.querystring( [ url ] );
  // 
  // Arguments:
  // 
  //  url - (String) A URL containing query string params to be parsed. If url
  //    is not passed, the current window.location is used.
  // 
  // Returns:
  // 
  //  (String) The parsed query string, with any leading "?" removed.
  //
  
  // Method: jQuery.param.querystring (build url)
  // 
  // Merge a URL, with or without pre-existing query string params, plus any
  // object, params string or URL containing query string params into a new URL.
  // 
  // Usage:
  // 
  // > jQuery.param.querystring( url, params [, merge_mode ] );
  // 
  // Arguments:
  // 
  //  url - (String) A valid URL for params to be merged into. This URL may
  //    contain a query string and/or fragment (hash).
  //  params - (String) A params string or URL containing query string params to
  //    be merged into url.
  //  params - (Object) A params object to be merged into url.
  //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
  //    specified, and is as-follows:
  // 
  //    * 0: params in the params argument will override any query string
  //         params in url.
  //    * 1: any query string params in url will override params in the params
  //         argument.
  //    * 2: params argument will completely replace any query string in url.
  // 
  // Returns:
  // 
  //  (String) Either a params string with urlencoded data or a URL with a
  //    urlencoded query string in the format 'a=b&c=d&e=f'.
  
  // Method: jQuery.param.fragment
  // 
  // Retrieve the fragment (hash) from a URL or if no arguments are passed, the
  // current window.location.
  // 
  // Usage:
  // 
  // > jQuery.param.fragment( [ url ] );
  // 
  // Arguments:
  // 
  //  url - (String) A URL containing fragment (hash) params to be parsed. If
  //    url is not passed, the current window.location is used.
  // 
  // Returns:
  // 
  //  (String) The parsed fragment (hash) string, with any leading "#" removed.
  
  // Method: jQuery.param.fragment (build url)
  // 
  // Merge a URL, with or without pre-existing fragment (hash) params, plus any
  // object, params string or URL containing fragment (hash) params into a new
  // URL.
  // 
  // Usage:
  // 
  // > jQuery.param.fragment( url, params [, merge_mode ] );
  // 
  // Arguments:
  // 
  //  url - (String) A valid URL for params to be merged into. This URL may
  //    contain a query string and/or fragment (hash).
  //  params - (String) A params string or URL containing fragment (hash) params
  //    to be merged into url.
  //  params - (Object) A params object to be merged into url.
  //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
  //    specified, and is as-follows:
  // 
  //    * 0: params in the params argument will override any fragment (hash)
  //         params in url.
  //    * 1: any fragment (hash) params in url will override params in the
  //         params argument.
  //    * 2: params argument will completely replace any query string in url.
  // 
  // Returns:
  // 
  //  (String) Either a params string with urlencoded data or a URL with a
  //    urlencoded fragment (hash) in the format 'a=b&c=d&e=f'.
  
  function jq_param_sub( is_fragment, get_func, url, params, merge_mode ) {
    var result,
      qs,
      matches,
      url_params,
      hash;
    
    if ( params !== undefined ) {
      // Build URL by merging params into url string.
      
      // matches[1] = url part that precedes params, not including trailing ?/#
      // matches[2] = params, not including leading ?/#
      // matches[3] = if in 'querystring' mode, hash including leading #, otherwise ''
      matches = url.match( is_fragment ? /^([^#]*)\#?(.*)$/ : /^([^#?]*)\??([^#]*)(#?.*)/ );
      
      // Get the hash if in 'querystring' mode, and it exists.
      hash = matches[3] || '';
      
      if ( merge_mode === 2 && is_string( params ) ) {
        // If merge_mode is 2 and params is a string, merge the fragment / query
        // string into the URL wholesale, without converting it into an object.
        qs = params.replace( is_fragment ? re_trim_fragment : re_trim_querystring, '' );
        
      } else {
        // Convert relevant params in url to object.
        url_params = jq_deparam( matches[2] );
        
        params = is_string( params )
          
          // Convert passed params string into object.
          ? jq_deparam[ is_fragment ? str_fragment : str_querystring ]( params )
          
          // Passed params object.
          : params;
        
        qs = merge_mode === 2 ? params                              // passed params replace url params
          : merge_mode === 1  ? $.extend( {}, params, url_params )  // url params override passed params
          : $.extend( {}, url_params, params );                     // passed params override url params
        
        // Convert params object to a string.
        qs = jq_param( qs );
        
        // Unescape characters specified via $.param.noEscape. Since only hash-
        // history users have requested this feature, it's only enabled for
        // fragment-related params strings.
        if ( is_fragment ) {
          qs = qs.replace( re_no_escape, decode );
        }
      }
      
      // Build URL from the base url, querystring and hash. In 'querystring'
      // mode, ? is only added if a query string exists. In 'fragment' mode, #
      // is always added.
      result = matches[1] + ( is_fragment ? '#' : qs || !matches[1] ? '?' : '' ) + qs + hash;
      
    } else {
      // If URL was passed in, parse params from URL string, otherwise parse
      // params from window.location.
      result = get_func( url !== undefined ? url : window[ str_location ][ str_href ] );
    }
    
    return result;
  };
  
  jq_param[ str_querystring ]                  = curry( jq_param_sub, 0, get_querystring );
  jq_param[ str_fragment ] = jq_param_fragment = curry( jq_param_sub, 1, get_fragment );
  
  // Method: jQuery.param.fragment.noEscape
  // 
  // Specify characters that will be left unescaped when fragments are created
  // or merged using <jQuery.param.fragment>, or when the fragment is modified
  // using <jQuery.bbq.pushState>. This option only applies to serialized data
  // object fragments, and not set-as-string fragments. Does not affect the
  // query string. Defaults to ",/" (comma, forward slash).
  // 
  // Note that this is considered a purely aesthetic option, and will help to
  // create URLs that "look pretty" in the address bar or bookmarks, without
  // affecting functionality in any way. That being said, be careful to not
  // unescape characters that are used as delimiters or serve a special
  // purpose, such as the "#?&=+" (octothorpe, question mark, ampersand,
  // equals, plus) characters.
  // 
  // Usage:
  // 
  // > jQuery.param.fragment.noEscape( [ chars ] );
  // 
  // Arguments:
  // 
  //  chars - (String) The characters to not escape in the fragment. If
  //    unspecified, defaults to empty string (escape all characters).
  // 
  // Returns:
  // 
  //  Nothing.
  
  jq_param_fragment.noEscape = function( chars ) {
    chars = chars || '';
    var arr = $.map( chars.split(''), encodeURIComponent );
    re_no_escape = new RegExp( arr.join('|'), 'g' );
  };
  
  // A sensible default. These are the characters people seem to complain about
  // "uglifying up the URL" the most.
  jq_param_fragment.noEscape( ',/' );
  
  // Section: Deparam (from string)
  // 
  // Method: jQuery.deparam
  // 
  // Deserialize a params string into an object, optionally coercing numbers,
  // booleans, null and undefined values; this method is the counterpart to the
  // internal jQuery.param method.
  // 
  // Usage:
  // 
  // > jQuery.deparam( params [, coerce ] );
  // 
  // Arguments:
  // 
  //  params - (String) A params string to be parsed.
  //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
  //    undefined to their actual value. Defaults to false if omitted.
  // 
  // Returns:
  // 
  //  (Object) An object representing the deserialized params string.
  
  $.deparam = jq_deparam = function( params, coerce ) {
    var obj = {},
      coerce_types = { 'true': !0, 'false': !1, 'null': null };
    
    // Iterate over all name=value pairs.
    $.each( params.replace( /\+/g, ' ' ).split( '&' ), function(j,v){
      var param = v.split( '=' ),
        key = decode( param[0] ),
        val,
        cur = obj,
        i = 0,
        
        // If key is more complex than 'foo', like 'a[]' or 'a[b][c]', split it
        // into its component parts.
        keys = key.split( '][' ),
        keys_last = keys.length - 1;
      
      // If the first keys part contains [ and the last ends with ], then []
      // are correctly balanced.
      if ( /\[/.test( keys[0] ) && /\]$/.test( keys[ keys_last ] ) ) {
        // Remove the trailing ] from the last keys part.
        keys[ keys_last ] = keys[ keys_last ].replace( /\]$/, '' );
        
        // Split first keys part into two parts on the [ and add them back onto
        // the beginning of the keys array.
        keys = keys.shift().split('[').concat( keys );
        
        keys_last = keys.length - 1;
      } else {
        // Basic 'foo' style key.
        keys_last = 0;
      }
      
      // Are we dealing with a name=value pair, or just a name?
      if ( param.length === 2 ) {
        val = decode( param[1] );
        
        // Coerce values.
        if ( coerce ) {
          val = val && !isNaN(val)            ? +val              // number
            : val === 'undefined'             ? undefined         // undefined
            : coerce_types[val] !== undefined ? coerce_types[val] // true, false, null
            : val;                                                // string
        }
        
        if ( keys_last ) {
          // Complex key, build deep object structure based on a few rules:
          // * The 'cur' pointer starts at the object top-level.
          // * [] = array push (n is set to array length), [n] = array if n is 
          //   numeric, otherwise object.
          // * If at the last keys part, set the value.
          // * For each keys part, if the current level is undefined create an
          //   object or array based on the type of the next keys part.
          // * Move the 'cur' pointer to the next level.
          // * Rinse & repeat.
          for ( ; i <= keys_last; i++ ) {
            key = keys[i] === '' ? cur.length : keys[i];
            cur = cur[key] = i < keys_last
              ? cur[key] || ( keys[i+1] && isNaN( keys[i+1] ) ? {} : [] )
              : val;
          }
          
        } else {
          // Simple key, even simpler rules, since only scalars and shallow
          // arrays are allowed.
          
          if ( $.isArray( obj[key] ) ) {
            // val is already an array, so push on the next value.
            obj[key].push( val );
            
          } else if ( obj[key] !== undefined ) {
            // val isn't an array, but since a second value has been specified,
            // convert val into an array.
            obj[key] = [ obj[key], val ];
            
          } else {
            // val is a scalar.
            obj[key] = val;
          }
        }
        
      } else if ( key ) {
        // No value was defined, so set something meaningful.
        obj[key] = coerce
          ? undefined
          : '';
      }
    });
    
    return obj;
  };
  
  // Method: jQuery.deparam.querystring
  // 
  // Parse the query string from a URL or the current window.location,
  // deserializing it into an object, optionally coercing numbers, booleans,
  // null and undefined values.
  // 
  // Usage:
  // 
  // > jQuery.deparam.querystring( [ url ] [, coerce ] );
  // 
  // Arguments:
  // 
  //  url - (String) An optional params string or URL containing query string
  //    params to be parsed. If url is omitted, the current window.location
  //    is used.
  //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
  //    undefined to their actual value. Defaults to false if omitted.
  // 
  // Returns:
  // 
  //  (Object) An object representing the deserialized params string.
  
  // Method: jQuery.deparam.fragment
  // 
  // Parse the fragment (hash) from a URL or the current window.location,
  // deserializing it into an object, optionally coercing numbers, booleans,
  // null and undefined values.
  // 
  // Usage:
  // 
  // > jQuery.deparam.fragment( [ url ] [, coerce ] );
  // 
  // Arguments:
  // 
  //  url - (String) An optional params string or URL containing fragment (hash)
  //    params to be parsed. If url is omitted, the current window.location
  //    is used.
  //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
  //    undefined to their actual value. Defaults to false if omitted.
  // 
  // Returns:
  // 
  //  (Object) An object representing the deserialized params string.
  
  function jq_deparam_sub( is_fragment, url_or_params, coerce ) {
    if ( url_or_params === undefined || typeof url_or_params === 'boolean' ) {
      // url_or_params not specified.
      coerce = url_or_params;
      url_or_params = jq_param[ is_fragment ? str_fragment : str_querystring ]();
    } else {
      url_or_params = is_string( url_or_params )
        ? url_or_params.replace( is_fragment ? re_trim_fragment : re_trim_querystring, '' )
        : url_or_params;
    }
    
    return jq_deparam( url_or_params, coerce );
  };
  
  jq_deparam[ str_querystring ]                    = curry( jq_deparam_sub, 0 );
  jq_deparam[ str_fragment ] = jq_deparam_fragment = curry( jq_deparam_sub, 1 );
  
  // Section: Element manipulation
  // 
  // Method: jQuery.elemUrlAttr
  // 
  // Get the internal "Default URL attribute per tag" list, or augment the list
  // with additional tag-attribute pairs, in case the defaults are insufficient.
  // 
  // In the <jQuery.fn.querystring> and <jQuery.fn.fragment> methods, this list
  // is used to determine which attribute contains the URL to be modified, if
  // an "attr" param is not specified.
  // 
  // Default Tag-Attribute List:
  // 
  //  a      - href
  //  base   - href
  //  iframe - src
  //  img    - src
  //  input  - src
  //  form   - action
  //  link   - href
  //  script - src
  // 
  // Usage:
  // 
  // > jQuery.elemUrlAttr( [ tag_attr ] );
  // 
  // Arguments:
  // 
  //  tag_attr - (Object) An object containing a list of tag names and their
  //    associated default attribute names in the format { tag: 'attr', ... } to
  //    be merged into the internal tag-attribute list.
  // 
  // Returns:
  // 
  //  (Object) An object containing all stored tag-attribute values.
  
  // Only define function and set defaults if function doesn't already exist, as
  // the urlInternal plugin will provide this method as well.
  $[ str_elemUrlAttr ] || ($[ str_elemUrlAttr ] = function( obj ) {
    return $.extend( elemUrlAttr_cache, obj );
  })({
    a: str_href,
    base: str_href,
    iframe: str_src,
    img: str_src,
    input: str_src,
    form: 'action',
    link: str_href,
    script: str_src
  });
  
  jq_elemUrlAttr = $[ str_elemUrlAttr ];
  
  // Method: jQuery.fn.querystring
  // 
  // Update URL attribute in one or more elements, merging the current URL (with
  // or without pre-existing query string params) plus any params object or
  // string into a new URL, which is then set into that attribute. Like
  // <jQuery.param.querystring (build url)>, but for all elements in a jQuery
  // collection.
  // 
  // Usage:
  // 
  // > jQuery('selector').querystring( [ attr, ] params [, merge_mode ] );
  // 
  // Arguments:
  // 
  //  attr - (String) Optional name of an attribute that will contain a URL to
  //    merge params or url into. See <jQuery.elemUrlAttr> for a list of default
  //    attributes.
  //  params - (Object) A params object to be merged into the URL attribute.
  //  params - (String) A URL containing query string params, or params string
  //    to be merged into the URL attribute.
  //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
  //    specified, and is as-follows:
  //    
  //    * 0: params in the params argument will override any params in attr URL.
  //    * 1: any params in attr URL will override params in the params argument.
  //    * 2: params argument will completely replace any query string in attr
  //         URL.
  // 
  // Returns:
  // 
  //  (jQuery) The initial jQuery collection of elements, but with modified URL
  //  attribute values.
  
  // Method: jQuery.fn.fragment
  // 
  // Update URL attribute in one or more elements, merging the current URL (with
  // or without pre-existing fragment/hash params) plus any params object or
  // string into a new URL, which is then set into that attribute. Like
  // <jQuery.param.fragment (build url)>, but for all elements in a jQuery
  // collection.
  // 
  // Usage:
  // 
  // > jQuery('selector').fragment( [ attr, ] params [, merge_mode ] );
  // 
  // Arguments:
  // 
  //  attr - (String) Optional name of an attribute that will contain a URL to
  //    merge params into. See <jQuery.elemUrlAttr> for a list of default
  //    attributes.
  //  params - (Object) A params object to be merged into the URL attribute.
  //  params - (String) A URL containing fragment (hash) params, or params
  //    string to be merged into the URL attribute.
  //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
  //    specified, and is as-follows:
  //    
  //    * 0: params in the params argument will override any params in attr URL.
  //    * 1: any params in attr URL will override params in the params argument.
  //    * 2: params argument will completely replace any fragment (hash) in attr
  //         URL.
  // 
  // Returns:
  // 
  //  (jQuery) The initial jQuery collection of elements, but with modified URL
  //  attribute values.
  
  function jq_fn_sub( mode, force_attr, params, merge_mode ) {
    if ( !is_string( params ) && typeof params !== 'object' ) {
      // force_attr not specified.
      merge_mode = params;
      params = force_attr;
      force_attr = undefined;
    }
    
    return this.each(function(){
      var that = $(this),
        
        // Get attribute specified, or default specified via $.elemUrlAttr.
        attr = force_attr || jq_elemUrlAttr()[ ( this.nodeName || '' ).toLowerCase() ] || '',
        
        // Get URL value.
        url = attr && that.attr( attr ) || '';
      
      // Update attribute with new URL.
      that.attr( attr, jq_param[ mode ]( url, params, merge_mode ) );
    });
    
  };
  
  $.fn[ str_querystring ] = curry( jq_fn_sub, str_querystring );
  $.fn[ str_fragment ]    = curry( jq_fn_sub, str_fragment );
  
  // Section: History, hashchange event
  // 
  // Method: jQuery.bbq.pushState
  // 
  // Adds a 'state' into the browser history at the current position, setting
  // location.hash and triggering any bound <hashchange event> callbacks
  // (provided the new state is different than the previous state).
  // 
  // If no arguments are passed, an empty state is created, which is just a
  // shortcut for jQuery.bbq.pushState( {}, 2 ).
  // 
  // Usage:
  // 
  // > jQuery.bbq.pushState( [ params [, merge_mode ] ] );
  // 
  // Arguments:
  // 
  //  params - (String) A serialized params string or a hash string beginning
  //    with # to merge into location.hash.
  //  params - (Object) A params object to merge into location.hash.
  //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
  //    specified (unless a hash string beginning with # is specified, in which
  //    case merge behavior defaults to 2), and is as-follows:
  // 
  //    * 0: params in the params argument will override any params in the
  //         current state.
  //    * 1: any params in the current state will override params in the params
  //         argument.
  //    * 2: params argument will completely replace current state.
  // 
  // Returns:
  // 
  //  Nothing.
  // 
  // Additional Notes:
  // 
  //  * Setting an empty state may cause the browser to scroll.
  //  * Unlike the fragment and querystring methods, if a hash string beginning
  //    with # is specified as the params agrument, merge_mode defaults to 2.
  
  jq_bbq.pushState = jq_bbq_pushState = function( params, merge_mode ) {
    if ( is_string( params ) && /^#/.test( params ) && merge_mode === undefined ) {
      // Params string begins with # and merge_mode not specified, so completely
      // overwrite window.location.hash.
      merge_mode = 2;
    }
    
    var has_args = params !== undefined,
      // Merge params into window.location using $.param.fragment.
      url = jq_param_fragment( window[ str_location ][ str_href ],
        has_args ? params : {}, has_args ? merge_mode : 2 );
    
    // Set new window.location.href. If hash is empty, use just # to prevent
    // browser from reloading the page. Note that Safari 3 & Chrome barf on
    // location.hash = '#'.
    window[ str_location ][ str_href ] = url + ( /#/.test( url ) ? '' : '#' );
  };
  
  // Method: jQuery.bbq.getState
  // 
  // Retrieves the current 'state' from the browser history, parsing
  // location.hash for a specific key or returning an object containing the
  // entire state, optionally coercing numbers, booleans, null and undefined
  // values.
  // 
  // Usage:
  // 
  // > jQuery.bbq.getState( [ key ] [, coerce ] );
  // 
  // Arguments:
  // 
  //  key - (String) An optional state key for which to return a value.
  //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
  //    undefined to their actual value. Defaults to false.
  // 
  // Returns:
  // 
  //  (Anything) If key is passed, returns the value corresponding with that key
  //    in the location.hash 'state', or undefined. If not, an object
  //    representing the entire 'state' is returned.
  
  jq_bbq.getState = jq_bbq_getState = function( key, coerce ) {
    return key === undefined || typeof key === 'boolean'
      ? jq_deparam_fragment( key ) // 'key' really means 'coerce' here
      : jq_deparam_fragment( coerce )[ key ];
  };
  
  // Method: jQuery.bbq.removeState
  // 
  // Remove one or more keys from the current browser history 'state', creating
  // a new state, setting location.hash and triggering any bound
  // <hashchange event> callbacks (provided the new state is different than
  // the previous state).
  // 
  // If no arguments are passed, an empty state is created, which is just a
  // shortcut for jQuery.bbq.pushState( {}, 2 ).
  // 
  // Usage:
  // 
  // > jQuery.bbq.removeState( [ key [, key ... ] ] );
  // 
  // Arguments:
  // 
  //  key - (String) One or more key values to remove from the current state,
  //    passed as individual arguments.
  //  key - (Array) A single array argument that contains a list of key values
  //    to remove from the current state.
  // 
  // Returns:
  // 
  //  Nothing.
  // 
  // Additional Notes:
  // 
  //  * Setting an empty state may cause the browser to scroll.
  
  jq_bbq.removeState = function( arr ) {
    var state = {};
    
    // If one or more arguments is passed..
    if ( arr !== undefined ) {
      
      // Get the current state.
      state = jq_bbq_getState();
      
      // For each passed key, delete the corresponding property from the current
      // state.
      $.each( $.isArray( arr ) ? arr : arguments, function(i,v){
        delete state[ v ];
      });
    }
    
    // Set the state, completely overriding any existing state.
    jq_bbq_pushState( state, 2 );
  };
  
  // Event: hashchange event (BBQ)
  // 
  // Usage in jQuery 1.4 and newer:
  // 
  // In jQuery 1.4 and newer, the event object passed into any hashchange event
  // callback is augmented with a copy of the location.hash fragment at the time
  // the event was triggered as its event.fragment property. In addition, the
  // event.getState method operates on this property (instead of location.hash)
  // which allows this fragment-as-a-state to be referenced later, even after
  // window.location may have changed.
  // 
  // Note that event.fragment and event.getState are not defined according to
  // W3C (or any other) specification, but will still be available whether or
  // not the hashchange event exists natively in the browser, because of the
  // utility they provide.
  // 
  // The event.fragment property contains the output of <jQuery.param.fragment>
  // and the event.getState method is equivalent to the <jQuery.bbq.getState>
  // method.
  // 
  // > $(window).bind( 'hashchange', function( event ) {
  // >   var hash_str = event.fragment,
  // >     param_obj = event.getState(),
  // >     param_val = event.getState( 'param_name' ),
  // >     param_val_coerced = event.getState( 'param_name', true );
  // >   ...
  // > });
  // 
  // Usage in jQuery 1.3.2:
  // 
  // In jQuery 1.3.2, the event object cannot to be augmented as in jQuery 1.4+,
  // so the fragment state isn't bound to the event object and must instead be
  // parsed using the <jQuery.param.fragment> and <jQuery.bbq.getState> methods.
  // 
  // > $(window).bind( 'hashchange', function( event ) {
  // >   var hash_str = $.param.fragment(),
  // >     param_obj = $.bbq.getState(),
  // >     param_val = $.bbq.getState( 'param_name' ),
  // >     param_val_coerced = $.bbq.getState( 'param_name', true );
  // >   ...
  // > });
  // 
  // Additional Notes:
  // 
  // * Due to changes in the special events API, jQuery BBQ v1.2 or newer is
  //   required to enable the augmented event object in jQuery 1.4.2 and newer.
  // * See <jQuery hashchange event> for more detailed information.
  
  jq_event_special[ str_hashchange ] = $.extend( jq_event_special[ str_hashchange ], {
    
    // Augmenting the event object with the .fragment property and .getState
    // method requires jQuery 1.4 or newer. Note: with 1.3.2, everything will
    // work, but the event won't be augmented)
    add: function( handleObj ) {
      var old_handler;
      
      function new_handler(e) {
        // e.fragment is set to the value of location.hash (with any leading #
        // removed) at the time the event is triggered.
        var hash = e[ str_fragment ] = jq_param_fragment();
        
        // e.getState() works just like $.bbq.getState(), but uses the
        // e.fragment property stored on the event object.
        e.getState = function( key, coerce ) {
          return key === undefined || typeof key === 'boolean'
            ? jq_deparam( hash, key ) // 'key' really means 'coerce' here
            : jq_deparam( hash, coerce )[ key ];
        };
        
        old_handler.apply( this, arguments );
      };
      
      // This may seem a little complicated, but it normalizes the special event
      // .add method between jQuery 1.4/1.4.1 and 1.4.2+
      if ( $.isFunction( handleObj ) ) {
        // 1.4, 1.4.1
        old_handler = handleObj;
        return new_handler;
      } else {
        // 1.4.2+
        old_handler = handleObj.handler;
        handleObj.handler = new_handler;
      }
    }
    
  });
  
})(jQuery,this);

/*!
 * jQuery hashchange event - v1.2 - 2/11/2010
 * http://benalman.com/projects/jquery-hashchange-plugin/
 * 
 * Copyright (c) 2010 "Cowboy" Ben Alman
 * Dual licensed under the MIT and GPL licenses.
 * http://benalman.com/about/license/
 */

// Script: jQuery hashchange event
//
// *Version: 1.2, Last updated: 2/11/2010*
// 
// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
// GitHub       - http://github.com/cowboy/jquery-hashchange/
// Source       - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
// (Minified)   - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (1.1kb)
// 
// About: License
// 
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
// 
// About: Examples
// 
// This working example, complete with fully commented code, illustrate one way
// in which this plugin can be used.
// 
// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
// 
// About: Support and Testing
// 
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
// 
// jQuery Versions - 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-3.7, Safari 3-4, Chrome, Opera 9.6-10.1.
// Unit Tests      - http://benalman.com/code/projects/jquery-hashchange/unit/
// 
// About: Known issues
// 
// While this jQuery hashchange event implementation is quite stable and robust,
// there are a few unfortunate browser bugs surrounding expected hashchange
// event-based behaviors, independent of any JavaScript window.onhashchange
// abstraction. See the following examples for more information:
// 
// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
// 
// About: Release History
// 
// 1.2   - (2/11/2010) Fixed a bug where coming back to a page using this plugin
//         from a page on another domain would cause an error in Safari 4. Also,
//         IE6/7 Iframe is now inserted after the body (this actually works),
//         which prevents the page from scrolling when the event is first bound.
//         Event can also now be bound before DOM ready, but it won't be usable
//         before then in IE6/7.
// 1.1   - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
//         where browser version is incorrectly reported as 8.0, despite
//         inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
// 1.0   - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
//         window.onhashchange functionality into a separate plugin for users
//         who want just the basic event & back button support, without all the
//         extra awesomeness that BBQ provides. This plugin will be included as
//         part of jQuery BBQ, but also be available separately.

(function($,window,undefined){
  '$:nomunge'; // Used by YUI compressor.
  
  // Method / object references.
  var fake_onhashchange,
    jq_event_special = $.event.special,
    
    // Reused strings.
    str_location = 'location',
    str_hashchange = 'hashchange',
    str_href = 'href',
    
    // IE6/7 specifically need some special love when it comes to back-button
    // support, so let's do a little browser sniffing..
    browser = $.browser,
    mode = document.documentMode,
    // ML: This detection of IE fails when using IE7 (non-compat) mode in IE9.
    // Instead, I'll just check for the presence of the iframe (which we're
    // generating when appropriate on the server side).
    //is_old_ie = browser.msie && ( mode === undefined || mode < 8 ),
    is_old_ie = browser.msie && document.getElementById("__historyFrame") != null,
    
    // Does the browser support window.onhashchange? Test for IE version, since
    // IE8 incorrectly reports this when in "IE7" or "IE8 Compatibility View"!
    supports_onhashchange = 'on' + str_hashchange in window && !is_old_ie;
  
  // Get location.hash (or what you'd expect location.hash to be) sans any
  // leading #. Thanks for making this necessary, Firefox!
  function get_fragment( url ) {
    url = url || window[ str_location ][ str_href ];
    return url.replace( /^[^#]*#?(.*)$/, '$1' );
  };
  
  // Property: jQuery.hashchangeDelay
  // 
  // The numeric interval (in milliseconds) at which the <hashchange event>
  // polling loop executes. Defaults to 100.
  
  $[ str_hashchange + 'Delay' ] = 100;
  
  // Event: hashchange event
  // 
  // Fired when location.hash changes. In browsers that support it, the native
  // window.onhashchange event is used (IE8, FF3.6), otherwise a polling loop is
  // initialized, running every <jQuery.hashchangeDelay> milliseconds to see if
  // the hash has changed. In IE 6 and 7, a hidden Iframe is created to allow
  // the back button and hash-based history to work.
  // 
  // Usage:
  // 
  // > $(window).bind( 'hashchange', function(e) {
  // >   var hash = location.hash;
  // >   ...
  // > });
  // 
  // Additional Notes:
  // 
  // * The polling loop and Iframe are not created until at least one callback
  //   is actually bound to 'hashchange'.
  // * If you need the bound callback(s) to execute immediately, in cases where
  //   the page 'state' exists on page load (via bookmark or page refresh, for
  //   example) use $(window).trigger( 'hashchange' );
  // * The event can be bound before DOM ready, but since it won't be usable
  //   before then in IE6/7 (due to the necessary Iframe), recommended usage is
  //   to bind it inside a $(document).ready() callback.
  
  jq_event_special[ str_hashchange ] = $.extend( jq_event_special[ str_hashchange ], {
    
    // Called only when the first 'hashchange' event is bound to window.
    setup: function() {
      // If window.onhashchange is supported natively, there's nothing to do..
      if ( supports_onhashchange ) { return false; }
      
      // Otherwise, we need to create our own. And we don't want to call this
      // until the user binds to the event, just in case they never do, since it
      // will create a polling loop and possibly even a hidden Iframe.
      $( fake_onhashchange.start );
    },
    
    // Called only when the last 'hashchange' event is unbound from window.
    teardown: function() {
      // If window.onhashchange is supported natively, there's nothing to do..
      if ( supports_onhashchange ) { return false; }
      
      // Otherwise, we need to stop ours (if possible).
      $( fake_onhashchange.stop );
    }
    
  });
  
  // fake_onhashchange does all the work of triggering the window.onhashchange
  // event for browsers that don't natively support it, including creating a
  // polling loop to watch for hash changes and in IE 6/7 creating a hidden
  // Iframe to enable back and forward.
  fake_onhashchange = (function(){
    var self = {},
      timeout_id,
      iframe,
      set_history,
      get_history;
    
    // Initialize. In IE 6/7, creates a hidden Iframe for history handling.
    function init(){
      // Most browsers don't need special methods here..
      set_history = get_history = function(val){ return val; };
      
      // But IE6/7 do!
      if ( is_old_ie ) {
        
        // Create hidden Iframe after the end of the body to prevent initial
        // page load from scrolling unnecessarily.
        //
        // ML: Use the iframe generated directly in the page, because dynamically
        // adding it will lost history when leaving the page and then coming back.
        // iframe = $('<iframe src="javascript:0"/>').hide().insertAfter( 'body' )[0].contentWindow;
        iframe = document.getElementById("__historyFrame").contentWindow;
        
        // Get history by looking at the hidden Iframe's location.hash.
        get_history = function() {
          return get_fragment( iframe.document[ str_location ][ str_href ] );
        };
        
        // Set a new history item by opening and then closing the Iframe
        // document, *then* setting its location.hash.
        set_history = function( hash, history_hash ) {
          if ( hash !== history_hash ) {
            var doc = iframe.document;
            doc.open().close();
            doc[ str_location ].hash = '#' + hash;
          }
        };
        
        // Set initial history.
        //
        // ML: Do not set anything here. It breaks the history when coming back
        // to the page, and it looks like it's working OK without it.
        //set_history( get_fragment() );
      }
    };
    
    // Start the polling loop.
    self.start = function() {
      // Polling loop is already running!
      if ( timeout_id ) { return; }
      
      // Remember the initial hash so it doesn't get triggered immediately.
      var last_hash = get_fragment();
      
      // Initialize if not yet initialized.
      set_history || init();
      
      // This polling loop checks every $.hashchangeDelay milliseconds to see if
      // location.hash has changed, and triggers the 'hashchange' event on
      // window when necessary.
      (function loopy(){
        var hash = get_fragment(),
          history_hash = get_history( last_hash );
        
        if ( hash !== last_hash ) {
          set_history( last_hash = hash, history_hash );
          
          $(window).trigger( str_hashchange );
          
        } else if ( history_hash !== last_hash ) {
          window[ str_location ][ str_href ] = window[ str_location ][ str_href ].replace( /#.*/, '' ) + '#' + history_hash;
        }
        
        timeout_id = setTimeout( loopy, $[ str_hashchange + 'Delay' ] );
      })();
    };
    
    // Stop the polling loop, but only if an IE6/7 Iframe wasn't created. In
    // that case, even if there are no longer any bound event handlers, the
    // polling loop is still necessary for back/next to work at all!
    self.stop = function() {
      if ( !iframe ) {
        timeout_id && clearTimeout( timeout_id );
        timeout_id = 0;
      }
    };
    
    return self;
  })();
  
})(jQuery,this);
;
/*!
 * jQuery UI 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI
 */
(function( $, undefined ) {

// prevent duplicate loading
// this is only a problem because we proxy existing functions
// and we don't want to double proxy them
$.ui = $.ui || {};
if ( $.ui.version ) {
	return;
}

$.extend( $.ui, {
	version: "1.8.11",

	keyCode: {
		ALT: 18,
		BACKSPACE: 8,
		CAPS_LOCK: 20,
		COMMA: 188,
		COMMAND: 91,
		COMMAND_LEFT: 91, // COMMAND
		COMMAND_RIGHT: 93,
		CONTROL: 17,
		DELETE: 46,
		DOWN: 40,
		END: 35,
		ENTER: 13,
		ESCAPE: 27,
		HOME: 36,
		INSERT: 45,
		LEFT: 37,
		MENU: 93, // COMMAND_RIGHT
		NUMPAD_ADD: 107,
		NUMPAD_DECIMAL: 110,
		NUMPAD_DIVIDE: 111,
		NUMPAD_ENTER: 108,
		NUMPAD_MULTIPLY: 106,
		NUMPAD_SUBTRACT: 109,
		PAGE_DOWN: 34,
		PAGE_UP: 33,
		PERIOD: 190,
		RIGHT: 39,
		SHIFT: 16,
		SPACE: 32,
		TAB: 9,
		UP: 38,
		WINDOWS: 91 // COMMAND
	}
});

// plugins
$.fn.extend({
	_focus: $.fn.focus,
	focus: function( delay, fn ) {
		return typeof delay === "number" ?
			this.each(function() {
				var elem = this;
				setTimeout(function() {
					$( elem ).focus();
					if ( fn ) {
						fn.call( elem );
					}
				}, delay );
			}) :
			this._focus.apply( this, arguments );
	},

	scrollParent: function() {
		var scrollParent;
		if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
			scrollParent = this.parents().filter(function() {
				return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
			}).eq(0);
		} else {
			scrollParent = this.parents().filter(function() {
				return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
			}).eq(0);
		}

		return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
	},

	zIndex: function( zIndex ) {
		if ( zIndex !== undefined ) {
			return this.css( "zIndex", zIndex );
		}

		if ( this.length ) {
			var elem = $( this[ 0 ] ), position, value;
			while ( elem.length && elem[ 0 ] !== document ) {
				// Ignore z-index if position is set to a value where z-index is ignored by the browser
				// This makes behavior of this function consistent across browsers
				// WebKit always returns auto if the element is positioned
				position = elem.css( "position" );
				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
					// IE returns 0 when zIndex is not specified
					// other browsers return a string
					// we ignore the case of nested elements with an explicit value of 0
					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
					value = parseInt( elem.css( "zIndex" ), 10 );
					if ( !isNaN( value ) && value !== 0 ) {
						return value;
					}
				}
				elem = elem.parent();
			}
		}

		return 0;
	},

	disableSelection: function() {
		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
			".ui-disableSelection", function( event ) {
				event.preventDefault();
			});
	},

	enableSelection: function() {
		return this.unbind( ".ui-disableSelection" );
	}
});

$.each( [ "Width", "Height" ], function( i, name ) {
	var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
		type = name.toLowerCase(),
		orig = {
			innerWidth: $.fn.innerWidth,
			innerHeight: $.fn.innerHeight,
			outerWidth: $.fn.outerWidth,
			outerHeight: $.fn.outerHeight
		};

	function reduce( elem, size, border, margin ) {
		$.each( side, function() {
			size -= parseFloat( $.curCSS( elem, "padding" + this, true) ) || 0;
			if ( border ) {
				size -= parseFloat( $.curCSS( elem, "border" + this + "Width", true) ) || 0;
			}
			if ( margin ) {
				size -= parseFloat( $.curCSS( elem, "margin" + this, true) ) || 0;
			}
		});
		return size;
	}

	$.fn[ "inner" + name ] = function( size ) {
		if ( size === undefined ) {
			return orig[ "inner" + name ].call( this );
		}

		return this.each(function() {
			$( this ).css( type, reduce( this, size ) + "px" );
		});
	};

	$.fn[ "outer" + name] = function( size, margin ) {
		if ( typeof size !== "number" ) {
			return orig[ "outer" + name ].call( this, size );
		}

		return this.each(function() {
			$( this).css( type, reduce( this, size, true, margin ) + "px" );
		});
	};
});

// selectors
function visible( element ) {
	return !$( element ).parents().andSelf().filter(function() {
		return $.curCSS( this, "visibility" ) === "hidden" ||
			$.expr.filters.hidden( this );
	}).length;
}

$.extend( $.expr[ ":" ], {
	data: function( elem, i, match ) {
		return !!$.data( elem, match[ 3 ] );
	},

	focusable: function( element ) {
		var nodeName = element.nodeName.toLowerCase(),
			tabIndex = $.attr( element, "tabindex" );
		if ( "area" === nodeName ) {
			var map = element.parentNode,
				mapName = map.name,
				img;
			if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
				return false;
			}
			img = $( "img[usemap=#" + mapName + "]" )[0];
			return !!img && visible( img );
		}
		return ( /input|select|textarea|button|object/.test( nodeName )
			? !element.disabled
			: "a" == nodeName
				? element.href || !isNaN( tabIndex )
				: !isNaN( tabIndex ))
			// the element and all of its ancestors must be visible
			&& visible( element );
	},

	tabbable: function( element ) {
		var tabIndex = $.attr( element, "tabindex" );
		return ( isNaN( tabIndex ) || tabIndex >= 0 ) && $( element ).is( ":focusable" );
	}
});

// support
$(function() {
	var body = document.body,
		div = body.appendChild( div = document.createElement( "div" ) );

	$.extend( div.style, {
		minHeight: "100px",
		height: "auto",
		padding: 0,
		borderWidth: 0
	});

	$.support.minHeight = div.offsetHeight === 100;
	$.support.selectstart = "onselectstart" in div;

	// set display to none to avoid a layout bug in IE
	// http://dev.jquery.com/ticket/4014
	body.removeChild( div ).style.display = "none";
});





// deprecated
$.extend( $.ui, {
	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
	plugin: {
		add: function( module, option, set ) {
			var proto = $.ui[ module ].prototype;
			for ( var i in set ) {
				proto.plugins[ i ] = proto.plugins[ i ] || [];
				proto.plugins[ i ].push( [ option, set[ i ] ] );
			}
		},
		call: function( instance, name, args ) {
			var set = instance.plugins[ name ];
			if ( !set || !instance.element[ 0 ].parentNode ) {
				return;
			}
	
			for ( var i = 0; i < set.length; i++ ) {
				if ( instance.options[ set[ i ][ 0 ] ] ) {
					set[ i ][ 1 ].apply( instance.element, args );
				}
			}
		}
	},
	
	// will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
	contains: function( a, b ) {
		return document.compareDocumentPosition ?
			a.compareDocumentPosition( b ) & 16 :
			a !== b && a.contains( b );
	},
	
	// only used by resizable
	hasScroll: function( el, a ) {
	
		//If overflow is hidden, the element might have extra content, but the user wants to hide it
		if ( $( el ).css( "overflow" ) === "hidden") {
			return false;
		}
	
		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
			has = false;
	
		if ( el[ scroll ] > 0 ) {
			return true;
		}
	
		// TODO: determine which cases actually cause this to happen
		// if the element doesn't have the scroll set, see if it's possible to
		// set the scroll
		el[ scroll ] = 1;
		has = ( el[ scroll ] > 0 );
		el[ scroll ] = 0;
		return has;
	},
	
	// these are odd functions, fix the API or move into individual plugins
	isOverAxis: function( x, reference, size ) {
		//Determines when x coordinate is over "b" element axis
		return ( x > reference ) && ( x < ( reference + size ) );
	},
	isOver: function( y, x, top, left, height, width ) {
		//Determines when x, y coordinates is over "b" element
		return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
	}
});

})( jQuery );
/*!
 * jQuery UI Widget 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Widget
 */
(function( $, undefined ) {

// jQuery 1.4+
if ( $.cleanData ) {
	var _cleanData = $.cleanData;
	$.cleanData = function( elems ) {
		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
			$( elem ).triggerHandler( "remove" );
		}
		_cleanData( elems );
	};
} else {
	var _remove = $.fn.remove;
	$.fn.remove = function( selector, keepData ) {
		return this.each(function() {
			if ( !keepData ) {
				if ( !selector || $.filter( selector, [ this ] ).length ) {
					$( "*", this ).add( [ this ] ).each(function() {
						$( this ).triggerHandler( "remove" );
					});
				}
			}
			return _remove.call( $(this), selector, keepData );
		});
	};
}

$.widget = function( name, base, prototype ) {
	var namespace = name.split( "." )[ 0 ],
		fullName;
	name = name.split( "." )[ 1 ];
	fullName = namespace + "-" + name;

	if ( !prototype ) {
		prototype = base;
		base = $.Widget;
	}

	// create selector for plugin
	$.expr[ ":" ][ fullName ] = function( elem ) {
		return !!$.data( elem, name );
	};

	$[ namespace ] = $[ namespace ] || {};
	$[ namespace ][ name ] = function( options, element ) {
		// allow instantiation without initializing for simple inheritance
		if ( arguments.length ) {
			this._createWidget( options, element );
		}
	};

	var basePrototype = new base();
	// we need to make the options hash a property directly on the new instance
	// otherwise we'll modify the options hash on the prototype that we're
	// inheriting from
//	$.each( basePrototype, function( key, val ) {
//		if ( $.isPlainObject(val) ) {
//			basePrototype[ key ] = $.extend( {}, val );
//		}
//	});
	basePrototype.options = $.extend( true, {}, basePrototype.options );
	$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
		namespace: namespace,
		widgetName: name,
		widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
		widgetBaseClass: fullName
	}, prototype );

	$.widget.bridge( name, $[ namespace ][ name ] );
};

$.widget.bridge = function( name, object ) {
	$.fn[ name ] = function( options ) {
		var isMethodCall = typeof options === "string",
			args = Array.prototype.slice.call( arguments, 1 ),
			returnValue = this;

		// allow multiple hashes to be passed on init
		options = !isMethodCall && args.length ?
			$.extend.apply( null, [ true, options ].concat(args) ) :
			options;

		// prevent calls to internal methods
		if ( isMethodCall && options.charAt( 0 ) === "_" ) {
			return returnValue;
		}

		if ( isMethodCall ) {
			this.each(function() {
				var instance = $.data( this, name ),
					methodValue = instance && $.isFunction( instance[options] ) ?
						instance[ options ].apply( instance, args ) :
						instance;
				// TODO: add this back in 1.9 and use $.error() (see #5972)
//				if ( !instance ) {
//					throw "cannot call methods on " + name + " prior to initialization; " +
//						"attempted to call method '" + options + "'";
//				}
//				if ( !$.isFunction( instance[options] ) ) {
//					throw "no such method '" + options + "' for " + name + " widget instance";
//				}
//				var methodValue = instance[ options ].apply( instance, args );
				if ( methodValue !== instance && methodValue !== undefined ) {
					returnValue = methodValue;
					return false;
				}
			});
		} else {
			this.each(function() {
				var instance = $.data( this, name );
				if ( instance ) {
					instance.option( options || {} )._init();
				} else {
					$.data( this, name, new object( options, this ) );
				}
			});
		}

		return returnValue;
	};
};

$.Widget = function( options, element ) {
	// allow instantiation without initializing for simple inheritance
	if ( arguments.length ) {
		this._createWidget( options, element );
	}
};

$.Widget.prototype = {
	widgetName: "widget",
	widgetEventPrefix: "",
	options: {
		disabled: false
	},
	_createWidget: function( options, element ) {
		// $.widget.bridge stores the plugin instance, but we do it anyway
		// so that it's stored even before the _create function runs
		$.data( element, this.widgetName, this );
		this.element = $( element );
		this.options = $.extend( true, {},
			this.options,
			this._getCreateOptions(),
			options );

		var self = this;
		this.element.bind( "remove." + this.widgetName, function() {
			self.destroy();
		});

		this._create();
		this._trigger( "create" );
		this._init();
	},
	_getCreateOptions: function() {
		return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
	},
	_create: function() {},
	_init: function() {},

	destroy: function() {
		this.element
			.unbind( "." + this.widgetName )
			.removeData( this.widgetName );
		this.widget()
			.unbind( "." + this.widgetName )
			.removeAttr( "aria-disabled" )
			.removeClass(
				this.widgetBaseClass + "-disabled " +
				"ui-state-disabled" );
	},

	widget: function() {
		return this.element;
	},

	option: function( key, value ) {
		var options = key;

		if ( arguments.length === 0 ) {
			// don't return a reference to the internal hash
			return $.extend( {}, this.options );
		}

		if  (typeof key === "string" ) {
			if ( value === undefined ) {
				return this.options[ key ];
			}
			options = {};
			options[ key ] = value;
		}

		this._setOptions( options );

		return this;
	},
	_setOptions: function( options ) {
		var self = this;
		$.each( options, function( key, value ) {
			self._setOption( key, value );
		});

		return this;
	},
	_setOption: function( key, value ) {
		this.options[ key ] = value;

		if ( key === "disabled" ) {
			this.widget()
				[ value ? "addClass" : "removeClass"](
					this.widgetBaseClass + "-disabled" + " " +
					"ui-state-disabled" )
				.attr( "aria-disabled", value );
		}

		return this;
	},

	enable: function() {
		return this._setOption( "disabled", false );
	},
	disable: function() {
		return this._setOption( "disabled", true );
	},

	_trigger: function( type, event, data ) {
		var callback = this.options[ type ];

		event = $.Event( event );
		event.type = ( type === this.widgetEventPrefix ?
			type :
			this.widgetEventPrefix + type ).toLowerCase();
		data = data || {};

		// copy original event properties over to the new event
		// this would happen if we could call $.event.fix instead of $.Event
		// but we don't have a way to force an event to be fixed multiple times
		if ( event.originalEvent ) {
			for ( var i = $.event.props.length, prop; i; ) {
				prop = $.event.props[ --i ];
				event[ prop ] = event.originalEvent[ prop ];
			}
		}

		this.element.trigger( event, data );

		return !( $.isFunction(callback) &&
			callback.call( this.element[0], event, data ) === false ||
			event.isDefaultPrevented() );
	}
};

})( jQuery );
/*!
 * jQuery UI Mouse 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Mouse
 *
 * Depends:
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget("ui.mouse", {
	options: {
		cancel: ':input,option',
		distance: 1,
		delay: 0
	},
	_mouseInit: function() {
		var self = this;

		this.element
			.bind('mousedown.'+this.widgetName, function(event) {
				return self._mouseDown(event);
			})
			.bind('click.'+this.widgetName, function(event) {
				if (true === $.data(event.target, self.widgetName + '.preventClickEvent')) {
				    $.removeData(event.target, self.widgetName + '.preventClickEvent');
					event.stopImmediatePropagation();
					return false;
				}
			});

		this.started = false;
	},

	// TODO: make sure destroying one instance of mouse doesn't mess with
	// other instances of mouse
	_mouseDestroy: function() {
		this.element.unbind('.'+this.widgetName);
	},

	_mouseDown: function(event) {
		// don't let more than one widget handle mouseStart
		// TODO: figure out why we have to use originalEvent
		event.originalEvent = event.originalEvent || {};
		if (event.originalEvent.mouseHandled) { return; }

		// we may have missed mouseup (out of window)
		(this._mouseStarted && this._mouseUp(event));

		this._mouseDownEvent = event;

		var self = this,
			btnIsLeft = (event.which == 1),
			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
			return true;
		}

		this.mouseDelayMet = !this.options.delay;
		if (!this.mouseDelayMet) {
			this._mouseDelayTimer = setTimeout(function() {
				self.mouseDelayMet = true;
			}, this.options.delay);
		}

		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
			this._mouseStarted = (this._mouseStart(event) !== false);
			if (!this._mouseStarted) {
				event.preventDefault();
				return true;
			}
		}

		// Click event may never have fired (Gecko & Opera)
		if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {
			$.removeData(event.target, this.widgetName + '.preventClickEvent');
		}

		// these delegates are required to keep context
		this._mouseMoveDelegate = function(event) {
			return self._mouseMove(event);
		};
		this._mouseUpDelegate = function(event) {
			return self._mouseUp(event);
		};
		$(document)
			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);

		event.preventDefault();
		event.originalEvent.mouseHandled = true;
		return true;
	},

	_mouseMove: function(event) {
		// IE mouseup check - mouseup happened when mouse was out of window
		if ($.browser.msie && !(document.documentMode >= 9) && !event.button) {
			return this._mouseUp(event);
		}

		if (this._mouseStarted) {
			this._mouseDrag(event);
			return event.preventDefault();
		}

		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
			this._mouseStarted =
				(this._mouseStart(this._mouseDownEvent, event) !== false);
			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
		}

		return !this._mouseStarted;
	},

	_mouseUp: function(event) {
		$(document)
			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);

		if (this._mouseStarted) {
			this._mouseStarted = false;

			if (event.target == this._mouseDownEvent.target) {
			    $.data(event.target, this.widgetName + '.preventClickEvent', true);
			}

			this._mouseStop(event);
		}

		return false;
	},

	_mouseDistanceMet: function(event) {
		return (Math.max(
				Math.abs(this._mouseDownEvent.pageX - event.pageX),
				Math.abs(this._mouseDownEvent.pageY - event.pageY)
			) >= this.options.distance
		);
	},

	_mouseDelayMet: function(event) {
		return this.mouseDelayMet;
	},

	// These are placeholder methods, to be overriden by extending plugin
	_mouseStart: function(event) {},
	_mouseDrag: function(event) {},
	_mouseStop: function(event) {},
	_mouseCapture: function(event) { return true; }
});

})(jQuery);
/*
 * jQuery UI Position 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Position
 */
(function( $, undefined ) {

$.ui = $.ui || {};

var horizontalPositions = /left|center|right/,
	verticalPositions = /top|center|bottom/,
	center = "center",
	_position = $.fn.position,
	_offset = $.fn.offset;

$.fn.position = function( options ) {
	if ( !options || !options.of ) {
		return _position.apply( this, arguments );
	}

	// make a copy, we don't want to modify arguments
	options = $.extend( {}, options );

	var target = $( options.of ),
		targetElem = target[0],
		collision = ( options.collision || "flip" ).split( " " ),
		offset = options.offset ? options.offset.split( " " ) : [ 0, 0 ],
		targetWidth,
		targetHeight,
		basePosition;

	if ( targetElem.nodeType === 9 ) {
		targetWidth = target.width();
		targetHeight = target.height();
		basePosition = { top: 0, left: 0 };
	// TODO: use $.isWindow() in 1.9
	} else if ( targetElem.setTimeout ) {
		targetWidth = target.width();
		targetHeight = target.height();
		basePosition = { top: target.scrollTop(), left: target.scrollLeft() };
	} else if ( targetElem.preventDefault ) {
		// force left top to allow flipping
		options.at = "left top";
		targetWidth = targetHeight = 0;
		basePosition = { top: options.of.pageY, left: options.of.pageX };
	} else {
		targetWidth = target.outerWidth();
		targetHeight = target.outerHeight();
		basePosition = target.offset();
	}

	// force my and at to have valid horizontal and veritcal positions
	// if a value is missing or invalid, it will be converted to center 
	$.each( [ "my", "at" ], function() {
		var pos = ( options[this] || "" ).split( " " );
		if ( pos.length === 1) {
			pos = horizontalPositions.test( pos[0] ) ?
				pos.concat( [center] ) :
				verticalPositions.test( pos[0] ) ?
					[ center ].concat( pos ) :
					[ center, center ];
		}
		pos[ 0 ] = horizontalPositions.test( pos[0] ) ? pos[ 0 ] : center;
		pos[ 1 ] = verticalPositions.test( pos[1] ) ? pos[ 1 ] : center;
		options[ this ] = pos;
	});

	// normalize collision option
	if ( collision.length === 1 ) {
		collision[ 1 ] = collision[ 0 ];
	}

	// normalize offset option
	offset[ 0 ] = parseInt( offset[0], 10 ) || 0;
	if ( offset.length === 1 ) {
		offset[ 1 ] = offset[ 0 ];
	}
	offset[ 1 ] = parseInt( offset[1], 10 ) || 0;

	if ( options.at[0] === "right" ) {
		basePosition.left += targetWidth;
	} else if ( options.at[0] === center ) {
		basePosition.left += targetWidth / 2;
	}

	if ( options.at[1] === "bottom" ) {
		basePosition.top += targetHeight;
	} else if ( options.at[1] === center ) {
		basePosition.top += targetHeight / 2;
	}

	basePosition.left += offset[ 0 ];
	basePosition.top += offset[ 1 ];

	return this.each(function() {
		var elem = $( this ),
			elemWidth = elem.outerWidth(),
			elemHeight = elem.outerHeight(),
			marginLeft = parseInt( $.curCSS( this, "marginLeft", true ) ) || 0,
			marginTop = parseInt( $.curCSS( this, "marginTop", true ) ) || 0,
			collisionWidth = elemWidth + marginLeft +
				( parseInt( $.curCSS( this, "marginRight", true ) ) || 0 ),
			collisionHeight = elemHeight + marginTop +
				( parseInt( $.curCSS( this, "marginBottom", true ) ) || 0 ),
			position = $.extend( {}, basePosition ),
			collisionPosition;

		if ( options.my[0] === "right" ) {
			position.left -= elemWidth;
		} else if ( options.my[0] === center ) {
			position.left -= elemWidth / 2;
		}

		if ( options.my[1] === "bottom" ) {
			position.top -= elemHeight;
		} else if ( options.my[1] === center ) {
			position.top -= elemHeight / 2;
		}

		// prevent fractions (see #5280)
		position.left = Math.round( position.left );
		position.top = Math.round( position.top );

		collisionPosition = {
			left: position.left - marginLeft,
			top: position.top - marginTop
		};

		$.each( [ "left", "top" ], function( i, dir ) {
			if ( $.ui.position[ collision[i] ] ) {
				$.ui.position[ collision[i] ][ dir ]( position, {
					targetWidth: targetWidth,
					targetHeight: targetHeight,
					elemWidth: elemWidth,
					elemHeight: elemHeight,
					collisionPosition: collisionPosition,
					collisionWidth: collisionWidth,
					collisionHeight: collisionHeight,
					offset: offset,
					my: options.my,
					at: options.at
				});
			}
		});

		if ( $.fn.bgiframe ) {
			elem.bgiframe();
		}
		elem.offset( $.extend( position, { using: options.using } ) );
	});
};

$.ui.position = {
	fit: {
		left: function( position, data ) {
			var win = $( window ),
				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft();
			position.left = over > 0 ? position.left - over : Math.max( position.left - data.collisionPosition.left, position.left );
		},
		top: function( position, data ) {
			var win = $( window ),
				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop();
			position.top = over > 0 ? position.top - over : Math.max( position.top - data.collisionPosition.top, position.top );
		}
	},

	flip: {
		left: function( position, data ) {
			if ( data.at[0] === center ) {
				return;
			}
			var win = $( window ),
				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft(),
				myOffset = data.my[ 0 ] === "left" ?
					-data.elemWidth :
					data.my[ 0 ] === "right" ?
						data.elemWidth :
						0,
				atOffset = data.at[ 0 ] === "left" ?
					data.targetWidth :
					-data.targetWidth,
				offset = -2 * data.offset[ 0 ];
			position.left += data.collisionPosition.left < 0 ?
				myOffset + atOffset + offset :
				over > 0 ?
					myOffset + atOffset + offset :
					0;
		},
		top: function( position, data ) {
			if ( data.at[1] === center ) {
				return;
			}
			var win = $( window ),
				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop(),
				myOffset = data.my[ 1 ] === "top" ?
					-data.elemHeight :
					data.my[ 1 ] === "bottom" ?
						data.elemHeight :
						0,
				atOffset = data.at[ 1 ] === "top" ?
					data.targetHeight :
					-data.targetHeight,
				offset = -2 * data.offset[ 1 ];
			position.top += data.collisionPosition.top < 0 ?
				myOffset + atOffset + offset :
				over > 0 ?
					myOffset + atOffset + offset :
					0;
		}
	}
};

// offset setter from jQuery 1.4
if ( !$.offset.setOffset ) {
	$.offset.setOffset = function( elem, options ) {
		// set position first, in-case top/left are set even on static elem
		if ( /static/.test( $.curCSS( elem, "position" ) ) ) {
			elem.style.position = "relative";
		}
		var curElem   = $( elem ),
			curOffset = curElem.offset(),
			curTop    = parseInt( $.curCSS( elem, "top",  true ), 10 ) || 0,
			curLeft   = parseInt( $.curCSS( elem, "left", true ), 10)  || 0,
			props     = {
				top:  (options.top  - curOffset.top)  + curTop,
				left: (options.left - curOffset.left) + curLeft
			};
		
		if ( 'using' in options ) {
			options.using.call( elem, props );
		} else {
			curElem.css( props );
		}
	};

	$.fn.offset = function( options ) {
		var elem = this[ 0 ];
		if ( !elem || !elem.ownerDocument ) { return null; }
		if ( options ) { 
			return this.each(function() {
				$.offset.setOffset( this, options );
			});
		}
		return _offset.call( this );
	};
}

}( jQuery ));
/*
 * jQuery UI Draggable 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Draggables
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget("ui.draggable", $.ui.mouse, {
	widgetEventPrefix: "drag",
	options: {
		addClasses: true,
		appendTo: "parent",
		axis: false,
		connectToSortable: false,
		containment: false,
		cursor: "auto",
		cursorAt: false,
		grid: false,
		handle: false,
		helper: "original",
		iframeFix: false,
		opacity: false,
		refreshPositions: false,
		revert: false,
		revertDuration: 500,
		scope: "default",
		scroll: true,
		scrollSensitivity: 20,
		scrollSpeed: 20,
		snap: false,
		snapMode: "both",
		snapTolerance: 20,
		stack: false,
		zIndex: false
	},
	_create: function() {

		if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
			this.element[0].style.position = 'relative';

		(this.options.addClasses && this.element.addClass("ui-draggable"));
		(this.options.disabled && this.element.addClass("ui-draggable-disabled"));

		this._mouseInit();

	},

	destroy: function() {
		if(!this.element.data('draggable')) return;
		this.element
			.removeData("draggable")
			.unbind(".draggable")
			.removeClass("ui-draggable"
				+ " ui-draggable-dragging"
				+ " ui-draggable-disabled");
		this._mouseDestroy();

		return this;
	},

	_mouseCapture: function(event) {

		var o = this.options;

		// among others, prevent a drag on a resizable-handle
		if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
			return false;

		//Quit if we're not on a valid handle
		this.handle = this._getHandle(event);
		if (!this.handle)
			return false;

		return true;

	},

	_mouseStart: function(event) {

		var o = this.options;

		//Create and append the visible helper
		this.helper = this._createHelper(event);

		//Cache the helper size
		this._cacheHelperProportions();

		//If ddmanager is used for droppables, set the global draggable
		if($.ui.ddmanager)
			$.ui.ddmanager.current = this;

		/*
		 * - Position generation -
		 * This block generates everything position related - it's the core of draggables.
		 */

		//Cache the margins of the original element
		this._cacheMargins();

		//Store the helper's css position
		this.cssPosition = this.helper.css("position");
		this.scrollParent = this.helper.scrollParent();

		//The element's absolute position on the page minus margins
		this.offset = this.positionAbs = this.element.offset();
		this.offset = {
			top: this.offset.top - this.margins.top,
			left: this.offset.left - this.margins.left
		};

		$.extend(this.offset, {
			click: { //Where the click happened, relative to the element
				left: event.pageX - this.offset.left,
				top: event.pageY - this.offset.top
			},
			parent: this._getParentOffset(),
			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
		});

		//Generate the original position
		this.originalPosition = this.position = this._generatePosition(event);
		this.originalPageX = event.pageX;
		this.originalPageY = event.pageY;

		//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));

		//Set a containment if given in the options
		if(o.containment)
			this._setContainment();

		//Trigger event + callbacks
		if(this._trigger("start", event) === false) {
			this._clear();
			return false;
		}

		//Recache the helper size
		this._cacheHelperProportions();

		//Prepare the droppable offsets
		if ($.ui.ddmanager && !o.dropBehaviour)
			$.ui.ddmanager.prepareOffsets(this, event);

		this.helper.addClass("ui-draggable-dragging");
		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
		return true;
	},

	_mouseDrag: function(event, noPropagation) {

		//Compute the helpers position
		this.position = this._generatePosition(event);
		this.positionAbs = this._convertPositionTo("absolute");

		//Call plugins and callbacks and use the resulting position if something is returned
		if (!noPropagation) {
			var ui = this._uiHash();
			if(this._trigger('drag', event, ui) === false) {
				this._mouseUp({});
				return false;
			}
			this.position = ui.position;
		}

		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
		if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);

		return false;
	},

	_mouseStop: function(event) {

		//If we are using droppables, inform the manager about the drop
		var dropped = false;
		if ($.ui.ddmanager && !this.options.dropBehaviour)
			dropped = $.ui.ddmanager.drop(this, event);

		//if a drop comes from outside (a sortable)
		if(this.dropped) {
			dropped = this.dropped;
			this.dropped = false;
		}
		
		//if the original element is removed, don't bother to continue if helper is set to "original"
		if((!this.element[0] || !this.element[0].parentNode) && this.options.helper == "original")
			return false;

		if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
			var self = this;
			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
				if(self._trigger("stop", event) !== false) {
					self._clear();
				}
			});
		} else {
			if(this._trigger("stop", event) !== false) {
				this._clear();
			}
		}

		return false;
	},
	
	cancel: function() {
		
		if(this.helper.is(".ui-draggable-dragging")) {
			this._mouseUp({});
		} else {
			this._clear();
		}
		
		return this;
		
	},

	_getHandle: function(event) {

		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
		$(this.options.handle, this.element)
			.find("*")
			.andSelf()
			.each(function() {
				if(this == event.target) handle = true;
			});

		return handle;

	},

	_createHelper: function(event) {

		var o = this.options;
		var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone() : this.element);

		if(!helper.parents('body').length)
			helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));

		if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
			helper.css("position", "absolute");

		return helper;

	},

	_adjustOffsetFromHelper: function(obj) {
		if (typeof obj == 'string') {
			obj = obj.split(' ');
		}
		if ($.isArray(obj)) {
			obj = {left: +obj[0], top: +obj[1] || 0};
		}
		if ('left' in obj) {
			this.offset.click.left = obj.left + this.margins.left;
		}
		if ('right' in obj) {
			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
		}
		if ('top' in obj) {
			this.offset.click.top = obj.top + this.margins.top;
		}
		if ('bottom' in obj) {
			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
		}
	},

	_getParentOffset: function() {

		//Get the offsetParent and cache its position
		this.offsetParent = this.helper.offsetParent();
		var po = this.offsetParent.offset();

		// This is a special case where we need to modify a offset calculated on start, since the following happened:
		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
		if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
			po.left += this.scrollParent.scrollLeft();
			po.top += this.scrollParent.scrollTop();
		}

		if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
			po = { top: 0, left: 0 };

		return {
			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
		};

	},

	_getRelativeOffset: function() {

		if(this.cssPosition == "relative") {
			var p = this.element.position();
			return {
				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
			};
		} else {
			return { top: 0, left: 0 };
		}

	},

	_cacheMargins: function() {
		this.margins = {
			left: (parseInt(this.element.css("marginLeft"),10) || 0),
			top: (parseInt(this.element.css("marginTop"),10) || 0),
			right: (parseInt(this.element.css("marginRight"),10) || 0),
			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
		};
	},

	_cacheHelperProportions: function() {
		this.helperProportions = {
			width: this.helper.outerWidth(),
			height: this.helper.outerHeight()
		};
	},

	_setContainment: function() {

		var o = this.options;
		if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
		if(o.containment == 'document' || o.containment == 'window') this.containment = [
			(o.containment == 'document' ? 0 : $(window).scrollLeft()) - this.offset.relative.left - this.offset.parent.left,
			(o.containment == 'document' ? 0 : $(window).scrollTop()) - this.offset.relative.top - this.offset.parent.top,
			(o.containment == 'document' ? 0 : $(window).scrollLeft()) + $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
			(o.containment == 'document' ? 0 : $(window).scrollTop()) + ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
		];

		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
			var ce = $(o.containment)[0]; if(!ce) return;
			var co = $(o.containment).offset();
			var over = ($(ce).css("overflow") != 'hidden');

			this.containment = [
				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),
				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
			];
		} else if(o.containment.constructor == Array) {
			this.containment = o.containment;
		}

	},

	_convertPositionTo: function(d, pos) {

		if(!pos) pos = this.position;
		var mod = d == "absolute" ? 1 : -1;
		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

		return {
			top: (
				pos.top																	// The absolute mouse position
				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
			),
			left: (
				pos.left																// The absolute mouse position
				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
			)
		};

	},

	_generatePosition: function(event) {

		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
		var pageX = event.pageX;
		var pageY = event.pageY;

		/*
		 * - Position constraining -
		 * Constrain the position to a mix of grid, containment.
		 */

		if(this.originalPosition) { //If we are not dragging yet, we won't check for options

			if(this.containment) {
				if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
				if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
				if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
				if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
			}

			if(o.grid) {
				var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
				pageY = this.containment ? (!(top - this.offset.click.top < this.containment[1] || top - this.offset.click.top > this.containment[3]) ? top : (!(top - this.offset.click.top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;

				var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
				pageX = this.containment ? (!(left - this.offset.click.left < this.containment[0] || left - this.offset.click.left > this.containment[2]) ? left : (!(left - this.offset.click.left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
			}

		}

		return {
			top: (
				pageY																// The absolute mouse position
				- this.offset.click.top													// Click offset (relative to the element)
				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
			),
			left: (
				pageX																// The absolute mouse position
				- this.offset.click.left												// Click offset (relative to the element)
				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
			)
		};

	},

	_clear: function() {
		this.helper.removeClass("ui-draggable-dragging");
		if(this.helper[0] != this.element[0] && !this.cancelHelperRemoval) this.helper.remove();
		//if($.ui.ddmanager) $.ui.ddmanager.current = null;
		this.helper = null;
		this.cancelHelperRemoval = false;
	},

	// From now on bulk stuff - mainly helpers

	_trigger: function(type, event, ui) {
		ui = ui || this._uiHash();
		$.ui.plugin.call(this, type, [event, ui]);
		if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
		return $.Widget.prototype._trigger.call(this, type, event, ui);
	},

	plugins: {},

	_uiHash: function(event) {
		return {
			helper: this.helper,
			position: this.position,
			originalPosition: this.originalPosition,
			offset: this.positionAbs
		};
	}

});

$.extend($.ui.draggable, {
	version: "1.8.11"
});

$.ui.plugin.add("draggable", "connectToSortable", {
	start: function(event, ui) {

		var inst = $(this).data("draggable"), o = inst.options,
			uiSortable = $.extend({}, ui, { item: inst.element });
		inst.sortables = [];
		$(o.connectToSortable).each(function() {
			var sortable = $.data(this, 'sortable');
			if (sortable && !sortable.options.disabled) {
				inst.sortables.push({
					instance: sortable,
					shouldRevert: sortable.options.revert
				});
				sortable.refreshPositions();	// Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
				sortable._trigger("activate", event, uiSortable);
			}
		});

	},
	stop: function(event, ui) {

		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
		var inst = $(this).data("draggable"),
			uiSortable = $.extend({}, ui, { item: inst.element });

		$.each(inst.sortables, function() {
			if(this.instance.isOver) {

				this.instance.isOver = 0;

				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)

				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
				if(this.shouldRevert) this.instance.options.revert = true;

				//Trigger the stop of the sortable
				this.instance._mouseStop(event);

				this.instance.options.helper = this.instance.options._helper;

				//If the helper has been the original item, restore properties in the sortable
				if(inst.options.helper == 'original')
					this.instance.currentItem.css({ top: 'auto', left: 'auto' });

			} else {
				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
				this.instance._trigger("deactivate", event, uiSortable);
			}

		});

	},
	drag: function(event, ui) {

		var inst = $(this).data("draggable"), self = this;

		var checkPos = function(o) {
			var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
			var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
			var itemHeight = o.height, itemWidth = o.width;
			var itemTop = o.top, itemLeft = o.left;

			return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
		};

		$.each(inst.sortables, function(i) {
			
			//Copy over some variables to allow calling the sortable's native _intersectsWith
			this.instance.positionAbs = inst.positionAbs;
			this.instance.helperProportions = inst.helperProportions;
			this.instance.offset.click = inst.offset.click;
			
			if(this.instance._intersectsWith(this.instance.containerCache)) {

				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
				if(!this.instance.isOver) {

					this.instance.isOver = 1;
					//Now we fake the start of dragging for the sortable instance,
					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
					//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
					this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
					this.instance.options.helper = function() { return ui.helper[0]; };

					event.target = this.instance.currentItem[0];
					this.instance._mouseCapture(event, true);
					this.instance._mouseStart(event, true, true);

					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
					this.instance.offset.click.top = inst.offset.click.top;
					this.instance.offset.click.left = inst.offset.click.left;
					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;

					inst._trigger("toSortable", event);
					inst.dropped = this.instance.element; //draggable revert needs that
					//hack so receive/update callbacks work (mostly)
					inst.currentItem = inst.element;
					this.instance.fromOutside = inst;

				}

				//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
				if(this.instance.currentItem) this.instance._mouseDrag(event);

			} else {

				//If it doesn't intersect with the sortable, and it intersected before,
				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
				if(this.instance.isOver) {

					this.instance.isOver = 0;
					this.instance.cancelHelperRemoval = true;
					
					//Prevent reverting on this forced stop
					this.instance.options.revert = false;
					
					// The out event needs to be triggered independently
					this.instance._trigger('out', event, this.instance._uiHash(this.instance));
					
					this.instance._mouseStop(event, true);
					this.instance.options.helper = this.instance.options._helper;

					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
					this.instance.currentItem.remove();
					if(this.instance.placeholder) this.instance.placeholder.remove();

					inst._trigger("fromSortable", event);
					inst.dropped = false; //draggable revert needs that
				}

			};

		});

	}
});

$.ui.plugin.add("draggable", "cursor", {
	start: function(event, ui) {
		var t = $('body'), o = $(this).data('draggable').options;
		if (t.css("cursor")) o._cursor = t.css("cursor");
		t.css("cursor", o.cursor);
	},
	stop: function(event, ui) {
		var o = $(this).data('draggable').options;
		if (o._cursor) $('body').css("cursor", o._cursor);
	}
});

$.ui.plugin.add("draggable", "iframeFix", {
	start: function(event, ui) {
		var o = $(this).data('draggable').options;
		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
			$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
			.css({
				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
				position: "absolute", opacity: "0.001", zIndex: 1000
			})
			.css($(this).offset())
			.appendTo("body");
		});
	},
	stop: function(event, ui) {
		$("div.ui-draggable-iframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers
	}
});

$.ui.plugin.add("draggable", "opacity", {
	start: function(event, ui) {
		var t = $(ui.helper), o = $(this).data('draggable').options;
		if(t.css("opacity")) o._opacity = t.css("opacity");
		t.css('opacity', o.opacity);
	},
	stop: function(event, ui) {
		var o = $(this).data('draggable').options;
		if(o._opacity) $(ui.helper).css('opacity', o._opacity);
	}
});

$.ui.plugin.add("draggable", "scroll", {
	start: function(event, ui) {
		var i = $(this).data("draggable");
		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
	},
	drag: function(event, ui) {

		var i = $(this).data("draggable"), o = i.options, scrolled = false;

		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {

			if(!o.axis || o.axis != 'x') {
				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
				else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
			}

			if(!o.axis || o.axis != 'y') {
				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
				else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
			}

		} else {

			if(!o.axis || o.axis != 'x') {
				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
				else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
			}

			if(!o.axis || o.axis != 'y') {
				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
				else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
			}

		}

		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
			$.ui.ddmanager.prepareOffsets(i, event);

	}
});

$.ui.plugin.add("draggable", "snap", {
	start: function(event, ui) {

		var i = $(this).data("draggable"), o = i.options;
		i.snapElements = [];

		$(o.snap.constructor != String ? ( o.snap.items || ':data(draggable)' ) : o.snap).each(function() {
			var $t = $(this); var $o = $t.offset();
			if(this != i.element[0]) i.snapElements.push({
				item: this,
				width: $t.outerWidth(), height: $t.outerHeight(),
				top: $o.top, left: $o.left
			});
		});

	},
	drag: function(event, ui) {

		var inst = $(this).data("draggable"), o = inst.options;
		var d = o.snapTolerance;

		var x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;

		for (var i = inst.snapElements.length - 1; i >= 0; i--){

			var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width,
				t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;

			//Yes, I know, this is insane ;)
			if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
				if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
				inst.snapElements[i].snapping = false;
				continue;
			}

			if(o.snapMode != 'inner') {
				var ts = Math.abs(t - y2) <= d;
				var bs = Math.abs(b - y1) <= d;
				var ls = Math.abs(l - x2) <= d;
				var rs = Math.abs(r - x1) <= d;
				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
			}

			var first = (ts || bs || ls || rs);

			if(o.snapMode != 'outer') {
				var ts = Math.abs(t - y1) <= d;
				var bs = Math.abs(b - y2) <= d;
				var ls = Math.abs(l - x1) <= d;
				var rs = Math.abs(r - x2) <= d;
				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
			}

			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);

		};

	}
});

$.ui.plugin.add("draggable", "stack", {
	start: function(event, ui) {

		var o = $(this).data("draggable").options;

		var group = $.makeArray($(o.stack)).sort(function(a,b) {
			return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
		});
		if (!group.length) { return; }
		
		var min = parseInt(group[0].style.zIndex) || 0;
		$(group).each(function(i) {
			this.style.zIndex = min + i;
		});

		this[0].style.zIndex = min + group.length;

	}
});

$.ui.plugin.add("draggable", "zIndex", {
	start: function(event, ui) {
		var t = $(ui.helper), o = $(this).data("draggable").options;
		if(t.css("zIndex")) o._zIndex = t.css("zIndex");
		t.css('zIndex', o.zIndex);
	},
	stop: function(event, ui) {
		var o = $(this).data("draggable").options;
		if(o._zIndex) $(ui.helper).css('zIndex', o._zIndex);
	}
});

})(jQuery);
/*
 * jQuery UI Droppable 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Droppables
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 *	jquery.ui.mouse.js
 *	jquery.ui.draggable.js
 */
(function( $, undefined ) {

$.widget("ui.droppable", {
	widgetEventPrefix: "drop",
	options: {
		accept: '*',
		activeClass: false,
		addClasses: true,
		greedy: false,
		hoverClass: false,
		scope: 'default',
		tolerance: 'intersect'
	},
	_create: function() {

		var o = this.options, accept = o.accept;
		this.isover = 0; this.isout = 1;

		this.accept = $.isFunction(accept) ? accept : function(d) {
			return d.is(accept);
		};

		//Store the droppable's proportions
		this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };

		// Add the reference and positions to the manager
		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
		$.ui.ddmanager.droppables[o.scope].push(this);

		(o.addClasses && this.element.addClass("ui-droppable"));

	},

	destroy: function() {
		var drop = $.ui.ddmanager.droppables[this.options.scope];
		for ( var i = 0; i < drop.length; i++ )
			if ( drop[i] == this )
				drop.splice(i, 1);

		this.element
			.removeClass("ui-droppable ui-droppable-disabled")
			.removeData("droppable")
			.unbind(".droppable");

		return this;
	},

	_setOption: function(key, value) {

		if(key == 'accept') {
			this.accept = $.isFunction(value) ? value : function(d) {
				return d.is(value);
			};
		}
		$.Widget.prototype._setOption.apply(this, arguments);
	},

	_activate: function(event) {
		var draggable = $.ui.ddmanager.current;
		if(this.options.activeClass) this.element.addClass(this.options.activeClass);
		(draggable && this._trigger('activate', event, this.ui(draggable)));
	},

	_deactivate: function(event) {
		var draggable = $.ui.ddmanager.current;
		if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
		(draggable && this._trigger('deactivate', event, this.ui(draggable)));
	},

	_over: function(event) {

		var draggable = $.ui.ddmanager.current;
		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element

		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
			if(this.options.hoverClass) this.element.addClass(this.options.hoverClass);
			this._trigger('over', event, this.ui(draggable));
		}

	},

	_out: function(event) {

		var draggable = $.ui.ddmanager.current;
		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element

		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
			if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
			this._trigger('out', event, this.ui(draggable));
		}

	},

	_drop: function(event,custom) {

		var draggable = custom || $.ui.ddmanager.current;
		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element

		var childrenIntersection = false;
		this.element.find(":data(droppable)").not(".ui-draggable-dragging").each(function() {
			var inst = $.data(this, 'droppable');
			if(
				inst.options.greedy
				&& !inst.options.disabled
				&& inst.options.scope == draggable.options.scope
				&& inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element))
				&& $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
			) { childrenIntersection = true; return false; }
		});
		if(childrenIntersection) return false;

		if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
			if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
			if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
			this._trigger('drop', event, this.ui(draggable));
			return this.element;
		}

		return false;

	},

	ui: function(c) {
		return {
			draggable: (c.currentItem || c.element),
			helper: c.helper,
			position: c.position,
			offset: c.positionAbs
		};
	}

});

$.extend($.ui.droppable, {
	version: "1.8.11"
});

$.ui.intersect = function(draggable, droppable, toleranceMode) {

	if (!droppable.offset) return false;

	var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
		y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
	var l = droppable.offset.left, r = l + droppable.proportions.width,
		t = droppable.offset.top, b = t + droppable.proportions.height;

	switch (toleranceMode) {
		case 'fit':
			return (l <= x1 && x2 <= r
				&& t <= y1 && y2 <= b);
			break;
		case 'intersect':
			return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
				&& x2 - (draggable.helperProportions.width / 2) < r // Left Half
				&& t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
				&& y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
			break;
		case 'pointer':
			var draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left),
				draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top),
				isOver = $.ui.isOver(draggableTop, draggableLeft, t, l, droppable.proportions.height, droppable.proportions.width);
			return isOver;
			break;
		case 'touch':
			return (
					(y1 >= t && y1 <= b) ||	// Top edge touching
					(y2 >= t && y2 <= b) ||	// Bottom edge touching
					(y1 < t && y2 > b)		// Surrounded vertically
				) && (
					(x1 >= l && x1 <= r) ||	// Left edge touching
					(x2 >= l && x2 <= r) ||	// Right edge touching
					(x1 < l && x2 > r)		// Surrounded horizontally
				);
			break;
		default:
			return false;
			break;
		}

};

/*
	This manager tracks offsets of draggables and droppables
*/
$.ui.ddmanager = {
	current: null,
	droppables: { 'default': [] },
	prepareOffsets: function(t, event) {

		var m = $.ui.ddmanager.droppables[t.options.scope] || [];
		var type = event ? event.type : null; // workaround for #2317
		var list = (t.currentItem || t.element).find(":data(droppable)").andSelf();

		droppablesLoop: for (var i = 0; i < m.length; i++) {

			if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) continue;	//No disabled and non-accepted
			for (var j=0; j < list.length; j++) { if(list[j] == m[i].element[0]) { m[i].proportions.height = 0; continue droppablesLoop; } }; //Filter out elements in the current dragged item
			m[i].visible = m[i].element.css("display") != "none"; if(!m[i].visible) continue; 									//If the element is not visible, continue

			if(type == "mousedown") m[i]._activate.call(m[i], event); //Activate the droppable if used directly from draggables

			m[i].offset = m[i].element.offset();
			m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };

		}

	},
	drop: function(draggable, event) {

		var dropped = false;
		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {

			if(!this.options) return;
			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
				dropped = dropped || this._drop.call(this, event);

			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
				this.isout = 1; this.isover = 0;
				this._deactivate.call(this, event);
			}

		});
		return dropped;

	},
	drag: function(draggable, event) {

		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
		if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, event);

		//Run through all droppables and check their positions based on specific tolerance options
		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {

			if(this.options.disabled || this.greedyChild || !this.visible) return;
			var intersects = $.ui.intersect(draggable, this, this.options.tolerance);

			var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
			if(!c) return;

			var parentInstance;
			if (this.options.greedy) {
				var parent = this.element.parents(':data(droppable):eq(0)');
				if (parent.length) {
					parentInstance = $.data(parent[0], 'droppable');
					parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
				}
			}

			// we just moved into a greedy child
			if (parentInstance && c == 'isover') {
				parentInstance['isover'] = 0;
				parentInstance['isout'] = 1;
				parentInstance._out.call(parentInstance, event);
			}

			this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
			this[c == "isover" ? "_over" : "_out"].call(this, event);

			// we just moved out of a greedy child
			if (parentInstance && c == 'isout') {
				parentInstance['isout'] = 0;
				parentInstance['isover'] = 1;
				parentInstance._over.call(parentInstance, event);
			}
		});

	}
};

})(jQuery);
/*
 * jQuery UI Resizable 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Resizables
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget("ui.resizable", $.ui.mouse, {
	widgetEventPrefix: "resize",
	options: {
		alsoResize: false,
		animate: false,
		animateDuration: "slow",
		animateEasing: "swing",
		aspectRatio: false,
		autoHide: false,
		containment: false,
		ghost: false,
		grid: false,
		handles: "e,s,se",
		helper: false,
		maxHeight: null,
		maxWidth: null,
		minHeight: 10,
		minWidth: 10,
		zIndex: 1000
	},
	_create: function() {

		var self = this, o = this.options;
		this.element.addClass("ui-resizable");

		$.extend(this, {
			_aspectRatio: !!(o.aspectRatio),
			aspectRatio: o.aspectRatio,
			originalElement: this.element,
			_proportionallyResizeElements: [],
			_helper: o.helper || o.ghost || o.animate ? o.helper || 'ui-resizable-helper' : null
		});

		//Wrap the element if it cannot hold child nodes
		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {

			//Opera fix for relative positioning
			if (/relative/.test(this.element.css('position')) && $.browser.opera)
				this.element.css({ position: 'relative', top: 'auto', left: 'auto' });

			//Create a wrapper element and set the wrapper to the new current internal element
			this.element.wrap(
				$('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({
					position: this.element.css('position'),
					width: this.element.outerWidth(),
					height: this.element.outerHeight(),
					top: this.element.css('top'),
					left: this.element.css('left')
				})
			);

			//Overwrite the original this.element
			this.element = this.element.parent().data(
				"resizable", this.element.data('resizable')
			);

			this.elementIsWrapper = true;

			//Move margins to the wrapper
			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});

			//Prevent Safari textarea resize
			this.originalResizeStyle = this.originalElement.css('resize');
			this.originalElement.css('resize', 'none');

			//Push the actual element to our proportionallyResize internal array
			this._proportionallyResizeElements.push(this.originalElement.css({ position: 'static', zoom: 1, display: 'block' }));

			// avoid IE jump (hard set the margin)
			this.originalElement.css({ margin: this.originalElement.css('margin') });

			// fix handlers offset
			this._proportionallyResize();

		}

		this.handles = o.handles || (!$('.ui-resizable-handle', this.element).length ? "e,s,se" : { n: '.ui-resizable-n', e: '.ui-resizable-e', s: '.ui-resizable-s', w: '.ui-resizable-w', se: '.ui-resizable-se', sw: '.ui-resizable-sw', ne: '.ui-resizable-ne', nw: '.ui-resizable-nw' });
		if(this.handles.constructor == String) {

			if(this.handles == 'all') this.handles = 'n,e,s,w,se,sw,ne,nw';
			var n = this.handles.split(","); this.handles = {};

			for(var i = 0; i < n.length; i++) {

				var handle = $.trim(n[i]), hname = 'ui-resizable-'+handle;
				var axis = $('<div class="ui-resizable-handle ' + hname + '"></div>');

				// increase zIndex of sw, se, ne, nw axis
				//TODO : this modifies original option
				if(/sw|se|ne|nw/.test(handle)) axis.css({ zIndex: ++o.zIndex });

				//TODO : What's going on here?
				if ('se' == handle) {
					axis.addClass('ui-icon ui-icon-gripsmall-diagonal-se');
				};

				//Insert into internal handles object and append to element
				this.handles[handle] = '.ui-resizable-'+handle;
				this.element.append(axis);
			}

		}

		this._renderAxis = function(target) {

			target = target || this.element;

			for(var i in this.handles) {

				if(this.handles[i].constructor == String)
					this.handles[i] = $(this.handles[i], this.element).show();

				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {

					var axis = $(this.handles[i], this.element), padWrapper = 0;

					//Checking the correct pad and border
					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();

					//The padding type i have to apply...
					var padPos = [ 'padding',
						/ne|nw|n/.test(i) ? 'Top' :
						/se|sw|s/.test(i) ? 'Bottom' :
						/^e$/.test(i) ? 'Right' : 'Left' ].join("");

					target.css(padPos, padWrapper);

					this._proportionallyResize();

				}

				//TODO: What's that good for? There's not anything to be executed left
				if(!$(this.handles[i]).length)
					continue;

			}
		};

		//TODO: make renderAxis a prototype function
		this._renderAxis(this.element);

		this._handles = $('.ui-resizable-handle', this.element)
			.disableSelection();

		//Matching axis name
		this._handles.mouseover(function() {
			if (!self.resizing) {
				if (this.className)
					var axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
				//Axis, default = se
				self.axis = axis && axis[1] ? axis[1] : 'se';
			}
		});

		//If we want to auto hide the elements
		if (o.autoHide) {
			this._handles.hide();
			$(this.element)
				.addClass("ui-resizable-autohide")
				.hover(function() {
					$(this).removeClass("ui-resizable-autohide");
					self._handles.show();
				},
				function(){
					if (!self.resizing) {
						$(this).addClass("ui-resizable-autohide");
						self._handles.hide();
					}
				});
		}

		//Initialize the mouse interaction
		this._mouseInit();

	},

	destroy: function() {

		this._mouseDestroy();

		var _destroy = function(exp) {
			$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
				.removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
		};

		//TODO: Unwrap at same DOM position
		if (this.elementIsWrapper) {
			_destroy(this.element);
			var wrapper = this.element;
			wrapper.after(
				this.originalElement.css({
					position: wrapper.css('position'),
					width: wrapper.outerWidth(),
					height: wrapper.outerHeight(),
					top: wrapper.css('top'),
					left: wrapper.css('left')
				})
			).remove();
		}

		this.originalElement.css('resize', this.originalResizeStyle);
		_destroy(this.originalElement);

		return this;
	},

	_mouseCapture: function(event) {
		var handle = false;
		for (var i in this.handles) {
			if ($(this.handles[i])[0] == event.target) {
				handle = true;
			}
		}

		return !this.options.disabled && handle;
	},

	_mouseStart: function(event) {

		var o = this.options, iniPos = this.element.position(), el = this.element;

		this.resizing = true;
		this.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };

		// bugfix for http://dev.jquery.com/ticket/1749
		if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {
			el.css({ position: 'absolute', top: iniPos.top, left: iniPos.left });
		}

		//Opera fixing relative position
		if ($.browser.opera && (/relative/).test(el.css('position')))
			el.css({ position: 'relative', top: 'auto', left: 'auto' });

		this._renderProxy();

		var curleft = num(this.helper.css('left')), curtop = num(this.helper.css('top'));

		if (o.containment) {
			curleft += $(o.containment).scrollLeft() || 0;
			curtop += $(o.containment).scrollTop() || 0;
		}

		//Store needed variables
		this.offset = this.helper.offset();
		this.position = { left: curleft, top: curtop };
		this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
		this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
		this.originalPosition = { left: curleft, top: curtop };
		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
		this.originalMousePosition = { left: event.pageX, top: event.pageY };

		//Aspect Ratio
		this.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);

	    var cursor = $('.ui-resizable-' + this.axis).css('cursor');
	    $('body').css('cursor', cursor == 'auto' ? this.axis + '-resize' : cursor);

		el.addClass("ui-resizable-resizing");
		this._propagate("start", event);
		return true;
	},

	_mouseDrag: function(event) {

		//Increase performance, avoid regex
		var el = this.helper, o = this.options, props = {},
			self = this, smp = this.originalMousePosition, a = this.axis;

		var dx = (event.pageX-smp.left)||0, dy = (event.pageY-smp.top)||0;
		var trigger = this._change[a];
		if (!trigger) return false;

		// Calculate the attrs that will be change
		var data = trigger.apply(this, [event, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;

		if (this._aspectRatio || event.shiftKey)
			data = this._updateRatio(data, event);

		data = this._respectSize(data, event);

		// plugins callbacks need to be called first
		this._propagate("resize", event);

		el.css({
			top: this.position.top + "px", left: this.position.left + "px",
			width: this.size.width + "px", height: this.size.height + "px"
		});

		if (!this._helper && this._proportionallyResizeElements.length)
			this._proportionallyResize();

		this._updateCache(data);

		// calling the user callback at the end
		this._trigger('resize', event, this.ui());

		return false;
	},

	_mouseStop: function(event) {

		this.resizing = false;
		var o = this.options, self = this;

		if(this._helper) {
			var pr = this._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
				soffseth = ista && $.ui.hasScroll(pr[0], 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
				soffsetw = ista ? 0 : self.sizeDiff.width;

			var s = { width: (self.helper.width()  - soffsetw), height: (self.helper.height() - soffseth) },
				left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
				top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;

			if (!o.animate)
				this.element.css($.extend(s, { top: top, left: left }));

			self.helper.height(self.size.height);
			self.helper.width(self.size.width);

			if (this._helper && !o.animate) this._proportionallyResize();
		}

		$('body').css('cursor', 'auto');

		this.element.removeClass("ui-resizable-resizing");

		this._propagate("stop", event);

		if (this._helper) this.helper.remove();
		return false;

	},

	_updateCache: function(data) {
		var o = this.options;
		this.offset = this.helper.offset();
		if (isNumber(data.left)) this.position.left = data.left;
		if (isNumber(data.top)) this.position.top = data.top;
		if (isNumber(data.height)) this.size.height = data.height;
		if (isNumber(data.width)) this.size.width = data.width;
	},

	_updateRatio: function(data, event) {

		var o = this.options, cpos = this.position, csize = this.size, a = this.axis;

		if (data.height) data.width = (csize.height * this.aspectRatio);
		else if (data.width) data.height = (csize.width / this.aspectRatio);

		if (a == 'sw') {
			data.left = cpos.left + (csize.width - data.width);
			data.top = null;
		}
		if (a == 'nw') {
			data.top = cpos.top + (csize.height - data.height);
			data.left = cpos.left + (csize.width - data.width);
		}

		return data;
	},

	_respectSize: function(data, event) {

		var el = this.helper, o = this.options, pRatio = this._aspectRatio || event.shiftKey, a = this.axis,
				ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
					isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height);

		if (isminw) data.width = o.minWidth;
		if (isminh) data.height = o.minHeight;
		if (ismaxw) data.width = o.maxWidth;
		if (ismaxh) data.height = o.maxHeight;

		var dw = this.originalPosition.left + this.originalSize.width, dh = this.position.top + this.size.height;
		var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);

		if (isminw && cw) data.left = dw - o.minWidth;
		if (ismaxw && cw) data.left = dw - o.maxWidth;
		if (isminh && ch)	data.top = dh - o.minHeight;
		if (ismaxh && ch)	data.top = dh - o.maxHeight;

		// fixing jump error on top/left - bug #2330
		var isNotwh = !data.width && !data.height;
		if (isNotwh && !data.left && data.top) data.top = null;
		else if (isNotwh && !data.top && data.left) data.left = null;

		return data;
	},

	_proportionallyResize: function() {

		var o = this.options;
		if (!this._proportionallyResizeElements.length) return;
		var element = this.helper || this.element;

		for (var i=0; i < this._proportionallyResizeElements.length; i++) {

			var prel = this._proportionallyResizeElements[i];

			if (!this.borderDif) {
				var b = [prel.css('borderTopWidth'), prel.css('borderRightWidth'), prel.css('borderBottomWidth'), prel.css('borderLeftWidth')],
					p = [prel.css('paddingTop'), prel.css('paddingRight'), prel.css('paddingBottom'), prel.css('paddingLeft')];

				this.borderDif = $.map(b, function(v, i) {
					var border = parseInt(v,10)||0, padding = parseInt(p[i],10)||0;
					return border + padding;
				});
			}

			if ($.browser.msie && !(!($(element).is(':hidden') || $(element).parents(':hidden').length)))
				continue;

			prel.css({
				height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
				width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
			});

		};

	},

	_renderProxy: function() {

		var el = this.element, o = this.options;
		this.elementOffset = el.offset();

		if(this._helper) {

			this.helper = this.helper || $('<div style="overflow:hidden;"></div>');

			// fix ie6 offset TODO: This seems broken
			var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
			pxyoffset = ( ie6 ? 2 : -1 );

			this.helper.addClass(this._helper).css({
				width: this.element.outerWidth() + pxyoffset,
				height: this.element.outerHeight() + pxyoffset,
				position: 'absolute',
				left: this.elementOffset.left - ie6offset +'px',
				top: this.elementOffset.top - ie6offset +'px',
				zIndex: ++o.zIndex //TODO: Don't modify option
			});

			this.helper
				.appendTo("body")
				.disableSelection();

		} else {
			this.helper = this.element;
		}

	},

	_change: {
		e: function(event, dx, dy) {
			return { width: this.originalSize.width + dx };
		},
		w: function(event, dx, dy) {
			var o = this.options, cs = this.originalSize, sp = this.originalPosition;
			return { left: sp.left + dx, width: cs.width - dx };
		},
		n: function(event, dx, dy) {
			var o = this.options, cs = this.originalSize, sp = this.originalPosition;
			return { top: sp.top + dy, height: cs.height - dy };
		},
		s: function(event, dx, dy) {
			return { height: this.originalSize.height + dy };
		},
		se: function(event, dx, dy) {
			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
		},
		sw: function(event, dx, dy) {
			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
		},
		ne: function(event, dx, dy) {
			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
		},
		nw: function(event, dx, dy) {
			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
		}
	},

	_propagate: function(n, event) {
		$.ui.plugin.call(this, n, [event, this.ui()]);
		(n != "resize" && this._trigger(n, event, this.ui()));
	},

	plugins: {},

	ui: function() {
		return {
			originalElement: this.originalElement,
			element: this.element,
			helper: this.helper,
			position: this.position,
			size: this.size,
			originalSize: this.originalSize,
			originalPosition: this.originalPosition
		};
	}

});

$.extend($.ui.resizable, {
	version: "1.8.11"
});

/*
 * Resizable Extensions
 */

$.ui.plugin.add("resizable", "alsoResize", {

	start: function (event, ui) {
		var self = $(this).data("resizable"), o = self.options;

		var _store = function (exp) {
			$(exp).each(function() {
				var el = $(this);
				el.data("resizable-alsoresize", {
					width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
					left: parseInt(el.css('left'), 10), top: parseInt(el.css('top'), 10),
					position: el.css('position') // to reset Opera on stop()
				});
			});
		};

		if (typeof(o.alsoResize) == 'object' && !o.alsoResize.parentNode) {
			if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
			else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
		}else{
			_store(o.alsoResize);
		}
	},

	resize: function (event, ui) {
		var self = $(this).data("resizable"), o = self.options, os = self.originalSize, op = self.originalPosition;

		var delta = {
			height: (self.size.height - os.height) || 0, width: (self.size.width - os.width) || 0,
			top: (self.position.top - op.top) || 0, left: (self.position.left - op.left) || 0
		},

		_alsoResize = function (exp, c) {
			$(exp).each(function() {
				var el = $(this), start = $(this).data("resizable-alsoresize"), style = {}, 
					css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ['width', 'height'] : ['width', 'height', 'top', 'left'];

				$.each(css, function (i, prop) {
					var sum = (start[prop]||0) + (delta[prop]||0);
					if (sum && sum >= 0)
						style[prop] = sum || null;
				});

				// Opera fixing relative position
				if ($.browser.opera && /relative/.test(el.css('position'))) {
					self._revertToRelativePosition = true;
					el.css({ position: 'absolute', top: 'auto', left: 'auto' });
				}

				el.css(style);
			});
		};

		if (typeof(o.alsoResize) == 'object' && !o.alsoResize.nodeType) {
			$.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
		}else{
			_alsoResize(o.alsoResize);
		}
	},

	stop: function (event, ui) {
		var self = $(this).data("resizable"), o = self.options;

		var _reset = function (exp) {
			$(exp).each(function() {
				var el = $(this);
				// reset position for Opera - no need to verify it was changed
				el.css({ position: el.data("resizable-alsoresize").position });
			});
		};

		if (self._revertToRelativePosition) {
			self._revertToRelativePosition = false;
			if (typeof(o.alsoResize) == 'object' && !o.alsoResize.nodeType) {
				$.each(o.alsoResize, function (exp) { _reset(exp); });
			}else{
				_reset(o.alsoResize);
			}
		}

		$(this).removeData("resizable-alsoresize");
	}
});

$.ui.plugin.add("resizable", "animate", {

	stop: function(event, ui) {
		var self = $(this).data("resizable"), o = self.options;

		var pr = self._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
					soffseth = ista && $.ui.hasScroll(pr[0], 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
						soffsetw = ista ? 0 : self.sizeDiff.width;

		var style = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
					left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
						top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;

		self.element.animate(
			$.extend(style, top && left ? { top: top, left: left } : {}), {
				duration: o.animateDuration,
				easing: o.animateEasing,
				step: function() {

					var data = {
						width: parseInt(self.element.css('width'), 10),
						height: parseInt(self.element.css('height'), 10),
						top: parseInt(self.element.css('top'), 10),
						left: parseInt(self.element.css('left'), 10)
					};

					if (pr && pr.length) $(pr[0]).css({ width: data.width, height: data.height });

					// propagating resize, and updating values for each animation step
					self._updateCache(data);
					self._propagate("resize", event);

				}
			}
		);
	}

});

$.ui.plugin.add("resizable", "containment", {

	start: function(event, ui) {
		var self = $(this).data("resizable"), o = self.options, el = self.element;
		var oc = o.containment,	ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
		if (!ce) return;

		self.containerElement = $(ce);

		if (/document/.test(oc) || oc == document) {
			self.containerOffset = { left: 0, top: 0 };
			self.containerPosition = { left: 0, top: 0 };

			self.parentData = {
				element: $(document), left: 0, top: 0,
				width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
			};
		}

		// i'm a node, so compute top, left, right, bottom
		else {
			var element = $(ce), p = [];
			$([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });

			self.containerOffset = element.offset();
			self.containerPosition = element.position();
			self.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };

			var co = self.containerOffset, ch = self.containerSize.height,	cw = self.containerSize.width,
						width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw ), height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);

			self.parentData = {
				element: ce, left: co.left, top: co.top, width: width, height: height
			};
		}
	},

	resize: function(event, ui) {
		var self = $(this).data("resizable"), o = self.options,
				ps = self.containerSize, co = self.containerOffset, cs = self.size, cp = self.position,
				pRatio = self._aspectRatio || event.shiftKey, cop = { top:0, left:0 }, ce = self.containerElement;

		if (ce[0] != document && (/static/).test(ce.css('position'))) cop = co;

		if (cp.left < (self._helper ? co.left : 0)) {
			self.size.width = self.size.width + (self._helper ? (self.position.left - co.left) : (self.position.left - cop.left));
			if (pRatio) self.size.height = self.size.width / o.aspectRatio;
			self.position.left = o.helper ? co.left : 0;
		}

		if (cp.top < (self._helper ? co.top : 0)) {
			self.size.height = self.size.height + (self._helper ? (self.position.top - co.top) : self.position.top);
			if (pRatio) self.size.width = self.size.height * o.aspectRatio;
			self.position.top = self._helper ? co.top : 0;
		}

		self.offset.left = self.parentData.left+self.position.left;
		self.offset.top = self.parentData.top+self.position.top;

		var woset = Math.abs( (self._helper ? self.offset.left - cop.left : (self.offset.left - cop.left)) + self.sizeDiff.width ),
					hoset = Math.abs( (self._helper ? self.offset.top - cop.top : (self.offset.top - co.top)) + self.sizeDiff.height );

		var isParent = self.containerElement.get(0) == self.element.parent().get(0),
		    isOffsetRelative = /relative|absolute/.test(self.containerElement.css('position'));

		if(isParent && isOffsetRelative) woset -= self.parentData.left;

		if (woset + self.size.width >= self.parentData.width) {
			self.size.width = self.parentData.width - woset;
			if (pRatio) self.size.height = self.size.width / self.aspectRatio;
		}

		if (hoset + self.size.height >= self.parentData.height) {
			self.size.height = self.parentData.height - hoset;
			if (pRatio) self.size.width = self.size.height * self.aspectRatio;
		}
	},

	stop: function(event, ui){
		var self = $(this).data("resizable"), o = self.options, cp = self.position,
				co = self.containerOffset, cop = self.containerPosition, ce = self.containerElement;

		var helper = $(self.helper), ho = helper.offset(), w = helper.outerWidth() - self.sizeDiff.width, h = helper.outerHeight() - self.sizeDiff.height;

		if (self._helper && !o.animate && (/relative/).test(ce.css('position')))
			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });

		if (self._helper && !o.animate && (/static/).test(ce.css('position')))
			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });

	}
});

$.ui.plugin.add("resizable", "ghost", {

	start: function(event, ui) {

		var self = $(this).data("resizable"), o = self.options, cs = self.size;

		self.ghost = self.originalElement.clone();
		self.ghost
			.css({ opacity: .25, display: 'block', position: 'relative', height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
			.addClass('ui-resizable-ghost')
			.addClass(typeof o.ghost == 'string' ? o.ghost : '');

		self.ghost.appendTo(self.helper);

	},

	resize: function(event, ui){
		var self = $(this).data("resizable"), o = self.options;
		if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });
	},

	stop: function(event, ui){
		var self = $(this).data("resizable"), o = self.options;
		if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
	}

});

$.ui.plugin.add("resizable", "grid", {

	resize: function(event, ui) {
		var self = $(this).data("resizable"), o = self.options, cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || event.shiftKey;
		o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
		var ox = Math.round((cs.width - os.width) / (o.grid[0]||1)) * (o.grid[0]||1), oy = Math.round((cs.height - os.height) / (o.grid[1]||1)) * (o.grid[1]||1);

		if (/^(se|s|e)$/.test(a)) {
			self.size.width = os.width + ox;
			self.size.height = os.height + oy;
		}
		else if (/^(ne)$/.test(a)) {
			self.size.width = os.width + ox;
			self.size.height = os.height + oy;
			self.position.top = op.top - oy;
		}
		else if (/^(sw)$/.test(a)) {
			self.size.width = os.width + ox;
			self.size.height = os.height + oy;
			self.position.left = op.left - ox;
		}
		else {
			self.size.width = os.width + ox;
			self.size.height = os.height + oy;
			self.position.top = op.top - oy;
			self.position.left = op.left - ox;
		}
	}

});

var num = function(v) {
	return parseInt(v, 10) || 0;
};

var isNumber = function(value) {
	return !isNaN(parseInt(value, 10));
};

})(jQuery);
/*
 * jQuery UI Selectable 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Selectables
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget("ui.selectable", $.ui.mouse, {
	options: {
		appendTo: 'body',
		autoRefresh: true,
		distance: 0,
		filter: '*',
		tolerance: 'touch'
	},
	_create: function() {
		var self = this;

		this.element.addClass("ui-selectable");

		this.dragged = false;

		// cache selectee children based on filter
		var selectees;
		this.refresh = function() {
			selectees = $(self.options.filter, self.element[0]);
			selectees.each(function() {
				var $this = $(this);
				var pos = $this.offset();
				$.data(this, "selectable-item", {
					element: this,
					$element: $this,
					left: pos.left,
					top: pos.top,
					right: pos.left + $this.outerWidth(),
					bottom: pos.top + $this.outerHeight(),
					startselected: false,
					selected: $this.hasClass('ui-selected'),
					selecting: $this.hasClass('ui-selecting'),
					unselecting: $this.hasClass('ui-unselecting')
				});
			});
		};
		this.refresh();

		this.selectees = selectees.addClass("ui-selectee");

		this._mouseInit();

		this.helper = $("<div class='ui-selectable-helper'></div>");
	},

	destroy: function() {
		this.selectees
			.removeClass("ui-selectee")
			.removeData("selectable-item");
		this.element
			.removeClass("ui-selectable ui-selectable-disabled")
			.removeData("selectable")
			.unbind(".selectable");
		this._mouseDestroy();

		return this;
	},

	_mouseStart: function(event) {
		var self = this;

		this.opos = [event.pageX, event.pageY];

		if (this.options.disabled)
			return;

		var options = this.options;

		this.selectees = $(options.filter, this.element[0]);

		this._trigger("start", event);

		$(options.appendTo).append(this.helper);
		// position helper (lasso)
		this.helper.css({
			"left": event.clientX,
			"top": event.clientY,
			"width": 0,
			"height": 0
		});

		if (options.autoRefresh) {
			this.refresh();
		}

		this.selectees.filter('.ui-selected').each(function() {
			var selectee = $.data(this, "selectable-item");
			selectee.startselected = true;
			if (!event.metaKey) {
				selectee.$element.removeClass('ui-selected');
				selectee.selected = false;
				selectee.$element.addClass('ui-unselecting');
				selectee.unselecting = true;
				// selectable UNSELECTING callback
				self._trigger("unselecting", event, {
					unselecting: selectee.element
				});
			}
		});

		$(event.target).parents().andSelf().each(function() {
			var selectee = $.data(this, "selectable-item");
			if (selectee) {
				var doSelect = !event.metaKey || !selectee.$element.hasClass('ui-selected');
				selectee.$element
					.removeClass(doSelect ? "ui-unselecting" : "ui-selected")
					.addClass(doSelect ? "ui-selecting" : "ui-unselecting");
				selectee.unselecting = !doSelect;
				selectee.selecting = doSelect;
				selectee.selected = doSelect;
				// selectable (UN)SELECTING callback
				if (doSelect) {
					self._trigger("selecting", event, {
						selecting: selectee.element
					});
				} else {
					self._trigger("unselecting", event, {
						unselecting: selectee.element
					});
				}
				return false;
			}
		});

	},

	_mouseDrag: function(event) {
		var self = this;
		this.dragged = true;

		if (this.options.disabled)
			return;

		var options = this.options;

		var x1 = this.opos[0], y1 = this.opos[1], x2 = event.pageX, y2 = event.pageY;
		if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
		if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
		this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});

		this.selectees.each(function() {
			var selectee = $.data(this, "selectable-item");
			//prevent helper from being selected if appendTo: selectable
			if (!selectee || selectee.element == self.element[0])
				return;
			var hit = false;
			if (options.tolerance == 'touch') {
				hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
			} else if (options.tolerance == 'fit') {
				hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
			}

			if (hit) {
				// SELECT
				if (selectee.selected) {
					selectee.$element.removeClass('ui-selected');
					selectee.selected = false;
				}
				if (selectee.unselecting) {
					selectee.$element.removeClass('ui-unselecting');
					selectee.unselecting = false;
				}
				if (!selectee.selecting) {
					selectee.$element.addClass('ui-selecting');
					selectee.selecting = true;
					// selectable SELECTING callback
					self._trigger("selecting", event, {
						selecting: selectee.element
					});
				}
			} else {
				// UNSELECT
				if (selectee.selecting) {
					if (event.metaKey && selectee.startselected) {
						selectee.$element.removeClass('ui-selecting');
						selectee.selecting = false;
						selectee.$element.addClass('ui-selected');
						selectee.selected = true;
					} else {
						selectee.$element.removeClass('ui-selecting');
						selectee.selecting = false;
						if (selectee.startselected) {
							selectee.$element.addClass('ui-unselecting');
							selectee.unselecting = true;
						}
						// selectable UNSELECTING callback
						self._trigger("unselecting", event, {
							unselecting: selectee.element
						});
					}
				}
				if (selectee.selected) {
					if (!event.metaKey && !selectee.startselected) {
						selectee.$element.removeClass('ui-selected');
						selectee.selected = false;

						selectee.$element.addClass('ui-unselecting');
						selectee.unselecting = true;
						// selectable UNSELECTING callback
						self._trigger("unselecting", event, {
							unselecting: selectee.element
						});
					}
				}
			}
		});

		return false;
	},

	_mouseStop: function(event) {
		var self = this;

		this.dragged = false;

		var options = this.options;

		$('.ui-unselecting', this.element[0]).each(function() {
			var selectee = $.data(this, "selectable-item");
			selectee.$element.removeClass('ui-unselecting');
			selectee.unselecting = false;
			selectee.startselected = false;
			self._trigger("unselected", event, {
				unselected: selectee.element
			});
		});
		$('.ui-selecting', this.element[0]).each(function() {
			var selectee = $.data(this, "selectable-item");
			selectee.$element.removeClass('ui-selecting').addClass('ui-selected');
			selectee.selecting = false;
			selectee.selected = true;
			selectee.startselected = true;
			self._trigger("selected", event, {
				selected: selectee.element
			});
		});
		this._trigger("stop", event);

		this.helper.remove();

		return false;
	}

});

$.extend($.ui.selectable, {
	version: "1.8.11"
});

})(jQuery);
/*
 * jQuery UI Sortable 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Sortables
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget("ui.sortable", $.ui.mouse, {
	widgetEventPrefix: "sort",
	options: {
		appendTo: "parent",
		axis: false,
		connectWith: false,
		containment: false,
		cursor: 'auto',
		cursorAt: false,
		dropOnEmpty: true,
		forcePlaceholderSize: false,
		forceHelperSize: false,
		grid: false,
		handle: false,
		helper: "original",
		items: '> *',
		opacity: false,
		placeholder: false,
		revert: false,
		scroll: true,
		scrollSensitivity: 20,
		scrollSpeed: 20,
		scope: "default",
		tolerance: "intersect",
		zIndex: 1000
	},
	_create: function() {

		var o = this.options;
		this.containerCache = {};
		this.element.addClass("ui-sortable");

		//Get the items
		this.refresh();

		//Let's determine if the items are being displayed horizontally
		this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) || (/inline|table-cell/).test(this.items[0].item.css('display')) : false;

		//Let's determine the parent's offset
		this.offset = this.element.offset();

		//Initialize mouse events for interaction
		this._mouseInit();

	},

	destroy: function() {
		this.element
			.removeClass("ui-sortable ui-sortable-disabled")
			.removeData("sortable")
			.unbind(".sortable");
		this._mouseDestroy();

		for ( var i = this.items.length - 1; i >= 0; i-- )
			this.items[i].item.removeData("sortable-item");

		return this;
	},

	_setOption: function(key, value){
		if ( key === "disabled" ) {
			this.options[ key ] = value;
	
			this.widget()
				[ value ? "addClass" : "removeClass"]( "ui-sortable-disabled" );
		} else {
			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
			$.Widget.prototype._setOption.apply(this, arguments);
		}
	},

	_mouseCapture: function(event, overrideHandle) {

		if (this.reverting) {
			return false;
		}

		if(this.options.disabled || this.options.type == 'static') return false;

		//We have to refresh the items data once first
		this._refreshItems(event);

		//Find out if the clicked node (or one of its parents) is a actual item in this.items
		var currentItem = null, self = this, nodes = $(event.target).parents().each(function() {
			if($.data(this, 'sortable-item') == self) {
				currentItem = $(this);
				return false;
			}
		});
		if($.data(event.target, 'sortable-item') == self) currentItem = $(event.target);

		if(!currentItem) return false;
		if(this.options.handle && !overrideHandle) {
			var validHandle = false;

			$(this.options.handle, currentItem).find("*").andSelf().each(function() { if(this == event.target) validHandle = true; });
			if(!validHandle) return false;
		}

		this.currentItem = currentItem;
		this._removeCurrentsFromItems();
		return true;

	},

	_mouseStart: function(event, overrideHandle, noActivation) {

		var o = this.options, self = this;
		this.currentContainer = this;

		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
		this.refreshPositions();

		//Create and append the visible helper
		this.helper = this._createHelper(event);

		//Cache the helper size
		this._cacheHelperProportions();

		/*
		 * - Position generation -
		 * This block generates everything position related - it's the core of draggables.
		 */

		//Cache the margins of the original element
		this._cacheMargins();

		//Get the next scrolling parent
		this.scrollParent = this.helper.scrollParent();

		//The element's absolute position on the page minus margins
		this.offset = this.currentItem.offset();
		this.offset = {
			top: this.offset.top - this.margins.top,
			left: this.offset.left - this.margins.left
		};

		// Only after we got the offset, we can change the helper's position to absolute
		// TODO: Still need to figure out a way to make relative sorting possible
		this.helper.css("position", "absolute");
		this.cssPosition = this.helper.css("position");

		$.extend(this.offset, {
			click: { //Where the click happened, relative to the element
				left: event.pageX - this.offset.left,
				top: event.pageY - this.offset.top
			},
			parent: this._getParentOffset(),
			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
		});

		//Generate the original position
		this.originalPosition = this._generatePosition(event);
		this.originalPageX = event.pageX;
		this.originalPageY = event.pageY;

		//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));

		//Cache the former DOM position
		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };

		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
		if(this.helper[0] != this.currentItem[0]) {
			this.currentItem.hide();
		}

		//Create the placeholder
		this._createPlaceholder();

		//Set a containment if given in the options
		if(o.containment)
			this._setContainment();

		if(o.cursor) { // cursor option
			if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor");
			$('body').css("cursor", o.cursor);
		}

		if(o.opacity) { // opacity option
			if (this.helper.css("opacity")) this._storedOpacity = this.helper.css("opacity");
			this.helper.css("opacity", o.opacity);
		}

		if(o.zIndex) { // zIndex option
			if (this.helper.css("zIndex")) this._storedZIndex = this.helper.css("zIndex");
			this.helper.css("zIndex", o.zIndex);
		}

		//Prepare scrolling
		if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML')
			this.overflowOffset = this.scrollParent.offset();

		//Call callbacks
		this._trigger("start", event, this._uiHash());

		//Recache the helper size
		if(!this._preserveHelperProportions)
			this._cacheHelperProportions();


		//Post 'activate' events to possible containers
		if(!noActivation) {
			 for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._trigger("activate", event, self._uiHash(this)); }
		}

		//Prepare possible droppables
		if($.ui.ddmanager)
			$.ui.ddmanager.current = this;

		if ($.ui.ddmanager && !o.dropBehaviour)
			$.ui.ddmanager.prepareOffsets(this, event);

		this.dragging = true;

		this.helper.addClass("ui-sortable-helper");
		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
		return true;

	},

	_mouseDrag: function(event) {

		//Compute the helpers position
		this.position = this._generatePosition(event);
		this.positionAbs = this._convertPositionTo("absolute");

		if (!this.lastPositionAbs) {
			this.lastPositionAbs = this.positionAbs;
		}

		//Do scrolling
		if(this.options.scroll) {
			var o = this.options, scrolled = false;
			if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') {

				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
				else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity)
					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;

				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
				else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity)
					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;

			} else {

				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
				else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);

				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
				else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);

			}

			if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
				$.ui.ddmanager.prepareOffsets(this, event);
		}

		//Regenerate the absolute position used for position checks
		this.positionAbs = this._convertPositionTo("absolute");

		//Set the helper position
		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';

		//Rearrange
		for (var i = this.items.length - 1; i >= 0; i--) {

			//Cache variables and intersection, continue if no intersection
			var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);
			if (!intersection) continue;

			if(itemElement != this.currentItem[0] //cannot intersect with itself
				&&	this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
				&&	!$.ui.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
				&& (this.options.type == 'semi-dynamic' ? !$.ui.contains(this.element[0], itemElement) : true)
				//&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container
			) {

				this.direction = intersection == 1 ? "down" : "up";

				if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
					this._rearrange(event, item);
				} else {
					break;
				}

				this._trigger("change", event, this._uiHash());
				break;
			}
		}

		//Post events to containers
		this._contactContainers(event);

		//Interconnect with droppables
		if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);

		//Call callbacks
		this._trigger('sort', event, this._uiHash());

		this.lastPositionAbs = this.positionAbs;
		return false;

	},

	_mouseStop: function(event, noPropagation) {

		if(!event) return;

		//If we are using droppables, inform the manager about the drop
		if ($.ui.ddmanager && !this.options.dropBehaviour)
			$.ui.ddmanager.drop(this, event);

		if(this.options.revert) {
			var self = this;
			var cur = self.placeholder.offset();

			self.reverting = true;

			$(this.helper).animate({
				left: cur.left - this.offset.parent.left - self.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),
				top: cur.top - this.offset.parent.top - self.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)
			}, parseInt(this.options.revert, 10) || 500, function() {
				self._clear(event);
			});
		} else {
			this._clear(event, noPropagation);
		}

		return false;

	},

	cancel: function() {

		var self = this;

		if(this.dragging) {

			this._mouseUp({ target: null });

			if(this.options.helper == "original")
				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
			else
				this.currentItem.show();

			//Post deactivating events to containers
			for (var i = this.containers.length - 1; i >= 0; i--){
				this.containers[i]._trigger("deactivate", null, self._uiHash(this));
				if(this.containers[i].containerCache.over) {
					this.containers[i]._trigger("out", null, self._uiHash(this));
					this.containers[i].containerCache.over = 0;
				}
			}

		}

		if (this.placeholder) {
			//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
			if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
			if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();

			$.extend(this, {
				helper: null,
				dragging: false,
				reverting: false,
				_noFinalSort: null
			});

			if(this.domPosition.prev) {
				$(this.domPosition.prev).after(this.currentItem);
			} else {
				$(this.domPosition.parent).prepend(this.currentItem);
			}
		}

		return this;

	},

	serialize: function(o) {

		var items = this._getItemsAsjQuery(o && o.connected);
		var str = []; o = o || {};

		$(items).each(function() {
			var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
			if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2]));
		});

		if(!str.length && o.key) {
			str.push(o.key + '=');
		}

		return str.join('&');

	},

	toArray: function(o) {

		var items = this._getItemsAsjQuery(o && o.connected);
		var ret = []; o = o || {};

		items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); });
		return ret;

	},

	/* Be careful with the following core functions */
	_intersectsWith: function(item) {

		var x1 = this.positionAbs.left,
			x2 = x1 + this.helperProportions.width,
			y1 = this.positionAbs.top,
			y2 = y1 + this.helperProportions.height;

		var l = item.left,
			r = l + item.width,
			t = item.top,
			b = t + item.height;

		var dyClick = this.offset.click.top,
			dxClick = this.offset.click.left;

		var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;

		if(	   this.options.tolerance == "pointer"
			|| this.options.forcePointerForContainers
			|| (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height'])
		) {
			return isOverElement;
		} else {

			return (l < x1 + (this.helperProportions.width / 2) // Right Half
				&& x2 - (this.helperProportions.width / 2) < r // Left Half
				&& t < y1 + (this.helperProportions.height / 2) // Bottom Half
				&& y2 - (this.helperProportions.height / 2) < b ); // Top Half

		}
	},

	_intersectsWithPointer: function(item) {

		var isOverElementHeight = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
			isOverElementWidth = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
			isOverElement = isOverElementHeight && isOverElementWidth,
			verticalDirection = this._getDragVerticalDirection(),
			horizontalDirection = this._getDragHorizontalDirection();

		if (!isOverElement)
			return false;

		return this.floating ?
			( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 )
			: ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );

	},

	_intersectsWithSides: function(item) {

		var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
			isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
			verticalDirection = this._getDragVerticalDirection(),
			horizontalDirection = this._getDragHorizontalDirection();

		if (this.floating && horizontalDirection) {
			return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf));
		} else {
			return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf));
		}

	},

	_getDragVerticalDirection: function() {
		var delta = this.positionAbs.top - this.lastPositionAbs.top;
		return delta != 0 && (delta > 0 ? "down" : "up");
	},

	_getDragHorizontalDirection: function() {
		var delta = this.positionAbs.left - this.lastPositionAbs.left;
		return delta != 0 && (delta > 0 ? "right" : "left");
	},

	refresh: function(event) {
		this._refreshItems(event);
		this.refreshPositions();
		return this;
	},

	_connectWith: function() {
		var options = this.options;
		return options.connectWith.constructor == String
			? [options.connectWith]
			: options.connectWith;
	},
	
	_getItemsAsjQuery: function(connected) {

		var self = this;
		var items = [];
		var queries = [];
		var connectWith = this._connectWith();

		if(connectWith && connected) {
			for (var i = connectWith.length - 1; i >= 0; i--){
				var cur = $(connectWith[i]);
				for (var j = cur.length - 1; j >= 0; j--){
					var inst = $.data(cur[j], 'sortable');
					if(inst && inst != this && !inst.options.disabled) {
						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not('.ui-sortable-placeholder'), inst]);
					}
				};
			};
		}

		queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not('.ui-sortable-placeholder'), this]);

		for (var i = queries.length - 1; i >= 0; i--){
			queries[i][0].each(function() {
				items.push(this);
			});
		};

		return $(items);

	},

	_removeCurrentsFromItems: function() {

		var list = this.currentItem.find(":data(sortable-item)");

		for (var i=0; i < this.items.length; i++) {

			for (var j=0; j < list.length; j++) {
				if(list[j] == this.items[i].item[0])
					this.items.splice(i,1);
			};

		};

	},

	_refreshItems: function(event) {

		this.items = [];
		this.containers = [this];
		var items = this.items;
		var self = this;
		var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]];
		var connectWith = this._connectWith();

		if(connectWith) {
			for (var i = connectWith.length - 1; i >= 0; i--){
				var cur = $(connectWith[i]);
				for (var j = cur.length - 1; j >= 0; j--){
					var inst = $.data(cur[j], 'sortable');
					if(inst && inst != this && !inst.options.disabled) {
						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
						this.containers.push(inst);
					}
				};
			};
		}

		for (var i = queries.length - 1; i >= 0; i--) {
			var targetData = queries[i][1];
			var _queries = queries[i][0];

			for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) {
				var item = $(_queries[j]);

				item.data('sortable-item', targetData); // Data for target checking (mouse manager)

				items.push({
					item: item,
					instance: targetData,
					width: 0, height: 0,
					left: 0, top: 0
				});
			};
		};

	},

	refreshPositions: function(fast) {

		//This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
		if(this.offsetParent && this.helper) {
			this.offset.parent = this._getParentOffset();
		}

		for (var i = this.items.length - 1; i >= 0; i--){
			var item = this.items[i];

			var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;

			if (!fast) {
				item.width = t.outerWidth();
				item.height = t.outerHeight();
			}

			var p = t.offset();
			item.left = p.left;
			item.top = p.top;
		};

		if(this.options.custom && this.options.custom.refreshContainers) {
			this.options.custom.refreshContainers.call(this);
		} else {
			for (var i = this.containers.length - 1; i >= 0; i--){
				var p = this.containers[i].element.offset();
				this.containers[i].containerCache.left = p.left;
				this.containers[i].containerCache.top = p.top;
				this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
				this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
			};
		}

		return this;
	},

	_createPlaceholder: function(that) {

		var self = that || this, o = self.options;

		if(!o.placeholder || o.placeholder.constructor == String) {
			var className = o.placeholder;
			o.placeholder = {
				element: function() {

					var el = $(document.createElement(self.currentItem[0].nodeName))
						.addClass(className || self.currentItem[0].className+" ui-sortable-placeholder")
						.removeClass("ui-sortable-helper")[0];

					if(!className)
						el.style.visibility = "hidden";

					return el;
				},
				update: function(container, p) {

					// 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
					// 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
					if(className && !o.forcePlaceholderSize) return;

					//If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
					if(!p.height()) { p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10)); };
					if(!p.width()) { p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10)); };
				}
			};
		}

		//Create the placeholder
		self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem));

		//Append it after the actual current item
		self.currentItem.after(self.placeholder);

		//Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
		o.placeholder.update(self, self.placeholder);

	},

	_contactContainers: function(event) {
		
		// get innermost container that intersects with item 
		var innermostContainer = null, innermostIndex = null;		
		
		
		for (var i = this.containers.length - 1; i >= 0; i--){

			// never consider a container that's located within the item itself 
			if($.ui.contains(this.currentItem[0], this.containers[i].element[0]))
				continue;

			if(this._intersectsWith(this.containers[i].containerCache)) {

				// if we've already found a container and it's more "inner" than this, then continue 
				if(innermostContainer && $.ui.contains(this.containers[i].element[0], innermostContainer.element[0]))
					continue;

				innermostContainer = this.containers[i]; 
				innermostIndex = i;
					
			} else {
				// container doesn't intersect. trigger "out" event if necessary 
				if(this.containers[i].containerCache.over) {
					this.containers[i]._trigger("out", event, this._uiHash(this));
					this.containers[i].containerCache.over = 0;
				}
			}

		}
		
		// if no intersecting containers found, return 
		if(!innermostContainer) return; 

		// move the item into the container if it's not there already
		if(this.containers.length === 1) {
			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
			this.containers[innermostIndex].containerCache.over = 1;
		} else if(this.currentContainer != this.containers[innermostIndex]) { 

			//When entering a new container, we will find the item with the least distance and append our item near it 
			var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[innermostIndex].floating ? 'left' : 'top']; 
			for (var j = this.items.length - 1; j >= 0; j--) { 
				if(!$.ui.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue; 
				var cur = this.items[j][this.containers[innermostIndex].floating ? 'left' : 'top']; 
				if(Math.abs(cur - base) < dist) { 
					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j]; 
				} 
			} 

			if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled 
				return; 

			this.currentContainer = this.containers[innermostIndex]; 
			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true); 
			this._trigger("change", event, this._uiHash()); 
			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this)); 

			//Update the placeholder 
			this.options.placeholder.update(this.currentContainer, this.placeholder); 
		
			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); 
			this.containers[innermostIndex].containerCache.over = 1;
		} 
	
		
	},

	_createHelper: function(event) {

		var o = this.options;
		var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper == 'clone' ? this.currentItem.clone() : this.currentItem);

		if(!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already
			$(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);

		if(helper[0] == this.currentItem[0])
			this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };

		if(helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width());
		if(helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height());

		return helper;

	},

	_adjustOffsetFromHelper: function(obj) {
		if (typeof obj == 'string') {
			obj = obj.split(' ');
		}
		if ($.isArray(obj)) {
			obj = {left: +obj[0], top: +obj[1] || 0};
		}
		if ('left' in obj) {
			this.offset.click.left = obj.left + this.margins.left;
		}
		if ('right' in obj) {
			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
		}
		if ('top' in obj) {
			this.offset.click.top = obj.top + this.margins.top;
		}
		if ('bottom' in obj) {
			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
		}
	},

	_getParentOffset: function() {


		//Get the offsetParent and cache its position
		this.offsetParent = this.helper.offsetParent();
		var po = this.offsetParent.offset();

		// This is a special case where we need to modify a offset calculated on start, since the following happened:
		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
		if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
			po.left += this.scrollParent.scrollLeft();
			po.top += this.scrollParent.scrollTop();
		}

		if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
			po = { top: 0, left: 0 };

		return {
			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
		};

	},

	_getRelativeOffset: function() {

		if(this.cssPosition == "relative") {
			var p = this.currentItem.position();
			return {
				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
			};
		} else {
			return { top: 0, left: 0 };
		}

	},

	_cacheMargins: function() {
		this.margins = {
			left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
			top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
		};
	},

	_cacheHelperProportions: function() {
		this.helperProportions = {
			width: this.helper.outerWidth(),
			height: this.helper.outerHeight()
		};
	},

	_setContainment: function() {

		var o = this.options;
		if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
		if(o.containment == 'document' || o.containment == 'window') this.containment = [
			0 - this.offset.relative.left - this.offset.parent.left,
			0 - this.offset.relative.top - this.offset.parent.top,
			$(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
			($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
		];

		if(!(/^(document|window|parent)$/).test(o.containment)) {
			var ce = $(o.containment)[0];
			var co = $(o.containment).offset();
			var over = ($(ce).css("overflow") != 'hidden');

			this.containment = [
				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
			];
		}

	},

	_convertPositionTo: function(d, pos) {

		if(!pos) pos = this.position;
		var mod = d == "absolute" ? 1 : -1;
		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

		return {
			top: (
				pos.top																	// The absolute mouse position
				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
				- ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
			),
			left: (
				pos.left																// The absolute mouse position
				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
				- ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
			)
		};

	},

	_generatePosition: function(event) {

		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

		// This is another very weird special case that only happens for relative elements:
		// 1. If the css position is relative
		// 2. and the scroll parent is the document or similar to the offset parent
		// we have to refresh the relative offset during the scroll so there are no jumps
		if(this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) {
			this.offset.relative = this._getRelativeOffset();
		}

		var pageX = event.pageX;
		var pageY = event.pageY;

		/*
		 * - Position constraining -
		 * Constrain the position to a mix of grid, containment.
		 */

		if(this.originalPosition) { //If we are not dragging yet, we won't check for options

			if(this.containment) {
				if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
				if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
				if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
				if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
			}

			if(o.grid) {
				var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
				pageY = this.containment ? (!(top - this.offset.click.top < this.containment[1] || top - this.offset.click.top > this.containment[3]) ? top : (!(top - this.offset.click.top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;

				var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
				pageX = this.containment ? (!(left - this.offset.click.left < this.containment[0] || left - this.offset.click.left > this.containment[2]) ? left : (!(left - this.offset.click.left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
			}

		}

		return {
			top: (
				pageY																// The absolute mouse position
				- this.offset.click.top													// Click offset (relative to the element)
				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
				+ ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
			),
			left: (
				pageX																// The absolute mouse position
				- this.offset.click.left												// Click offset (relative to the element)
				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
				+ ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
			)
		};

	},

	_rearrange: function(event, i, a, hardRefresh) {

		a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction == 'down' ? i.item[0] : i.item[0].nextSibling));

		//Various things done here to improve the performance:
		// 1. we create a setTimeout, that calls refreshPositions
		// 2. on the instance, we have a counter variable, that get's higher after every append
		// 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
		// 4. this lets only the last addition to the timeout stack through
		this.counter = this.counter ? ++this.counter : 1;
		var self = this, counter = this.counter;

		window.setTimeout(function() {
			if(counter == self.counter) self.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
		},0);

	},

	_clear: function(event, noPropagation) {

		this.reverting = false;
		// We delay all events that have to be triggered to after the point where the placeholder has been removed and
		// everything else normalized again
		var delayedTriggers = [], self = this;

		// We first have to update the dom position of the actual currentItem
		// Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
		if(!this._noFinalSort && this.currentItem[0].parentNode) this.placeholder.before(this.currentItem);
		this._noFinalSort = null;

		if(this.helper[0] == this.currentItem[0]) {
			for(var i in this._storedCSS) {
				if(this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = '';
			}
			this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
		} else {
			this.currentItem.show();
		}

		if(this.fromOutside && !noPropagation) delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
		if((this.fromOutside || this.domPosition.prev != this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent != this.currentItem.parent()[0]) && !noPropagation) delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
		if(!$.ui.contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
			if(!noPropagation) delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
			for (var i = this.containers.length - 1; i >= 0; i--){
				if($.ui.contains(this.containers[i].element[0], this.currentItem[0]) && !noPropagation) {
					delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
					delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.containers[i]));
				}
			};
		};

		//Post events to containers
		for (var i = this.containers.length - 1; i >= 0; i--){
			if(!noPropagation) delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
			if(this.containers[i].containerCache.over) {
				delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
				this.containers[i].containerCache.over = 0;
			}
		}

		//Do what was originally in plugins
		if(this._storedCursor) $('body').css("cursor", this._storedCursor); //Reset cursor
		if(this._storedOpacity) this.helper.css("opacity", this._storedOpacity); //Reset opacity
		if(this._storedZIndex) this.helper.css("zIndex", this._storedZIndex == 'auto' ? '' : this._storedZIndex); //Reset z-index

		this.dragging = false;
		if(this.cancelHelperRemoval) {
			if(!noPropagation) {
				this._trigger("beforeStop", event, this._uiHash());
				for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
				this._trigger("stop", event, this._uiHash());
			}
			return false;
		}

		if(!noPropagation) this._trigger("beforeStop", event, this._uiHash());

		//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
		this.placeholder[0].parentNode.removeChild(this.placeholder[0]);

		if(this.helper[0] != this.currentItem[0]) this.helper.remove(); this.helper = null;

		if(!noPropagation) {
			for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
			this._trigger("stop", event, this._uiHash());
		}

		this.fromOutside = false;
		return true;

	},

	_trigger: function() {
		if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
			this.cancel();
		}
	},

	_uiHash: function(inst) {
		var self = inst || this;
		return {
			helper: self.helper,
			placeholder: self.placeholder || $([]),
			position: self.position,
			originalPosition: self.originalPosition,
			offset: self.positionAbs,
			item: self.currentItem,
			sender: inst ? inst.element : null
		};
	}

});

$.extend($.ui.sortable, {
	version: "1.8.11"
});

})(jQuery);
/*
 * jQuery UI Accordion 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Accordion
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget( "ui.accordion", {
	options: {
		active: 0,
		animated: "slide",
		autoHeight: true,
		clearStyle: false,
		collapsible: false,
		event: "click",
		fillSpace: false,
		header: "> li > :first-child,> :not(li):even",
		icons: {
			header: "ui-icon-triangle-1-e",
			headerSelected: "ui-icon-triangle-1-s"
		},
		navigation: false,
		navigationFilter: function() {
			return this.href.toLowerCase() === location.href.toLowerCase();
		}
	},

	_create: function() {
		var self = this,
			options = self.options;

		self.running = 0;

		self.element
			.addClass( "ui-accordion ui-widget ui-helper-reset" )
			// in lack of child-selectors in CSS
			// we need to mark top-LIs in a UL-accordion for some IE-fix
			.children( "li" )
				.addClass( "ui-accordion-li-fix" );

		self.headers = self.element.find( options.header )
			.addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" )
			.bind( "mouseenter.accordion", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).addClass( "ui-state-hover" );
			})
			.bind( "mouseleave.accordion", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).removeClass( "ui-state-hover" );
			})
			.bind( "focus.accordion", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).addClass( "ui-state-focus" );
			})
			.bind( "blur.accordion", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).removeClass( "ui-state-focus" );
			});

		self.headers.next()
			.addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" );

		if ( options.navigation ) {
			var current = self.element.find( "a" ).filter( options.navigationFilter ).eq( 0 );
			if ( current.length ) {
				var header = current.closest( ".ui-accordion-header" );
				if ( header.length ) {
					// anchor within header
					self.active = header;
				} else {
					// anchor within content
					self.active = current.closest( ".ui-accordion-content" ).prev();
				}
			}
		}

		self.active = self._findActive( self.active || options.active )
			.addClass( "ui-state-default ui-state-active" )
			.toggleClass( "ui-corner-all" )
			.toggleClass( "ui-corner-top" );
		self.active.next().addClass( "ui-accordion-content-active" );

		self._createIcons();
		self.resize();
		
		// ARIA
		self.element.attr( "role", "tablist" );

		self.headers
			.attr( "role", "tab" )
			.bind( "keydown.accordion", function( event ) {
				return self._keydown( event );
			})
			.next()
				.attr( "role", "tabpanel" );

		self.headers
			.not( self.active || "" )
			.attr({
				"aria-expanded": "false",
				"aria-selected": "false",
				tabIndex: -1
			})
			.next()
				.hide();

		// make sure at least one header is in the tab order
		if ( !self.active.length ) {
			self.headers.eq( 0 ).attr( "tabIndex", 0 );
		} else {
			self.active
				.attr({
					"aria-expanded": "true",
					"aria-selected": "true",
					tabIndex: 0
				});
		}

		// only need links in tab order for Safari
		if ( !$.browser.safari ) {
			self.headers.find( "a" ).attr( "tabIndex", -1 );
		}

		if ( options.event ) {
			self.headers.bind( options.event.split(" ").join(".accordion ") + ".accordion", function(event) {
				self._clickHandler.call( self, event, this );
				event.preventDefault();
			});
		}
	},

	_createIcons: function() {
		var options = this.options;
		if ( options.icons ) {
			$( "<span></span>" )
				.addClass( "ui-icon " + options.icons.header )
				.prependTo( this.headers );
			this.active.children( ".ui-icon" )
				.toggleClass(options.icons.header)
				.toggleClass(options.icons.headerSelected);
			this.element.addClass( "ui-accordion-icons" );
		}
	},

	_destroyIcons: function() {
		this.headers.children( ".ui-icon" ).remove();
		this.element.removeClass( "ui-accordion-icons" );
	},

	destroy: function() {
		var options = this.options;

		this.element
			.removeClass( "ui-accordion ui-widget ui-helper-reset" )
			.removeAttr( "role" );

		this.headers
			.unbind( ".accordion" )
			.removeClass( "ui-accordion-header ui-accordion-disabled ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
			.removeAttr( "role" )
			.removeAttr( "aria-expanded" )
			.removeAttr( "aria-selected" )
			.removeAttr( "tabIndex" );

		this.headers.find( "a" ).removeAttr( "tabIndex" );
		this._destroyIcons();
		var contents = this.headers.next()
			.css( "display", "" )
			.removeAttr( "role" )
			.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-accordion-disabled ui-state-disabled" );
		if ( options.autoHeight || options.fillHeight ) {
			contents.css( "height", "" );
		}

		return $.Widget.prototype.destroy.call( this );
	},

	_setOption: function( key, value ) {
		$.Widget.prototype._setOption.apply( this, arguments );
			
		if ( key == "active" ) {
			this.activate( value );
		}
		if ( key == "icons" ) {
			this._destroyIcons();
			if ( value ) {
				this._createIcons();
			}
		}
		// #5332 - opacity doesn't cascade to positioned elements in IE
		// so we need to add the disabled class to the headers and panels
		if ( key == "disabled" ) {
			this.headers.add(this.headers.next())
				[ value ? "addClass" : "removeClass" ](
					"ui-accordion-disabled ui-state-disabled" );
		}
	},

	_keydown: function( event ) {
		if ( this.options.disabled || event.altKey || event.ctrlKey ) {
			return;
		}

		var keyCode = $.ui.keyCode,
			length = this.headers.length,
			currentIndex = this.headers.index( event.target ),
			toFocus = false;

		switch ( event.keyCode ) {
			case keyCode.RIGHT:
			case keyCode.DOWN:
				toFocus = this.headers[ ( currentIndex + 1 ) % length ];
				break;
			case keyCode.LEFT:
			case keyCode.UP:
				toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
				break;
			case keyCode.SPACE:
			case keyCode.ENTER:
				this._clickHandler( { target: event.target }, event.target );
				event.preventDefault();
		}

		if ( toFocus ) {
			$( event.target ).attr( "tabIndex", -1 );
			$( toFocus ).attr( "tabIndex", 0 );
			toFocus.focus();
			return false;
		}

		return true;
	},

	resize: function() {
		var options = this.options,
			maxHeight;

		if ( options.fillSpace ) {
			if ( $.browser.msie ) {
				var defOverflow = this.element.parent().css( "overflow" );
				this.element.parent().css( "overflow", "hidden");
			}
			maxHeight = this.element.parent().height();
			if ($.browser.msie) {
				this.element.parent().css( "overflow", defOverflow );
			}

			this.headers.each(function() {
				maxHeight -= $( this ).outerHeight( true );
			});

			this.headers.next()
				.each(function() {
					$( this ).height( Math.max( 0, maxHeight -
						$( this ).innerHeight() + $( this ).height() ) );
				})
				.css( "overflow", "auto" );
		} else if ( options.autoHeight ) {
			maxHeight = 0;
			this.headers.next()
				.each(function() {
					maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
				})
				.height( maxHeight );
		}

		return this;
	},

	activate: function( index ) {
		// TODO this gets called on init, changing the option without an explicit call for that
		this.options.active = index;
		// call clickHandler with custom event
		var active = this._findActive( index )[ 0 ];
		this._clickHandler( { target: active }, active );

		return this;
	},

	_findActive: function( selector ) {
		return selector
			? typeof selector === "number"
				? this.headers.filter( ":eq(" + selector + ")" )
				: this.headers.not( this.headers.not( selector ) )
			: selector === false
				? $( [] )
				: this.headers.filter( ":eq(0)" );
	},

	// TODO isn't event.target enough? why the separate target argument?
	_clickHandler: function( event, target ) {
		var options = this.options;
		if ( options.disabled ) {
			return;
		}

		// called only when using activate(false) to close all parts programmatically
		if ( !event.target ) {
			if ( !options.collapsible ) {
				return;
			}
			this.active
				.removeClass( "ui-state-active ui-corner-top" )
				.addClass( "ui-state-default ui-corner-all" )
				.children( ".ui-icon" )
					.removeClass( options.icons.headerSelected )
					.addClass( options.icons.header );
			this.active.next().addClass( "ui-accordion-content-active" );
			var toHide = this.active.next(),
				data = {
					options: options,
					newHeader: $( [] ),
					oldHeader: options.active,
					newContent: $( [] ),
					oldContent: toHide
				},
				toShow = ( this.active = $( [] ) );
			this._toggle( toShow, toHide, data );
			return;
		}

		// get the click target
		var clicked = $( event.currentTarget || target ),
			clickedIsActive = clicked[0] === this.active[0];

		// TODO the option is changed, is that correct?
		// TODO if it is correct, shouldn't that happen after determining that the click is valid?
		options.active = options.collapsible && clickedIsActive ?
			false :
			this.headers.index( clicked );

		// if animations are still active, or the active header is the target, ignore click
		if ( this.running || ( !options.collapsible && clickedIsActive ) ) {
			return;
		}

		// find elements to show and hide
		var active = this.active,
			toShow = clicked.next(),
			toHide = this.active.next(),
			data = {
				options: options,
				newHeader: clickedIsActive && options.collapsible ? $([]) : clicked,
				oldHeader: this.active,
				newContent: clickedIsActive && options.collapsible ? $([]) : toShow,
				oldContent: toHide
			},
			down = this.headers.index( this.active[0] ) > this.headers.index( clicked[0] );

		// when the call to ._toggle() comes after the class changes
		// it causes a very odd bug in IE 8 (see #6720)
		this.active = clickedIsActive ? $([]) : clicked;
		this._toggle( toShow, toHide, data, clickedIsActive, down );

		// switch classes
		active
			.removeClass( "ui-state-active ui-corner-top" )
			.addClass( "ui-state-default ui-corner-all" )
			.children( ".ui-icon" )
				.removeClass( options.icons.headerSelected )
				.addClass( options.icons.header );
		if ( !clickedIsActive ) {
			clicked
				.removeClass( "ui-state-default ui-corner-all" )
				.addClass( "ui-state-active ui-corner-top" )
				.children( ".ui-icon" )
					.removeClass( options.icons.header )
					.addClass( options.icons.headerSelected );
			clicked
				.next()
				.addClass( "ui-accordion-content-active" );
		}

		return;
	},

	_toggle: function( toShow, toHide, data, clickedIsActive, down ) {
		var self = this,
			options = self.options;

		self.toShow = toShow;
		self.toHide = toHide;
		self.data = data;

		var complete = function() {
			if ( !self ) {
				return;
			}
			return self._completed.apply( self, arguments );
		};

		// trigger changestart event
		self._trigger( "changestart", null, self.data );

		// count elements to animate
		self.running = toHide.size() === 0 ? toShow.size() : toHide.size();

		if ( options.animated ) {
			var animOptions = {};

			if ( options.collapsible && clickedIsActive ) {
				animOptions = {
					toShow: $( [] ),
					toHide: toHide,
					complete: complete,
					down: down,
					autoHeight: options.autoHeight || options.fillSpace
				};
			} else {
				animOptions = {
					toShow: toShow,
					toHide: toHide,
					complete: complete,
					down: down,
					autoHeight: options.autoHeight || options.fillSpace
				};
			}

			if ( !options.proxied ) {
				options.proxied = options.animated;
			}

			if ( !options.proxiedDuration ) {
				options.proxiedDuration = options.duration;
			}

			options.animated = $.isFunction( options.proxied ) ?
				options.proxied( animOptions ) :
				options.proxied;

			options.duration = $.isFunction( options.proxiedDuration ) ?
				options.proxiedDuration( animOptions ) :
				options.proxiedDuration;

			var animations = $.ui.accordion.animations,
				duration = options.duration,
				easing = options.animated;

			if ( easing && !animations[ easing ] && !$.easing[ easing ] ) {
				easing = "slide";
			}
			if ( !animations[ easing ] ) {
				animations[ easing ] = function( options ) {
					this.slide( options, {
						easing: easing,
						duration: duration || 700
					});
				};
			}

			animations[ easing ]( animOptions );
		} else {
			if ( options.collapsible && clickedIsActive ) {
				toShow.toggle();
			} else {
				toHide.hide();
				toShow.show();
			}

			complete( true );
		}

		// TODO assert that the blur and focus triggers are really necessary, remove otherwise
		toHide.prev()
			.attr({
				"aria-expanded": "false",
				"aria-selected": "false",
				tabIndex: -1
			})
			.blur();
		toShow.prev()
			.attr({
				"aria-expanded": "true",
				"aria-selected": "true",
				tabIndex: 0
			})
			.focus();
	},

	_completed: function( cancel ) {
		this.running = cancel ? 0 : --this.running;
		if ( this.running ) {
			return;
		}

		if ( this.options.clearStyle ) {
			this.toShow.add( this.toHide ).css({
				height: "",
				overflow: ""
			});
		}

		// other classes are removed before the animation; this one needs to stay until completed
		this.toHide.removeClass( "ui-accordion-content-active" );
		// Work around for rendering bug in IE (#5421)
		if ( this.toHide.length ) {
			this.toHide.parent()[0].className = this.toHide.parent()[0].className;
		}

		this._trigger( "change", null, this.data );
	}
});

$.extend( $.ui.accordion, {
	version: "1.8.11",
	animations: {
		slide: function( options, additions ) {
			options = $.extend({
				easing: "swing",
				duration: 300
			}, options, additions );
			if ( !options.toHide.size() ) {
				options.toShow.animate({
					height: "show",
					paddingTop: "show",
					paddingBottom: "show"
				}, options );
				return;
			}
			if ( !options.toShow.size() ) {
				options.toHide.animate({
					height: "hide",
					paddingTop: "hide",
					paddingBottom: "hide"
				}, options );
				return;
			}
			var overflow = options.toShow.css( "overflow" ),
				percentDone = 0,
				showProps = {},
				hideProps = {},
				fxAttrs = [ "height", "paddingTop", "paddingBottom" ],
				originalWidth;
			// fix width before calculating height of hidden element
			var s = options.toShow;
			originalWidth = s[0].style.width;
			s.width( parseInt( s.parent().width(), 10 )
				- parseInt( s.css( "paddingLeft" ), 10 )
				- parseInt( s.css( "paddingRight" ), 10 )
				- ( parseInt( s.css( "borderLeftWidth" ), 10 ) || 0 )
				- ( parseInt( s.css( "borderRightWidth" ), 10) || 0 ) );

			$.each( fxAttrs, function( i, prop ) {
				hideProps[ prop ] = "hide";

				var parts = ( "" + $.css( options.toShow[0], prop ) ).match( /^([\d+-.]+)(.*)$/ );
				showProps[ prop ] = {
					value: parts[ 1 ],
					unit: parts[ 2 ] || "px"
				};
			});
			options.toShow.css({ height: 0, overflow: "hidden" }).show();
			options.toHide
				.filter( ":hidden" )
					.each( options.complete )
				.end()
				.filter( ":visible" )
				.animate( hideProps, {
				step: function( now, settings ) {
					// only calculate the percent when animating height
					// IE gets very inconsistent results when animating elements
					// with small values, which is common for padding
					if ( settings.prop == "height" ) {
						percentDone = ( settings.end - settings.start === 0 ) ? 0 :
							( settings.now - settings.start ) / ( settings.end - settings.start );
					}

					options.toShow[ 0 ].style[ settings.prop ] =
						( percentDone * showProps[ settings.prop ].value )
						+ showProps[ settings.prop ].unit;
				},
				duration: options.duration,
				easing: options.easing,
				complete: function() {
					if ( !options.autoHeight ) {
						options.toShow.css( "height", "" );
					}
					options.toShow.css({
						width: originalWidth,
						overflow: overflow
					});
					options.complete();
				}
			});
		},
		bounceslide: function( options ) {
			this.slide( options, {
				easing: options.down ? "easeOutBounce" : "swing",
				duration: options.down ? 1000 : 200
			});
		}
	}
});

})( jQuery );
/*
 * jQuery UI Autocomplete 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Autocomplete
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 *	jquery.ui.position.js
 */
(function( $, undefined ) {

// used to prevent race conditions with remote data sources
var requestIndex = 0;

$.widget( "ui.autocomplete", {
	options: {
		appendTo: "body",
		autoFocus: false,
		delay: 300,
		minLength: 1,
		position: {
			my: "left top",
			at: "left bottom",
			collision: "none"
		},
		source: null
	},

	pending: 0,

	_create: function() {
		var self = this,
			doc = this.element[ 0 ].ownerDocument,
			suppressKeyPress;

		this.element
			.addClass( "ui-autocomplete-input" )
			.attr( "autocomplete", "off" )
			// TODO verify these actually work as intended
			.attr({
				role: "textbox",
				"aria-autocomplete": "list",
				"aria-haspopup": "true"
			})
			.bind( "keydown.autocomplete", function( event ) {
				if ( self.options.disabled || self.element.attr( "readonly" ) ) {
					return;
				}

				suppressKeyPress = false;
				var keyCode = $.ui.keyCode;
				switch( event.keyCode ) {
				case keyCode.PAGE_UP:
					self._move( "previousPage", event );
					break;
				case keyCode.PAGE_DOWN:
					self._move( "nextPage", event );
					break;
				case keyCode.UP:
					self._move( "previous", event );
					// prevent moving cursor to beginning of text field in some browsers
					event.preventDefault();
					break;
				case keyCode.DOWN:
					self._move( "next", event );
					// prevent moving cursor to end of text field in some browsers
					event.preventDefault();
					break;
				case keyCode.ENTER:
				case keyCode.NUMPAD_ENTER:
					// when menu is open and has focus
					if ( self.menu.active ) {
						// #6055 - Opera still allows the keypress to occur
						// which causes forms to submit
						suppressKeyPress = true;
						event.preventDefault();
					}
					//passthrough - ENTER and TAB both select the current element
				case keyCode.TAB:
					if ( !self.menu.active ) {
						return;
					}
					self.menu.select( event );
					break;
				case keyCode.ESCAPE:
					self.element.val( self.term );
					self.close( event );
					break;
				default:
					// keypress is triggered before the input value is changed
					clearTimeout( self.searching );
					self.searching = setTimeout(function() {
						// only search if the value has changed
						if ( self.term != self.element.val() ) {
							self.selectedItem = null;
							self.search( null, event );
						}
					}, self.options.delay );
					break;
				}
			})
			.bind( "keypress.autocomplete", function( event ) {
				if ( suppressKeyPress ) {
					suppressKeyPress = false;
					event.preventDefault();
				}
			})
			.bind( "focus.autocomplete", function() {
				if ( self.options.disabled ) {
					return;
				}

				self.selectedItem = null;
				self.previous = self.element.val();
			})
			.bind( "blur.autocomplete", function( event ) {
				if ( self.options.disabled ) {
					return;
				}

				clearTimeout( self.searching );
				// clicks on the menu (or a button to trigger a search) will cause a blur event
				self.closing = setTimeout(function() {
					self.close( event );
					self._change( event );
				}, 150 );
			});
		this._initSource();
		this.response = function() {
			return self._response.apply( self, arguments );
		};
		this.menu = $( "<ul></ul>" )
			.addClass( "ui-autocomplete" )
			.appendTo( $( this.options.appendTo || "body", doc )[0] )
			// prevent the close-on-blur in case of a "slow" click on the menu (long mousedown)
			.mousedown(function( event ) {
				// clicking on the scrollbar causes focus to shift to the body
				// but we can't detect a mouseup or a click immediately afterward
				// so we have to track the next mousedown and close the menu if
				// the user clicks somewhere outside of the autocomplete
				var menuElement = self.menu.element[ 0 ];
				if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
					setTimeout(function() {
						$( document ).one( 'mousedown', function( event ) {
							if ( event.target !== self.element[ 0 ] &&
								event.target !== menuElement &&
								!$.ui.contains( menuElement, event.target ) ) {
								self.close();
							}
						});
					}, 1 );
				}

				// use another timeout to make sure the blur-event-handler on the input was already triggered
				setTimeout(function() {
					clearTimeout( self.closing );
				}, 13);
			})
			.menu({
				focus: function( event, ui ) {
					var item = ui.item.data( "item.autocomplete" );
					if ( false !== self._trigger( "focus", event, { item: item } ) ) {
						// use value to match what will end up in the input, if it was a key event
						if ( /^key/.test(event.originalEvent.type) ) {
							self.element.val( item.value );
						}
					}
				},
				selected: function( event, ui ) {
					var item = ui.item.data( "item.autocomplete" ),
						previous = self.previous;

					// only trigger when focus was lost (click on menu)
					if ( self.element[0] !== doc.activeElement ) {
						self.element.focus();
						self.previous = previous;
						// #6109 - IE triggers two focus events and the second
						// is asynchronous, so we need to reset the previous
						// term synchronously and asynchronously :-(
						setTimeout(function() {
							self.previous = previous;
							self.selectedItem = item;
						}, 1);
					}

					if ( false !== self._trigger( "select", event, { item: item } ) ) {
						self.element.val( item.value );
					}
					// reset the term after the select event
					// this allows custom select handling to work properly
					self.term = self.element.val();

					self.close( event );
					self.selectedItem = item;
				},
				blur: function( event, ui ) {
					// don't set the value of the text field if it's already correct
					// this prevents moving the cursor unnecessarily
					if ( self.menu.element.is(":visible") &&
						( self.element.val() !== self.term ) ) {
						self.element.val( self.term );
					}
				}
			})
			.zIndex( this.element.zIndex() + 1 )
			// workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
			.css({ top: 0, left: 0 })
			.hide()
			.data( "menu" );
		if ( $.fn.bgiframe ) {
			 this.menu.element.bgiframe();
		}
	},

	destroy: function() {
		this.element
			.removeClass( "ui-autocomplete-input" )
			.removeAttr( "autocomplete" )
			.removeAttr( "role" )
			.removeAttr( "aria-autocomplete" )
			.removeAttr( "aria-haspopup" );
		this.menu.element.remove();
		$.Widget.prototype.destroy.call( this );
	},

	_setOption: function( key, value ) {
		$.Widget.prototype._setOption.apply( this, arguments );
		if ( key === "source" ) {
			this._initSource();
		}
		if ( key === "appendTo" ) {
			this.menu.element.appendTo( $( value || "body", this.element[0].ownerDocument )[0] )
		}
		if ( key === "disabled" && value && this.xhr ) {
			this.xhr.abort();
		}
	},

	_initSource: function() {
		var self = this,
			array,
			url;
		if ( $.isArray(this.options.source) ) {
			array = this.options.source;
			this.source = function( request, response ) {
				response( $.ui.autocomplete.filter(array, request.term) );
			};
		} else if ( typeof this.options.source === "string" ) {
			url = this.options.source;
			this.source = function( request, response ) {
				if ( self.xhr ) {
					self.xhr.abort();
				}
				self.xhr = $.ajax({
					url: url,
					data: request,
					dataType: "json",
					autocompleteRequest: ++requestIndex,
					success: function( data, status ) {
						if ( this.autocompleteRequest === requestIndex ) {
							response( data );
						}
					},
					error: function() {
						if ( this.autocompleteRequest === requestIndex ) {
							response( [] );
						}
					}
				});
			};
		} else {
			this.source = this.options.source;
		}
	},

	search: function( value, event ) {
		value = value != null ? value : this.element.val();

		// always save the actual value, not the one passed as an argument
		this.term = this.element.val();

		if ( value.length < this.options.minLength ) {
			return this.close( event );
		}

		clearTimeout( this.closing );
		if ( this._trigger( "search", event ) === false ) {
			return;
		}

		return this._search( value );
	},

	_search: function( value ) {
		this.pending++;
		this.element.addClass( "ui-autocomplete-loading" );

		this.source( { term: value }, this.response );
	},

	_response: function( content ) {
		if ( !this.options.disabled && content && content.length ) {
			content = this._normalize( content );
			this._suggest( content );
			this._trigger( "open" );
		} else {
			this.close();
		}
		this.pending--;
		if ( !this.pending ) {
			this.element.removeClass( "ui-autocomplete-loading" );
		}
	},

	close: function( event ) {
		clearTimeout( this.closing );
		if ( this.menu.element.is(":visible") ) {
			this.menu.element.hide();
			this.menu.deactivate();
			this._trigger( "close", event );
		}
	},
	
	_change: function( event ) {
		if ( this.previous !== this.element.val() ) {
			this._trigger( "change", event, { item: this.selectedItem } );
		}
	},

	_normalize: function( items ) {
		// assume all items have the right format when the first item is complete
		if ( items.length && items[0].label && items[0].value ) {
			return items;
		}
		return $.map( items, function(item) {
			if ( typeof item === "string" ) {
				return {
					label: item,
					value: item
				};
			}
			return $.extend({
				label: item.label || item.value,
				value: item.value || item.label
			}, item );
		});
	},

	_suggest: function( items ) {
		var ul = this.menu.element
			.empty()
			.zIndex( this.element.zIndex() + 1 );
		this._renderMenu( ul, items );
		// TODO refresh should check if the active item is still in the dom, removing the need for a manual deactivate
		this.menu.deactivate();
		this.menu.refresh();

		// size and position menu
		ul.show();
		this._resizeMenu();
		ul.position( $.extend({
			of: this.element
		}, this.options.position ));

		if ( this.options.autoFocus ) {
			this.menu.next( new $.Event("mouseover") );
		}
	},

	_resizeMenu: function() {
		var ul = this.menu.element;
		ul.outerWidth( Math.max(
			ul.width( "" ).outerWidth(),
			this.element.outerWidth()
		) );
	},

	_renderMenu: function( ul, items ) {
		var self = this;
		$.each( items, function( index, item ) {
			self._renderItem( ul, item );
		});
	},

	_renderItem: function( ul, item) {
		return $( "<li></li>" )
			.data( "item.autocomplete", item )
			.append( $( "<a></a>" ).text( item.label ) )
			.appendTo( ul );
	},

	_move: function( direction, event ) {
		if ( !this.menu.element.is(":visible") ) {
			this.search( null, event );
			return;
		}
		if ( this.menu.first() && /^previous/.test(direction) ||
				this.menu.last() && /^next/.test(direction) ) {
			this.element.val( this.term );
			this.menu.deactivate();
			return;
		}
		this.menu[ direction ]( event );
	},

	widget: function() {
		return this.menu.element;
	}
});

$.extend( $.ui.autocomplete, {
	escapeRegex: function( value ) {
		return value.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
	},
	filter: function(array, term) {
		var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
		return $.grep( array, function(value) {
			return matcher.test( value.label || value.value || value );
		});
	}
});

}( jQuery ));

/*
 * jQuery UI Menu (not officially released)
 * 
 * This widget isn't yet finished and the API is subject to change. We plan to finish
 * it for the next release. You're welcome to give it a try anyway and give us feedback,
 * as long as you're okay with migrating your code later on. We can help with that, too.
 *
 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Menu
 *
 * Depends:
 *	jquery.ui.core.js
 *  jquery.ui.widget.js
 */
(function($) {

$.widget("ui.menu", {
	_create: function() {
		var self = this;
		this.element
			.addClass("ui-menu ui-widget ui-widget-content ui-corner-all")
			.attr({
				role: "listbox",
				"aria-activedescendant": "ui-active-menuitem"
			})
			.click(function( event ) {
				if ( !$( event.target ).closest( ".ui-menu-item a" ).length ) {
					return;
				}
				// temporary
				event.preventDefault();
				self.select( event );
			});
		this.refresh();
	},
	
	refresh: function() {
		var self = this;

		// don't refresh list items that are already adapted
		var items = this.element.children("li:not(.ui-menu-item):has(a)")
			.addClass("ui-menu-item")
			.attr("role", "menuitem");
		
		items.children("a")
			.addClass("ui-corner-all")
			.attr("tabindex", -1)
			// mouseenter doesn't work with event delegation
			.mouseenter(function( event ) {
				self.activate( event, $(this).parent() );
			})
			.mouseleave(function() {
				self.deactivate();
			});
	},

	activate: function( event, item ) {
		this.deactivate();
		if (this.hasScroll()) {
			var offset = item.offset().top - this.element.offset().top,
				scroll = this.element.attr("scrollTop"),
				elementHeight = this.element.height();
			if (offset < 0) {
				this.element.attr("scrollTop", scroll + offset);
			} else if (offset >= elementHeight) {
				this.element.attr("scrollTop", scroll + offset - elementHeight + item.height());
			}
		}
		this.active = item.eq(0)
			.children("a")
				.addClass("ui-state-hover")
				.attr("id", "ui-active-menuitem")
			.end();
		this._trigger("focus", event, { item: item });
	},

	deactivate: function() {
		if (!this.active) { return; }

		this.active.children("a")
			.removeClass("ui-state-hover")
			.removeAttr("id");
		this._trigger("blur");
		this.active = null;
	},

	next: function(event) {
		this.move("next", ".ui-menu-item:first", event);
	},

	previous: function(event) {
		this.move("prev", ".ui-menu-item:last", event);
	},

	first: function() {
		return this.active && !this.active.prevAll(".ui-menu-item").length;
	},

	last: function() {
		return this.active && !this.active.nextAll(".ui-menu-item").length;
	},

	move: function(direction, edge, event) {
		if (!this.active) {
			this.activate(event, this.element.children(edge));
			return;
		}
		var next = this.active[direction + "All"](".ui-menu-item").eq(0);
		if (next.length) {
			this.activate(event, next);
		} else {
			this.activate(event, this.element.children(edge));
		}
	},

	// TODO merge with previousPage
	nextPage: function(event) {
		if (this.hasScroll()) {
			// TODO merge with no-scroll-else
			if (!this.active || this.last()) {
				this.activate(event, this.element.children(".ui-menu-item:first"));
				return;
			}
			var base = this.active.offset().top,
				height = this.element.height(),
				result = this.element.children(".ui-menu-item").filter(function() {
					var close = $(this).offset().top - base - height + $(this).height();
					// TODO improve approximation
					return close < 10 && close > -10;
				});

			// TODO try to catch this earlier when scrollTop indicates the last page anyway
			if (!result.length) {
				result = this.element.children(".ui-menu-item:last");
			}
			this.activate(event, result);
		} else {
			this.activate(event, this.element.children(".ui-menu-item")
				.filter(!this.active || this.last() ? ":first" : ":last"));
		}
	},

	// TODO merge with nextPage
	previousPage: function(event) {
		if (this.hasScroll()) {
			// TODO merge with no-scroll-else
			if (!this.active || this.first()) {
				this.activate(event, this.element.children(".ui-menu-item:last"));
				return;
			}

			var base = this.active.offset().top,
				height = this.element.height();
				result = this.element.children(".ui-menu-item").filter(function() {
					var close = $(this).offset().top - base + height - $(this).height();
					// TODO improve approximation
					return close < 10 && close > -10;
				});

			// TODO try to catch this earlier when scrollTop indicates the last page anyway
			if (!result.length) {
				result = this.element.children(".ui-menu-item:first");
			}
			this.activate(event, result);
		} else {
			this.activate(event, this.element.children(".ui-menu-item")
				.filter(!this.active || this.first() ? ":last" : ":first"));
		}
	},

	hasScroll: function() {
		return this.element.height() < this.element.attr("scrollHeight");
	},

	select: function( event ) {
		this._trigger("selected", event, { item: this.active });
	}
});

}(jQuery));
/*
 * jQuery UI Button 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Button
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

var lastActive,
	baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
	stateClasses = "ui-state-hover ui-state-active ",
	typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
	formResetHandler = function( event ) {
		$( ":ui-button", event.target.form ).each(function() {
			var inst = $( this ).data( "button" );
			setTimeout(function() {
				inst.refresh();
			}, 1 );
		});
	},
	radioGroup = function( radio ) {
		var name = radio.name,
			form = radio.form,
			radios = $( [] );
		if ( name ) {
			if ( form ) {
				radios = $( form ).find( "[name='" + name + "']" );
			} else {
				radios = $( "[name='" + name + "']", radio.ownerDocument )
					.filter(function() {
						return !this.form;
					});
			}
		}
		return radios;
	};

$.widget( "ui.button", {
	options: {
		disabled: null,
		text: true,
		label: null,
		icons: {
			primary: null,
			secondary: null
		}
	},
	_create: function() {
		this.element.closest( "form" )
			.unbind( "reset.button" )
			.bind( "reset.button", formResetHandler );

		if ( typeof this.options.disabled !== "boolean" ) {
			this.options.disabled = this.element.attr( "disabled" );
		}

		this._determineButtonType();
		this.hasTitle = !!this.buttonElement.attr( "title" );

		var self = this,
			options = this.options,
			toggleButton = this.type === "checkbox" || this.type === "radio",
			hoverClass = "ui-state-hover" + ( !toggleButton ? " ui-state-active" : "" ),
			focusClass = "ui-state-focus";

		if ( options.label === null ) {
			options.label = this.buttonElement.html();
		}

		if ( this.element.is( ":disabled" ) ) {
			options.disabled = true;
		}

		this.buttonElement
			.addClass( baseClasses )
			.attr( "role", "button" )
			.bind( "mouseenter.button", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).addClass( "ui-state-hover" );
				if ( this === lastActive ) {
					$( this ).addClass( "ui-state-active" );
				}
			})
			.bind( "mouseleave.button", function() {
				if ( options.disabled ) {
					return;
				}
				$( this ).removeClass( hoverClass );
			})
			.bind( "focus.button", function() {
				// no need to check disabled, focus won't be triggered anyway
				$( this ).addClass( focusClass );
			})
			.bind( "blur.button", function() {
				$( this ).removeClass( focusClass );
			});

		if ( toggleButton ) {
			this.element.bind( "change.button", function() {
				self.refresh();
			});
		}

		if ( this.type === "checkbox" ) {
			this.buttonElement.bind( "click.button", function() {
				if ( options.disabled ) {
					return false;
				}
				$( this ).toggleClass( "ui-state-active" );
				self.buttonElement.attr( "aria-pressed", self.element[0].checked );
			});
		} else if ( this.type === "radio" ) {
			this.buttonElement.bind( "click.button", function() {
				if ( options.disabled ) {
					return false;
				}
				$( this ).addClass( "ui-state-active" );
				self.buttonElement.attr( "aria-pressed", true );

				var radio = self.element[ 0 ];
				radioGroup( radio )
					.not( radio )
					.map(function() {
						return $( this ).button( "widget" )[ 0 ];
					})
					.removeClass( "ui-state-active" )
					.attr( "aria-pressed", false );
			});
		} else {
			this.buttonElement
				.bind( "mousedown.button", function() {
					if ( options.disabled ) {
						return false;
					}
					$( this ).addClass( "ui-state-active" );
					lastActive = this;
					$( document ).one( "mouseup", function() {
						lastActive = null;
					});
				})
				.bind( "mouseup.button", function() {
					if ( options.disabled ) {
						return false;
					}
					$( this ).removeClass( "ui-state-active" );
				})
				.bind( "keydown.button", function(event) {
					if ( options.disabled ) {
						return false;
					}
					if ( event.keyCode == $.ui.keyCode.SPACE || event.keyCode == $.ui.keyCode.ENTER ) {
						$( this ).addClass( "ui-state-active" );
					}
				})
				.bind( "keyup.button", function() {
					$( this ).removeClass( "ui-state-active" );
				});

			if ( this.buttonElement.is("a") ) {
				this.buttonElement.keyup(function(event) {
					if ( event.keyCode === $.ui.keyCode.SPACE ) {
						// TODO pass through original event correctly (just as 2nd argument doesn't work)
						$( this ).click();
					}
				});
			}
		}

		// TODO: pull out $.Widget's handling for the disabled option into
		// $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
		// be overridden by individual plugins
		this._setOption( "disabled", options.disabled );
	},

	_determineButtonType: function() {
		
		if ( this.element.is(":checkbox") ) {
			this.type = "checkbox";
		} else {
			if ( this.element.is(":radio") ) {
				this.type = "radio";
			} else {
				if ( this.element.is("input") ) {
					this.type = "input";
				} else {
					this.type = "button";
				}
			}
		}
		
		if ( this.type === "checkbox" || this.type === "radio" ) {
			// we don't search against the document in case the element
			// is disconnected from the DOM
			var ancestor = this.element.parents().filter(":last"),
				labelSelector = "label[for=" + this.element.attr("id") + "]";
			this.buttonElement = ancestor.find( labelSelector );
			if ( !this.buttonElement.length ) {
				ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
				this.buttonElement = ancestor.filter( labelSelector );
				if ( !this.buttonElement.length ) {
					this.buttonElement = ancestor.find( labelSelector );
				}
			}
			this.element.addClass( "ui-helper-hidden-accessible" );

			var checked = this.element.is( ":checked" );
			if ( checked ) {
				this.buttonElement.addClass( "ui-state-active" );
			}
			this.buttonElement.attr( "aria-pressed", checked );
		} else {
			this.buttonElement = this.element;
		}
	},

	widget: function() {
		return this.buttonElement;
	},

	destroy: function() {
		this.element
			.removeClass( "ui-helper-hidden-accessible" );
		this.buttonElement
			.removeClass( baseClasses + " " + stateClasses + " " + typeClasses )
			.removeAttr( "role" )
			.removeAttr( "aria-pressed" )
			.html( this.buttonElement.find(".ui-button-text").html() );

		if ( !this.hasTitle ) {
			this.buttonElement.removeAttr( "title" );
		}

		$.Widget.prototype.destroy.call( this );
	},

	_setOption: function( key, value ) {
		$.Widget.prototype._setOption.apply( this, arguments );
		if ( key === "disabled" ) {
			if ( value ) {
				this.element.attr( "disabled", true );
			} else {
				this.element.removeAttr( "disabled" );
			}
		}
		this._resetButton();
	},

	refresh: function() {
		var isDisabled = this.element.is( ":disabled" );
		if ( isDisabled !== this.options.disabled ) {
			this._setOption( "disabled", isDisabled );
		}
		if ( this.type === "radio" ) {
			radioGroup( this.element[0] ).each(function() {
				if ( $( this ).is( ":checked" ) ) {
					$( this ).button( "widget" )
						.addClass( "ui-state-active" )
						.attr( "aria-pressed", true );
				} else {
					$( this ).button( "widget" )
						.removeClass( "ui-state-active" )
						.attr( "aria-pressed", false );
				}
			});
		} else if ( this.type === "checkbox" ) {
			if ( this.element.is( ":checked" ) ) {
				this.buttonElement
					.addClass( "ui-state-active" )
					.attr( "aria-pressed", true );
			} else {
				this.buttonElement
					.removeClass( "ui-state-active" )
					.attr( "aria-pressed", false );
			}
		}
	},

	_resetButton: function() {
		if ( this.type === "input" ) {
			if ( this.options.label ) {
				this.element.val( this.options.label );
			}
			return;
		}
		var buttonElement = this.buttonElement.removeClass( typeClasses ),
			buttonText = $( "<span></span>" )
				.addClass( "ui-button-text" )
				.html( this.options.label )
				.appendTo( buttonElement.empty() )
				.text(),
			icons = this.options.icons,
			multipleIcons = icons.primary && icons.secondary,
			buttonClasses = [];  

		if ( icons.primary || icons.secondary ) {
			if ( this.options.text ) {
				buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
			}

			if ( icons.primary ) {
				buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
			}

			if ( icons.secondary ) {
				buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
			}

			if ( !this.options.text ) {
				buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );

				if ( !this.hasTitle ) {
					buttonElement.attr( "title", buttonText );
				}
			}
		} else {
			buttonClasses.push( "ui-button-text-only" );
		}
		buttonElement.addClass( buttonClasses.join( " " ) );
	}
});

$.widget( "ui.buttonset", {
	options: {
		items: ":button, :submit, :reset, :checkbox, :radio, a, :data(button)"
	},

	_create: function() {
		this.element.addClass( "ui-buttonset" );
	},
	
	_init: function() {
		this.refresh();
	},

	_setOption: function( key, value ) {
		if ( key === "disabled" ) {
			this.buttons.button( "option", key, value );
		}

		$.Widget.prototype._setOption.apply( this, arguments );
	},
	
	refresh: function() {
		this.buttons = this.element.find( this.options.items )
			.filter( ":ui-button" )
				.button( "refresh" )
			.end()
			.not( ":ui-button" )
				.button()
			.end()
			.map(function() {
				return $( this ).button( "widget" )[ 0 ];
			})
				.removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
				.filter( ":first" )
					.addClass( "ui-corner-left" )
				.end()
				.filter( ":last" )
					.addClass( "ui-corner-right" )
				.end()
			.end();
	},

	destroy: function() {
		this.element.removeClass( "ui-buttonset" );
		this.buttons
			.map(function() {
				return $( this ).button( "widget" )[ 0 ];
			})
				.removeClass( "ui-corner-left ui-corner-right" )
			.end()
			.button( "destroy" );

		$.Widget.prototype.destroy.call( this );
	}
});

}( jQuery ) );
/*
 * jQuery UI Dialog 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Dialog
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 *  jquery.ui.button.js
 *	jquery.ui.draggable.js
 *	jquery.ui.mouse.js
 *	jquery.ui.position.js
 *	jquery.ui.resizable.js
 */
(function( $, undefined ) {

var uiDialogClasses =
		'ui-dialog ' +
		'ui-widget ' +
		'ui-widget-content ' +
		'ui-corner-all ',
	sizeRelatedOptions = {
		buttons: true,
		height: true,
		maxHeight: true,
		maxWidth: true,
		minHeight: true,
		minWidth: true,
		width: true
	},
	resizableRelatedOptions = {
		maxHeight: true,
		maxWidth: true,
		minHeight: true,
		minWidth: true
	};

$.widget("ui.dialog", {
	options: {
		autoOpen: true,
		buttons: {},
		closeOnEscape: true,
		closeText: 'close',
		dialogClass: '',
		draggable: true,
		hide: null,
		height: 'auto',
		maxHeight: false,
		maxWidth: false,
		minHeight: 150,
		minWidth: 150,
		modal: false,
		position: {
			my: 'center',
			at: 'center',
			collision: 'fit',
			// ensure that the titlebar is never outside the document
			using: function(pos) {
				var topOffset = $(this).css(pos).offset().top;
				if (topOffset < 0) {
					$(this).css('top', pos.top - topOffset);
				}
			}
		},
		resizable: true,
		show: null,
		stack: true,
		title: '',
		width: 300,
		zIndex: 1000
	},

	_create: function() {
		this.originalTitle = this.element.attr('title');
		// #5742 - .attr() might return a DOMElement
		if ( typeof this.originalTitle !== "string" ) {
			this.originalTitle = "";
		}

		this.options.title = this.options.title || this.originalTitle;
		var self = this,
			options = self.options,

			title = options.title || '&#160;',
			titleId = $.ui.dialog.getTitleId(self.element),

			uiDialog = (self.uiDialog = $('<div></div>'))
				.appendTo(document.body)
				.hide()
				.addClass(uiDialogClasses + options.dialogClass)
				.css({
					zIndex: options.zIndex
				})
				// setting tabIndex makes the div focusable
				// setting outline to 0 prevents a border on focus in Mozilla
				.attr('tabIndex', -1).css('outline', 0).keydown(function(event) {
					if (options.closeOnEscape && event.keyCode &&
						event.keyCode === $.ui.keyCode.ESCAPE) {
						
						self.close(event);
						event.preventDefault();
					}
				})
				.attr({
					role: 'dialog',
					'aria-labelledby': titleId
				})
				.mousedown(function(event) {
					self.moveToTop(false, event);
				}),

			uiDialogContent = self.element
				.show()
				.removeAttr('title')
				.addClass(
					'ui-dialog-content ' +
					'ui-widget-content')
				.appendTo(uiDialog),

			uiDialogTitlebar = (self.uiDialogTitlebar = $('<div></div>'))
				.addClass(
					'ui-dialog-titlebar ' +
					'ui-widget-header ' +
					'ui-corner-all ' +
					'ui-helper-clearfix'
				)
				.prependTo(uiDialog),

			uiDialogTitlebarClose = $('<a href="#"></a>')
				.addClass(
					'ui-dialog-titlebar-close ' +
					'ui-corner-all'
				)
				.attr('role', 'button')
				.hover(
					function() {
						uiDialogTitlebarClose.addClass('ui-state-hover');
					},
					function() {
						uiDialogTitlebarClose.removeClass('ui-state-hover');
					}
				)
				.focus(function() {
					uiDialogTitlebarClose.addClass('ui-state-focus');
				})
				.blur(function() {
					uiDialogTitlebarClose.removeClass('ui-state-focus');
				})
				.click(function(event) {
					self.close(event);
					return false;
				})
				.appendTo(uiDialogTitlebar),

			uiDialogTitlebarCloseText = (self.uiDialogTitlebarCloseText = $('<span></span>'))
				.addClass(
					'ui-icon ' +
					'ui-icon-closethick'
				)
				.text(options.closeText)
				.appendTo(uiDialogTitlebarClose),

			uiDialogTitle = $('<span></span>')
				.addClass('ui-dialog-title')
				.attr('id', titleId)
				.html(title)
				.prependTo(uiDialogTitlebar);

		//handling of deprecated beforeclose (vs beforeClose) option
		//Ticket #4669 http://dev.jqueryui.com/ticket/4669
		//TODO: remove in 1.9pre
		if ($.isFunction(options.beforeclose) && !$.isFunction(options.beforeClose)) {
			options.beforeClose = options.beforeclose;
		}

		uiDialogTitlebar.find("*").add(uiDialogTitlebar).disableSelection();

		if (options.draggable && $.fn.draggable) {
			self._makeDraggable();
		}
		if (options.resizable && $.fn.resizable) {
			self._makeResizable();
		}

		self._createButtons(options.buttons);
		self._isOpen = false;

		if ($.fn.bgiframe) {
			uiDialog.bgiframe();
		}
	},

	_init: function() {
		if ( this.options.autoOpen ) {
			this.open();
		}
	},

	destroy: function() {
		var self = this;
		
		if (self.overlay) {
			self.overlay.destroy();
		}
		self.uiDialog.hide();
		self.element
			.unbind('.dialog')
			.removeData('dialog')
			.removeClass('ui-dialog-content ui-widget-content')
			.hide().appendTo('body');
		self.uiDialog.remove();

		if (self.originalTitle) {
			self.element.attr('title', self.originalTitle);
		}

		return self;
	},

	widget: function() {
		return this.uiDialog;
	},

	close: function(event) {
		var self = this,
			maxZ, thisZ;
		
		if (false === self._trigger('beforeClose', event)) {
			return;
		}

		if (self.overlay) {
			self.overlay.destroy();
		}
		self.uiDialog.unbind('keypress.ui-dialog');

		self._isOpen = false;

		if (self.options.hide) {
			self.uiDialog.hide(self.options.hide, function() {
				self._trigger('close', event);
			});
		} else {
			self.uiDialog.hide();
			self._trigger('close', event);
		}

		$.ui.dialog.overlay.resize();

		// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
		if (self.options.modal) {
			maxZ = 0;
			$('.ui-dialog').each(function() {
				if (this !== self.uiDialog[0]) {
					thisZ = $(this).css('z-index');
					if(!isNaN(thisZ)) {
						maxZ = Math.max(maxZ, thisZ);
					}
				}
			});
			$.ui.dialog.maxZ = maxZ;
		}

		return self;
	},

	isOpen: function() {
		return this._isOpen;
	},

	// the force parameter allows us to move modal dialogs to their correct
	// position on open
	moveToTop: function(force, event) {
		var self = this,
			options = self.options,
			saveScroll;

		if ((options.modal && !force) ||
			(!options.stack && !options.modal)) {
			return self._trigger('focus', event);
		}

		if (options.zIndex > $.ui.dialog.maxZ) {
			$.ui.dialog.maxZ = options.zIndex;
		}
		if (self.overlay) {
			$.ui.dialog.maxZ += 1;
			self.overlay.$el.css('z-index', $.ui.dialog.overlay.maxZ = $.ui.dialog.maxZ);
		}

		//Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
		//  http://ui.jquery.com/bugs/ticket/3193
		saveScroll = { scrollTop: self.element.attr('scrollTop'), scrollLeft: self.element.attr('scrollLeft') };
		$.ui.dialog.maxZ += 1;
		self.uiDialog.css('z-index', $.ui.dialog.maxZ);
		self.element.attr(saveScroll);
		self._trigger('focus', event);

		return self;
	},

	open: function() {
		if (this._isOpen) { return; }

		var self = this,
			options = self.options,
			uiDialog = self.uiDialog;

		self.overlay = options.modal ? new $.ui.dialog.overlay(self) : null;
		self._size();
		self._position(options.position);
		uiDialog.show(options.show);
		self.moveToTop(true);

		// prevent tabbing out of modal dialogs
		if (options.modal) {
			uiDialog.bind('keypress.ui-dialog', function(event) {
				if (event.keyCode !== $.ui.keyCode.TAB) {
					return;
				}

				var tabbables = $(':tabbable', this),
					first = tabbables.filter(':first'),
					last  = tabbables.filter(':last');

				if (event.target === last[0] && !event.shiftKey) {
					first.focus(1);
					return false;
				} else if (event.target === first[0] && event.shiftKey) {
					last.focus(1);
					return false;
				}
			});
		}

		// set focus to the first tabbable element in the content area or the first button
		// if there are no tabbable elements, set focus on the dialog itself
		$(self.element.find(':tabbable').get().concat(
			uiDialog.find('.ui-dialog-buttonpane :tabbable').get().concat(
				uiDialog.get()))).eq(0).focus();

		self._isOpen = true;
		self._trigger('open');

		return self;
	},

	_createButtons: function(buttons) {
		var self = this,
			hasButtons = false,
			uiDialogButtonPane = $('<div></div>')
				.addClass(
					'ui-dialog-buttonpane ' +
					'ui-widget-content ' +
					'ui-helper-clearfix'
				),
			uiButtonSet = $( "<div></div>" )
				.addClass( "ui-dialog-buttonset" )
				.appendTo( uiDialogButtonPane );

		// if we already have a button pane, remove it
		self.uiDialog.find('.ui-dialog-buttonpane').remove();

		if (typeof buttons === 'object' && buttons !== null) {
			$.each(buttons, function() {
				return !(hasButtons = true);
			});
		}
		if (hasButtons) {
			$.each(buttons, function(name, props) {
				props = $.isFunction( props ) ?
					{ click: props, text: name } :
					props;
				var button = $('<button type="button"></button>')
					.attr( props, true )
					.unbind('click')
					.click(function() {
						props.click.apply(self.element[0], arguments);
					})
					.appendTo(uiButtonSet);
				if ($.fn.button) {
					button.button();
				}
			});
			uiDialogButtonPane.appendTo(self.uiDialog);
		}
	},

	_makeDraggable: function() {
		var self = this,
			options = self.options,
			doc = $(document),
			heightBeforeDrag;

		function filteredUi(ui) {
			return {
				position: ui.position,
				offset: ui.offset
			};
		}

		self.uiDialog.draggable({
			cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
			handle: '.ui-dialog-titlebar',
			containment: 'document',
			start: function(event, ui) {
				heightBeforeDrag = options.height === "auto" ? "auto" : $(this).height();
				$(this).height($(this).height()).addClass("ui-dialog-dragging");
				self._trigger('dragStart', event, filteredUi(ui));
			},
			drag: function(event, ui) {
				self._trigger('drag', event, filteredUi(ui));
			},
			stop: function(event, ui) {
				options.position = [ui.position.left - doc.scrollLeft(),
					ui.position.top - doc.scrollTop()];
				$(this).removeClass("ui-dialog-dragging").height(heightBeforeDrag);
				self._trigger('dragStop', event, filteredUi(ui));
				$.ui.dialog.overlay.resize();
			}
		});
	},

	_makeResizable: function(handles) {
		handles = (handles === undefined ? this.options.resizable : handles);
		var self = this,
			options = self.options,
			// .ui-resizable has position: relative defined in the stylesheet
			// but dialogs have to use absolute or fixed positioning
			position = self.uiDialog.css('position'),
			resizeHandles = (typeof handles === 'string' ?
				handles	:
				'n,e,s,w,se,sw,ne,nw'
			);

		function filteredUi(ui) {
			return {
				originalPosition: ui.originalPosition,
				originalSize: ui.originalSize,
				position: ui.position,
				size: ui.size
			};
		}

		self.uiDialog.resizable({
			cancel: '.ui-dialog-content',
			containment: 'document',
			alsoResize: self.element,
			maxWidth: options.maxWidth,
			maxHeight: options.maxHeight,
			minWidth: options.minWidth,
			minHeight: self._minHeight(),
			handles: resizeHandles,
			start: function(event, ui) {
				$(this).addClass("ui-dialog-resizing");
				self._trigger('resizeStart', event, filteredUi(ui));
			},
			resize: function(event, ui) {
				self._trigger('resize', event, filteredUi(ui));
			},
			stop: function(event, ui) {
				$(this).removeClass("ui-dialog-resizing");
				options.height = $(this).height();
				options.width = $(this).width();
				self._trigger('resizeStop', event, filteredUi(ui));
				$.ui.dialog.overlay.resize();
			}
		})
		.css('position', position)
		.find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
	},

	_minHeight: function() {
		var options = this.options;

		if (options.height === 'auto') {
			return options.minHeight;
		} else {
			return Math.min(options.minHeight, options.height);
		}
	},

	_position: function(position) {
		var myAt = [],
			offset = [0, 0],
			isVisible;

		if (position) {
			// deep extending converts arrays to objects in jQuery <= 1.3.2 :-(
	//		if (typeof position == 'string' || $.isArray(position)) {
	//			myAt = $.isArray(position) ? position : position.split(' ');

			if (typeof position === 'string' || (typeof position === 'object' && '0' in position)) {
				myAt = position.split ? position.split(' ') : [position[0], position[1]];
				if (myAt.length === 1) {
					myAt[1] = myAt[0];
				}

				$.each(['left', 'top'], function(i, offsetPosition) {
					if (+myAt[i] === myAt[i]) {
						offset[i] = myAt[i];
						myAt[i] = offsetPosition;
					}
				});

				position = {
					my: myAt.join(" "),
					at: myAt.join(" "),
					offset: offset.join(" ")
				};
			} 

			position = $.extend({}, $.ui.dialog.prototype.options.position, position);
		} else {
			position = $.ui.dialog.prototype.options.position;
		}

		// need to show the dialog to get the actual offset in the position plugin
		isVisible = this.uiDialog.is(':visible');
		if (!isVisible) {
			this.uiDialog.show();
		}
		this.uiDialog
			// workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
			.css({ top: 0, left: 0 })
			.position($.extend({ of: window }, position));
		if (!isVisible) {
			this.uiDialog.hide();
		}
	},

	_setOptions: function( options ) {
		var self = this,
			resizableOptions = {},
			resize = false;

		$.each( options, function( key, value ) {
			self._setOption( key, value );
			
			if ( key in sizeRelatedOptions ) {
				resize = true;
			}
			if ( key in resizableRelatedOptions ) {
				resizableOptions[ key ] = value;
			}
		});

		if ( resize ) {
			this._size();
		}
		if ( this.uiDialog.is( ":data(resizable)" ) ) {
			this.uiDialog.resizable( "option", resizableOptions );
		}
	},

	_setOption: function(key, value){
		var self = this,
			uiDialog = self.uiDialog;

		switch (key) {
			//handling of deprecated beforeclose (vs beforeClose) option
			//Ticket #4669 http://dev.jqueryui.com/ticket/4669
			//TODO: remove in 1.9pre
			case "beforeclose":
				key = "beforeClose";
				break;
			case "buttons":
				self._createButtons(value);
				break;
			case "closeText":
				// ensure that we always pass a string
				self.uiDialogTitlebarCloseText.text("" + value);
				break;
			case "dialogClass":
				uiDialog
					.removeClass(self.options.dialogClass)
					.addClass(uiDialogClasses + value);
				break;
			case "disabled":
				if (value) {
					uiDialog.addClass('ui-dialog-disabled');
				} else {
					uiDialog.removeClass('ui-dialog-disabled');
				}
				break;
			case "draggable":
				var isDraggable = uiDialog.is( ":data(draggable)" );
				if ( isDraggable && !value ) {
					uiDialog.draggable( "destroy" );
				}
				
				if ( !isDraggable && value ) {
					self._makeDraggable();
				}
				break;
			case "position":
				self._position(value);
				break;
			case "resizable":
				// currently resizable, becoming non-resizable
				var isResizable = uiDialog.is( ":data(resizable)" );
				if (isResizable && !value) {
					uiDialog.resizable('destroy');
				}

				// currently resizable, changing handles
				if (isResizable && typeof value === 'string') {
					uiDialog.resizable('option', 'handles', value);
				}

				// currently non-resizable, becoming resizable
				if (!isResizable && value !== false) {
					self._makeResizable(value);
				}
				break;
			case "title":
				// convert whatever was passed in o a string, for html() to not throw up
				$(".ui-dialog-title", self.uiDialogTitlebar).html("" + (value || '&#160;'));
				break;
		}

		$.Widget.prototype._setOption.apply(self, arguments);
	},

	_size: function() {
		/* If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
		 * divs will both have width and height set, so we need to reset them
		 */
		var options = this.options,
			nonContentHeight,
			minContentHeight,
			isVisible = this.uiDialog.is( ":visible" );

		// reset content sizing
		this.element.show().css({
			width: 'auto',
			minHeight: 0,
			height: 0
		});

		if (options.minWidth > options.width) {
			options.width = options.minWidth;
		}

		// reset wrapper sizing
		// determine the height of all the non-content elements
		nonContentHeight = this.uiDialog.css({
				height: 'auto',
				width: options.width
			})
			.height();
		minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
		
		if ( options.height === "auto" ) {
			// only needed for IE6 support
			if ( $.support.minHeight ) {
				this.element.css({
					minHeight: minContentHeight,
					height: "auto"
				});
			} else {
				this.uiDialog.show();
				var autoHeight = this.element.css( "height", "auto" ).height();
				if ( !isVisible ) {
					this.uiDialog.hide();
				}
				this.element.height( Math.max( autoHeight, minContentHeight ) );
			}
		} else {
			this.element.height( Math.max( options.height - nonContentHeight, 0 ) );
		}

		if (this.uiDialog.is(':data(resizable)')) {
			this.uiDialog.resizable('option', 'minHeight', this._minHeight());
		}
	}
});

$.extend($.ui.dialog, {
	version: "1.8.11",

	uuid: 0,
	maxZ: 0,

	getTitleId: function($el) {
		var id = $el.attr('id');
		if (!id) {
			this.uuid += 1;
			id = this.uuid;
		}
		return 'ui-dialog-title-' + id;
	},

	overlay: function(dialog) {
		this.$el = $.ui.dialog.overlay.create(dialog);
	}
});

$.extend($.ui.dialog.overlay, {
	instances: [],
	// reuse old instances due to IE memory leak with alpha transparency (see #5185)
	oldInstances: [],
	maxZ: 0,
	events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
		function(event) { return event + '.dialog-overlay'; }).join(' '),
	create: function(dialog) {
		if (this.instances.length === 0) {
			// prevent use of anchors and inputs
			// we use a setTimeout in case the overlay is created from an
			// event that we're going to be cancelling (see #2804)
			setTimeout(function() {
				// handle $(el).dialog().dialog('close') (see #4065)
				if ($.ui.dialog.overlay.instances.length) {
					$(document).bind($.ui.dialog.overlay.events, function(event) {
						// stop events if the z-index of the target is < the z-index of the overlay
						// we cannot return true when we don't want to cancel the event (#3523)
						if ($(event.target).zIndex() < $.ui.dialog.overlay.maxZ) {
							return false;
						}
					});
				}
			}, 1);

			// allow closing by pressing the escape key
			$(document).bind('keydown.dialog-overlay', function(event) {
				if (dialog.options.closeOnEscape && event.keyCode &&
					event.keyCode === $.ui.keyCode.ESCAPE) {
					
					dialog.close(event);
					event.preventDefault();
				}
			});

			// handle window resize
			$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
		}

		var $el = (this.oldInstances.pop() || $('<div></div>').addClass('ui-widget-overlay'))
			.appendTo(document.body)
			.css({
				width: this.width(),
				height: this.height()
			});

		if ($.fn.bgiframe) {
			$el.bgiframe();
		}

		this.instances.push($el);
		return $el;
	},

	destroy: function($el) {
		var indexOf = $.inArray($el, this.instances);
		if (indexOf != -1){
			this.oldInstances.push(this.instances.splice(indexOf, 1)[0]);
		}

		if (this.instances.length === 0) {
			$([document, window]).unbind('.dialog-overlay');
		}

		$el.remove();
		
		// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
		var maxZ = 0;
		$.each(this.instances, function() {
			maxZ = Math.max(maxZ, this.css('z-index'));
		});
		this.maxZ = maxZ;
	},

	height: function() {
		var scrollHeight,
			offsetHeight;
		// handle IE 6
		if ($.browser.msie && $.browser.version < 7) {
			scrollHeight = Math.max(
				document.documentElement.scrollHeight,
				document.body.scrollHeight
			);
			offsetHeight = Math.max(
				document.documentElement.offsetHeight,
				document.body.offsetHeight
			);

			if (scrollHeight < offsetHeight) {
				return $(window).height() + 'px';
			} else {
				return scrollHeight + 'px';
			}
		// handle "good" browsers
		} else {
			return $(document).height() + 'px';
		}
	},

	width: function() {
		var scrollWidth,
			offsetWidth;
		// handle IE 6
		if ($.browser.msie && $.browser.version < 7) {
			scrollWidth = Math.max(
				document.documentElement.scrollWidth,
				document.body.scrollWidth
			);
			offsetWidth = Math.max(
				document.documentElement.offsetWidth,
				document.body.offsetWidth
			);

			if (scrollWidth < offsetWidth) {
				return $(window).width() + 'px';
			} else {
				return scrollWidth + 'px';
			}
		// handle "good" browsers
		} else {
			return $(document).width() + 'px';
		}
	},

	resize: function() {
		/* If the dialog is draggable and the user drags it past the
		 * right edge of the window, the document becomes wider so we
		 * need to stretch the overlay. If the user then drags the
		 * dialog back to the left, the document will become narrower,
		 * so we need to shrink the overlay to the appropriate size.
		 * This is handled by shrinking the overlay before setting it
		 * to the full document size.
		 */
		var $overlays = $([]);
		$.each($.ui.dialog.overlay.instances, function() {
			$overlays = $overlays.add(this);
		});

		$overlays.css({
			width: 0,
			height: 0
		}).css({
			width: $.ui.dialog.overlay.width(),
			height: $.ui.dialog.overlay.height()
		});
	}
});

$.extend($.ui.dialog.overlay.prototype, {
	destroy: function() {
		$.ui.dialog.overlay.destroy(this.$el);
	}
});

}(jQuery));
/*
 * jQuery UI Slider 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Slider
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

// number of pages in a slider
// (how many times can you page up/down to go through the whole range)
var numPages = 5;

$.widget( "ui.slider", $.ui.mouse, {

	widgetEventPrefix: "slide",

	options: {
		animate: false,
		distance: 0,
		max: 100,
		min: 0,
		orientation: "horizontal",
		range: false,
		step: 1,
		value: 0,
		values: null
	},

	_create: function() {
		var self = this,
			o = this.options;

		this._keySliding = false;
		this._mouseSliding = false;
		this._animateOff = true;
		this._handleIndex = null;
		this._detectOrientation();
		this._mouseInit();

		this.element
			.addClass( "ui-slider" +
				" ui-slider-" + this.orientation +
				" ui-widget" +
				" ui-widget-content" +
				" ui-corner-all" );
		
		if ( o.disabled ) {
			this.element.addClass( "ui-slider-disabled ui-disabled" );
		}

		this.range = $([]);

		if ( o.range ) {
			if ( o.range === true ) {
				this.range = $( "<div></div>" );
				if ( !o.values ) {
					o.values = [ this._valueMin(), this._valueMin() ];
				}
				if ( o.values.length && o.values.length !== 2 ) {
					o.values = [ o.values[0], o.values[0] ];
				}
			} else {
				this.range = $( "<div></div>" );
			}

			this.range
				.appendTo( this.element )
				.addClass( "ui-slider-range" );

			if ( o.range === "min" || o.range === "max" ) {
				this.range.addClass( "ui-slider-range-" + o.range );
			}

			// note: this isn't the most fittingly semantic framework class for this element,
			// but worked best visually with a variety of themes
			this.range.addClass( "ui-widget-header" );
		}

		if ( $( ".ui-slider-handle", this.element ).length === 0 ) {
			$( "<a href='#'></a>" )
				.appendTo( this.element )
				.addClass( "ui-slider-handle" );
		}

		if ( o.values && o.values.length ) {
			while ( $(".ui-slider-handle", this.element).length < o.values.length ) {
				$( "<a href='#'></a>" )
					.appendTo( this.element )
					.addClass( "ui-slider-handle" );
			}
		}

		this.handles = $( ".ui-slider-handle", this.element )
			.addClass( "ui-state-default" +
				" ui-corner-all" );

		this.handle = this.handles.eq( 0 );

		this.handles.add( this.range ).filter( "a" )
			.click(function( event ) {
				event.preventDefault();
			})
			.hover(function() {
				if ( !o.disabled ) {
					$( this ).addClass( "ui-state-hover" );
				}
			}, function() {
				$( this ).removeClass( "ui-state-hover" );
			})
			.focus(function() {
				if ( !o.disabled ) {
					$( ".ui-slider .ui-state-focus" ).removeClass( "ui-state-focus" );
					$( this ).addClass( "ui-state-focus" );
				} else {
					$( this ).blur();
				}
			})
			.blur(function() {
				$( this ).removeClass( "ui-state-focus" );
			});

		this.handles.each(function( i ) {
			$( this ).data( "index.ui-slider-handle", i );
		});

		this.handles
			.keydown(function( event ) {
				var ret = true,
					index = $( this ).data( "index.ui-slider-handle" ),
					allowed,
					curVal,
					newVal,
					step;
	
				if ( self.options.disabled ) {
					return;
				}
	
				switch ( event.keyCode ) {
					case $.ui.keyCode.HOME:
					case $.ui.keyCode.END:
					case $.ui.keyCode.PAGE_UP:
					case $.ui.keyCode.PAGE_DOWN:
					case $.ui.keyCode.UP:
					case $.ui.keyCode.RIGHT:
					case $.ui.keyCode.DOWN:
					case $.ui.keyCode.LEFT:
						ret = false;
						if ( !self._keySliding ) {
							self._keySliding = true;
							$( this ).addClass( "ui-state-active" );
							allowed = self._start( event, index );
							if ( allowed === false ) {
								return;
							}
						}
						break;
				}
	
				step = self.options.step;
				if ( self.options.values && self.options.values.length ) {
					curVal = newVal = self.values( index );
				} else {
					curVal = newVal = self.value();
				}
	
				switch ( event.keyCode ) {
					case $.ui.keyCode.HOME:
						newVal = self._valueMin();
						break;
					case $.ui.keyCode.END:
						newVal = self._valueMax();
						break;
					case $.ui.keyCode.PAGE_UP:
						newVal = self._trimAlignValue( curVal + ( (self._valueMax() - self._valueMin()) / numPages ) );
						break;
					case $.ui.keyCode.PAGE_DOWN:
						newVal = self._trimAlignValue( curVal - ( (self._valueMax() - self._valueMin()) / numPages ) );
						break;
					case $.ui.keyCode.UP:
					case $.ui.keyCode.RIGHT:
						if ( curVal === self._valueMax() ) {
							return;
						}
						newVal = self._trimAlignValue( curVal + step );
						break;
					case $.ui.keyCode.DOWN:
					case $.ui.keyCode.LEFT:
						if ( curVal === self._valueMin() ) {
							return;
						}
						newVal = self._trimAlignValue( curVal - step );
						break;
				}
	
				self._slide( event, index, newVal );
	
				return ret;
	
			})
			.keyup(function( event ) {
				var index = $( this ).data( "index.ui-slider-handle" );
	
				if ( self._keySliding ) {
					self._keySliding = false;
					self._stop( event, index );
					self._change( event, index );
					$( this ).removeClass( "ui-state-active" );
				}
	
			});

		this._refreshValue();

		this._animateOff = false;
	},

	destroy: function() {
		this.handles.remove();
		this.range.remove();

		this.element
			.removeClass( "ui-slider" +
				" ui-slider-horizontal" +
				" ui-slider-vertical" +
				" ui-slider-disabled" +
				" ui-widget" +
				" ui-widget-content" +
				" ui-corner-all" )
			.removeData( "slider" )
			.unbind( ".slider" );

		this._mouseDestroy();

		return this;
	},

	_mouseCapture: function( event ) {
		var o = this.options,
			position,
			normValue,
			distance,
			closestHandle,
			self,
			index,
			allowed,
			offset,
			mouseOverHandle;

		if ( o.disabled ) {
			return false;
		}

		this.elementSize = {
			width: this.element.outerWidth(),
			height: this.element.outerHeight()
		};
		this.elementOffset = this.element.offset();

		position = { x: event.pageX, y: event.pageY };
		normValue = this._normValueFromMouse( position );
		distance = this._valueMax() - this._valueMin() + 1;
		self = this;
		this.handles.each(function( i ) {
			var thisDistance = Math.abs( normValue - self.values(i) );
			if ( distance > thisDistance ) {
				distance = thisDistance;
				closestHandle = $( this );
				index = i;
			}
		});

		// workaround for bug #3736 (if both handles of a range are at 0,
		// the first is always used as the one with least distance,
		// and moving it is obviously prevented by preventing negative ranges)
		if( o.range === true && this.values(1) === o.min ) {
			index += 1;
			closestHandle = $( this.handles[index] );
		}

		allowed = this._start( event, index );
		if ( allowed === false ) {
			return false;
		}
		this._mouseSliding = true;

		self._handleIndex = index;

		closestHandle
			.addClass( "ui-state-active" )
			.focus();
		
		offset = closestHandle.offset();
		mouseOverHandle = !$( event.target ).parents().andSelf().is( ".ui-slider-handle" );
		this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
			left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
			top: event.pageY - offset.top -
				( closestHandle.height() / 2 ) -
				( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
				( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
				( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
		};

		if ( !this.handles.hasClass( "ui-state-hover" ) ) {
			this._slide( event, index, normValue );
		}
		this._animateOff = true;
		return true;
	},

	_mouseStart: function( event ) {
		return true;
	},

	_mouseDrag: function( event ) {
		var position = { x: event.pageX, y: event.pageY },
			normValue = this._normValueFromMouse( position );
		
		this._slide( event, this._handleIndex, normValue );

		return false;
	},

	_mouseStop: function( event ) {
		this.handles.removeClass( "ui-state-active" );
		this._mouseSliding = false;

		this._stop( event, this._handleIndex );
		this._change( event, this._handleIndex );

		this._handleIndex = null;
		this._clickOffset = null;
		this._animateOff = false;

		return false;
	},
	
	_detectOrientation: function() {
		this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
	},

	_normValueFromMouse: function( position ) {
		var pixelTotal,
			pixelMouse,
			percentMouse,
			valueTotal,
			valueMouse;

		if ( this.orientation === "horizontal" ) {
			pixelTotal = this.elementSize.width;
			pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
		} else {
			pixelTotal = this.elementSize.height;
			pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
		}

		percentMouse = ( pixelMouse / pixelTotal );
		if ( percentMouse > 1 ) {
			percentMouse = 1;
		}
		if ( percentMouse < 0 ) {
			percentMouse = 0;
		}
		if ( this.orientation === "vertical" ) {
			percentMouse = 1 - percentMouse;
		}

		valueTotal = this._valueMax() - this._valueMin();
		valueMouse = this._valueMin() + percentMouse * valueTotal;

		return this._trimAlignValue( valueMouse );
	},

	_start: function( event, index ) {
		var uiHash = {
			handle: this.handles[ index ],
			value: this.value()
		};
		if ( this.options.values && this.options.values.length ) {
			uiHash.value = this.values( index );
			uiHash.values = this.values();
		}
		return this._trigger( "start", event, uiHash );
	},

	_slide: function( event, index, newVal ) {
		var otherVal,
			newValues,
			allowed;

		if ( this.options.values && this.options.values.length ) {
			otherVal = this.values( index ? 0 : 1 );

			if ( ( this.options.values.length === 2 && this.options.range === true ) && 
					( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
				) {
				newVal = otherVal;
			}

			if ( newVal !== this.values( index ) ) {
				newValues = this.values();
				newValues[ index ] = newVal;
				// A slide can be canceled by returning false from the slide callback
				allowed = this._trigger( "slide", event, {
					handle: this.handles[ index ],
					value: newVal,
					values: newValues
				} );
				otherVal = this.values( index ? 0 : 1 );
				if ( allowed !== false ) {
					this.values( index, newVal, true );
				}
			}
		} else {
			if ( newVal !== this.value() ) {
				// A slide can be canceled by returning false from the slide callback
				allowed = this._trigger( "slide", event, {
					handle: this.handles[ index ],
					value: newVal
				} );
				if ( allowed !== false ) {
					this.value( newVal );
				}
			}
		}
	},

	_stop: function( event, index ) {
		var uiHash = {
			handle: this.handles[ index ],
			value: this.value()
		};
		if ( this.options.values && this.options.values.length ) {
			uiHash.value = this.values( index );
			uiHash.values = this.values();
		}

		this._trigger( "stop", event, uiHash );
	},

	_change: function( event, index ) {
		if ( !this._keySliding && !this._mouseSliding ) {
			var uiHash = {
				handle: this.handles[ index ],
				value: this.value()
			};
			if ( this.options.values && this.options.values.length ) {
				uiHash.value = this.values( index );
				uiHash.values = this.values();
			}

			this._trigger( "change", event, uiHash );
		}
	},

	value: function( newValue ) {
		if ( arguments.length ) {
			this.options.value = this._trimAlignValue( newValue );
			this._refreshValue();
			this._change( null, 0 );
		}

		return this._value();
	},

	values: function( index, newValue ) {
		var vals,
			newValues,
			i;

		if ( arguments.length > 1 ) {
			this.options.values[ index ] = this._trimAlignValue( newValue );
			this._refreshValue();
			this._change( null, index );
		}

		if ( arguments.length ) {
			if ( $.isArray( arguments[ 0 ] ) ) {
				vals = this.options.values;
				newValues = arguments[ 0 ];
				for ( i = 0; i < vals.length; i += 1 ) {
					vals[ i ] = this._trimAlignValue( newValues[ i ] );
					this._change( null, i );
				}
				this._refreshValue();
			} else {
				if ( this.options.values && this.options.values.length ) {
					return this._values( index );
				} else {
					return this.value();
				}
			}
		} else {
			return this._values();
		}
	},

	_setOption: function( key, value ) {
		var i,
			valsLength = 0;

		if ( $.isArray( this.options.values ) ) {
			valsLength = this.options.values.length;
		}

		$.Widget.prototype._setOption.apply( this, arguments );

		switch ( key ) {
			case "disabled":
				if ( value ) {
					this.handles.filter( ".ui-state-focus" ).blur();
					this.handles.removeClass( "ui-state-hover" );
					this.handles.attr( "disabled", "disabled" );
					this.element.addClass( "ui-disabled" );
				} else {
					this.handles.removeAttr( "disabled" );
					this.element.removeClass( "ui-disabled" );
				}
				break;
			case "orientation":
				this._detectOrientation();
				this.element
					.removeClass( "ui-slider-horizontal ui-slider-vertical" )
					.addClass( "ui-slider-" + this.orientation );
				this._refreshValue();
				break;
			case "value":
				this._animateOff = true;
				this._refreshValue();
				this._change( null, 0 );
				this._animateOff = false;
				break;
			case "values":
				this._animateOff = true;
				this._refreshValue();
				for ( i = 0; i < valsLength; i += 1 ) {
					this._change( null, i );
				}
				this._animateOff = false;
				break;
		}
	},

	//internal value getter
	// _value() returns value trimmed by min and max, aligned by step
	_value: function() {
		var val = this.options.value;
		val = this._trimAlignValue( val );

		return val;
	},

	//internal values getter
	// _values() returns array of values trimmed by min and max, aligned by step
	// _values( index ) returns single value trimmed by min and max, aligned by step
	_values: function( index ) {
		var val,
			vals,
			i;

		if ( arguments.length ) {
			val = this.options.values[ index ];
			val = this._trimAlignValue( val );

			return val;
		} else {
			// .slice() creates a copy of the array
			// this copy gets trimmed by min and max and then returned
			vals = this.options.values.slice();
			for ( i = 0; i < vals.length; i+= 1) {
				vals[ i ] = this._trimAlignValue( vals[ i ] );
			}

			return vals;
		}
	},
	
	// returns the step-aligned value that val is closest to, between (inclusive) min and max
	_trimAlignValue: function( val ) {
		if ( val <= this._valueMin() ) {
			return this._valueMin();
		}
		if ( val >= this._valueMax() ) {
			return this._valueMax();
		}
		var step = ( this.options.step > 0 ) ? this.options.step : 1,
			valModStep = (val - this._valueMin()) % step;
			alignValue = val - valModStep;

		if ( Math.abs(valModStep) * 2 >= step ) {
			alignValue += ( valModStep > 0 ) ? step : ( -step );
		}

		// Since JavaScript has problems with large floats, round
		// the final value to 5 digits after the decimal point (see #4124)
		return parseFloat( alignValue.toFixed(5) );
	},

	_valueMin: function() {
		return this.options.min;
	},

	_valueMax: function() {
		return this.options.max;
	},
	
	_refreshValue: function() {
		var oRange = this.options.range,
			o = this.options,
			self = this,
			animate = ( !this._animateOff ) ? o.animate : false,
			valPercent,
			_set = {},
			lastValPercent,
			value,
			valueMin,
			valueMax;

		if ( this.options.values && this.options.values.length ) {
			this.handles.each(function( i, j ) {
				valPercent = ( self.values(i) - self._valueMin() ) / ( self._valueMax() - self._valueMin() ) * 100;
				_set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
				$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
				if ( self.options.range === true ) {
					if ( self.orientation === "horizontal" ) {
						if ( i === 0 ) {
							self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
						}
						if ( i === 1 ) {
							self.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
						}
					} else {
						if ( i === 0 ) {
							self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
						}
						if ( i === 1 ) {
							self.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
						}
					}
				}
				lastValPercent = valPercent;
			});
		} else {
			value = this.value();
			valueMin = this._valueMin();
			valueMax = this._valueMax();
			valPercent = ( valueMax !== valueMin ) ?
					( value - valueMin ) / ( valueMax - valueMin ) * 100 :
					0;
			_set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
			this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );

			if ( oRange === "min" && this.orientation === "horizontal" ) {
				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
			}
			if ( oRange === "max" && this.orientation === "horizontal" ) {
				this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
			}
			if ( oRange === "min" && this.orientation === "vertical" ) {
				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
			}
			if ( oRange === "max" && this.orientation === "vertical" ) {
				this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
			}
		}
	}

});

$.extend( $.ui.slider, {
	version: "1.8.11"
});

}(jQuery));
/*
 * jQuery UI Tabs 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Tabs
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.widget.js
 */
(function( $, undefined ) {

var tabId = 0,
	listId = 0;

function getNextTabId() {
	return ++tabId;
}

function getNextListId() {
	return ++listId;
}

$.widget( "ui.tabs", {
	options: {
		add: null,
		ajaxOptions: null,
		cache: false,
		cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
		collapsible: false,
		disable: null,
		disabled: [],
		enable: null,
		event: "click",
		fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
		idPrefix: "ui-tabs-",
		load: null,
		panelTemplate: "<div></div>",
		remove: null,
		select: null,
		show: null,
		spinner: "<em>Loading&#8230;</em>",
		tabTemplate: "<li><a href='#{href}'><span>#{label}</span></a></li>"
	},

	_create: function() {
		this._tabify( true );
	},

	_setOption: function( key, value ) {
		if ( key == "selected" ) {
			if (this.options.collapsible && value == this.options.selected ) {
				return;
			}
			this.select( value );
		} else {
			this.options[ key ] = value;
			this._tabify();
		}
	},

	_tabId: function( a ) {
		return a.title && a.title.replace( /\s/g, "_" ).replace( /[^\w\u00c0-\uFFFF-]/g, "" ) ||
			this.options.idPrefix + getNextTabId();
	},

	_sanitizeSelector: function( hash ) {
		// we need this because an id may contain a ":"
		return hash.replace( /:/g, "\\:" );
	},

	_cookie: function() {
		var cookie = this.cookie ||
			( this.cookie = this.options.cookie.name || "ui-tabs-" + getNextListId() );
		return $.cookie.apply( null, [ cookie ].concat( $.makeArray( arguments ) ) );
	},

	_ui: function( tab, panel ) {
		return {
			tab: tab,
			panel: panel,
			index: this.anchors.index( tab )
		};
	},

	_cleanup: function() {
		// restore all former loading tabs labels
		this.lis.filter( ".ui-state-processing" )
			.removeClass( "ui-state-processing" )
			.find( "span:data(label.tabs)" )
				.each(function() {
					var el = $( this );
					el.html( el.data( "label.tabs" ) ).removeData( "label.tabs" );
				});
	},

	_tabify: function( init ) {
		var self = this,
			o = this.options,
			fragmentId = /^#.+/; // Safari 2 reports '#' for an empty hash

		this.list = this.element.find( "ol,ul" ).eq( 0 );
		this.lis = $( " > li:has(a[href])", this.list );
		this.anchors = this.lis.map(function() {
			return $( "a", this )[ 0 ];
		});
		this.panels = $( [] );

		this.anchors.each(function( i, a ) {
			var href = $( a ).attr( "href" );
			// For dynamically created HTML that contains a hash as href IE < 8 expands
			// such href to the full page url with hash and then misinterprets tab as ajax.
			// Same consideration applies for an added tab with a fragment identifier
			// since a[href=#fragment-identifier] does unexpectedly not match.
			// Thus normalize href attribute...
			var hrefBase = href.split( "#" )[ 0 ],
				baseEl;
			if ( hrefBase && ( hrefBase === location.toString().split( "#" )[ 0 ] ||
					( baseEl = $( "base" )[ 0 ]) && hrefBase === baseEl.href ) ) {
				href = a.hash;
				a.href = href;
			}

			// inline tab
			if ( fragmentId.test( href ) ) {
				self.panels = self.panels.add( self.element.find( self._sanitizeSelector( href ) ) );
			// remote tab
			// prevent loading the page itself if href is just "#"
			} else if ( href && href !== "#" ) {
				// required for restore on destroy
				$.data( a, "href.tabs", href );

				// TODO until #3808 is fixed strip fragment identifier from url
				// (IE fails to load from such url)
				$.data( a, "load.tabs", href.replace( /#.*$/, "" ) );

				var id = self._tabId( a );
				a.href = "#" + id;
				var $panel = self.element.find( "#" + id );
				if ( !$panel.length ) {
					$panel = $( o.panelTemplate )
						.attr( "id", id )
						.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
						.insertAfter( self.panels[ i - 1 ] || self.list );
					$panel.data( "destroy.tabs", true );
				}
				self.panels = self.panels.add( $panel );
			// invalid tab href
			} else {
				o.disabled.push( i );
			}
		});

		// initialization from scratch
		if ( init ) {
			// attach necessary classes for styling
			this.element.addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" );
			this.list.addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" );
			this.lis.addClass( "ui-state-default ui-corner-top" );
			this.panels.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" );

			// Selected tab
			// use "selected" option or try to retrieve:
			// 1. from fragment identifier in url
			// 2. from cookie
			// 3. from selected class attribute on <li>
			if ( o.selected === undefined ) {
				if ( location.hash ) {
					this.anchors.each(function( i, a ) {
						if ( a.hash == location.hash ) {
							o.selected = i;
							return false;
						}
					});
				}
				if ( typeof o.selected !== "number" && o.cookie ) {
					o.selected = parseInt( self._cookie(), 10 );
				}
				if ( typeof o.selected !== "number" && this.lis.filter( ".ui-tabs-selected" ).length ) {
					o.selected = this.lis.index( this.lis.filter( ".ui-tabs-selected" ) );
				}
				o.selected = o.selected || ( this.lis.length ? 0 : -1 );
			} else if ( o.selected === null ) { // usage of null is deprecated, TODO remove in next release
				o.selected = -1;
			}

			// sanity check - default to first tab...
			o.selected = ( ( o.selected >= 0 && this.anchors[ o.selected ] ) || o.selected < 0 )
				? o.selected
				: 0;

			// Take disabling tabs via class attribute from HTML
			// into account and update option properly.
			// A selected tab cannot become disabled.
			o.disabled = $.unique( o.disabled.concat(
				$.map( this.lis.filter( ".ui-state-disabled" ), function( n, i ) {
					return self.lis.index( n );
				})
			) ).sort();

			if ( $.inArray( o.selected, o.disabled ) != -1 ) {
				o.disabled.splice( $.inArray( o.selected, o.disabled ), 1 );
			}

			// highlight selected tab
			this.panels.addClass( "ui-tabs-hide" );
			this.lis.removeClass( "ui-tabs-selected ui-state-active" );
			// check for length avoids error when initializing empty list
			if ( o.selected >= 0 && this.anchors.length ) {
				self.element.find( self._sanitizeSelector( self.anchors[ o.selected ].hash ) ).removeClass( "ui-tabs-hide" );
				this.lis.eq( o.selected ).addClass( "ui-tabs-selected ui-state-active" );

				// seems to be expected behavior that the show callback is fired
				self.element.queue( "tabs", function() {
					self._trigger( "show", null,
						self._ui( self.anchors[ o.selected ], self.element.find( self._sanitizeSelector( self.anchors[ o.selected ].hash ) )[ 0 ] ) );
				});

				this.load( o.selected );
			}

			// clean up to avoid memory leaks in certain versions of IE 6
			// TODO: namespace this event
			$( window ).bind( "unload", function() {
				self.lis.add( self.anchors ).unbind( ".tabs" );
				self.lis = self.anchors = self.panels = null;
			});
		// update selected after add/remove
		} else {
			o.selected = this.lis.index( this.lis.filter( ".ui-tabs-selected" ) );
		}

		// update collapsible
		// TODO: use .toggleClass()
		this.element[ o.collapsible ? "addClass" : "removeClass" ]( "ui-tabs-collapsible" );

		// set or update cookie after init and add/remove respectively
		if ( o.cookie ) {
			this._cookie( o.selected, o.cookie );
		}

		// disable tabs
		for ( var i = 0, li; ( li = this.lis[ i ] ); i++ ) {
			$( li )[ $.inArray( i, o.disabled ) != -1 &&
				// TODO: use .toggleClass()
				!$( li ).hasClass( "ui-tabs-selected" ) ? "addClass" : "removeClass" ]( "ui-state-disabled" );
		}

		// reset cache if switching from cached to not cached
		if ( o.cache === false ) {
			this.anchors.removeData( "cache.tabs" );
		}

		// remove all handlers before, tabify may run on existing tabs after add or option change
		this.lis.add( this.anchors ).unbind( ".tabs" );

		if ( o.event !== "mouseover" ) {
			var addState = function( state, el ) {
				if ( el.is( ":not(.ui-state-disabled)" ) ) {
					el.addClass( "ui-state-" + state );
				}
			};
			var removeState = function( state, el ) {
				el.removeClass( "ui-state-" + state );
			};
			this.lis.bind( "mouseover.tabs" , function() {
				addState( "hover", $( this ) );
			});
			this.lis.bind( "mouseout.tabs", function() {
				removeState( "hover", $( this ) );
			});
			this.anchors.bind( "focus.tabs", function() {
				addState( "focus", $( this ).closest( "li" ) );
			});
			this.anchors.bind( "blur.tabs", function() {
				removeState( "focus", $( this ).closest( "li" ) );
			});
		}

		// set up animations
		var hideFx, showFx;
		if ( o.fx ) {
			if ( $.isArray( o.fx ) ) {
				hideFx = o.fx[ 0 ];
				showFx = o.fx[ 1 ];
			} else {
				hideFx = showFx = o.fx;
			}
		}

		// Reset certain styles left over from animation
		// and prevent IE's ClearType bug...
		function resetStyle( $el, fx ) {
			$el.css( "display", "" );
			if ( !$.support.opacity && fx.opacity ) {
				$el[ 0 ].style.removeAttribute( "filter" );
			}
		}

		// Show a tab...
		var showTab = showFx
			? function( clicked, $show ) {
				$( clicked ).closest( "li" ).addClass( "ui-tabs-selected ui-state-active" );
				$show.hide().removeClass( "ui-tabs-hide" ) // avoid flicker that way
					.animate( showFx, showFx.duration || "normal", function() {
						resetStyle( $show, showFx );
						self._trigger( "show", null, self._ui( clicked, $show[ 0 ] ) );
					});
			}
			: function( clicked, $show ) {
				$( clicked ).closest( "li" ).addClass( "ui-tabs-selected ui-state-active" );
				$show.removeClass( "ui-tabs-hide" );
				self._trigger( "show", null, self._ui( clicked, $show[ 0 ] ) );
			};

		// Hide a tab, $show is optional...
		var hideTab = hideFx
			? function( clicked, $hide ) {
				$hide.animate( hideFx, hideFx.duration || "normal", function() {
					self.lis.removeClass( "ui-tabs-selected ui-state-active" );
					$hide.addClass( "ui-tabs-hide" );
					resetStyle( $hide, hideFx );
					self.element.dequeue( "tabs" );
				});
			}
			: function( clicked, $hide, $show ) {
				self.lis.removeClass( "ui-tabs-selected ui-state-active" );
				$hide.addClass( "ui-tabs-hide" );
				self.element.dequeue( "tabs" );
			};

		// attach tab event handler, unbind to avoid duplicates from former tabifying...
		this.anchors.bind( o.event + ".tabs", function() {
			var el = this,
				$li = $(el).closest( "li" ),
				$hide = self.panels.filter( ":not(.ui-tabs-hide)" ),
				$show = self.element.find( self._sanitizeSelector( el.hash ) );

			// If tab is already selected and not collapsible or tab disabled or
			// or is already loading or click callback returns false stop here.
			// Check if click handler returns false last so that it is not executed
			// for a disabled or loading tab!
			if ( ( $li.hasClass( "ui-tabs-selected" ) && !o.collapsible) ||
				$li.hasClass( "ui-state-disabled" ) ||
				$li.hasClass( "ui-state-processing" ) ||
				self.panels.filter( ":animated" ).length ||
				self._trigger( "select", null, self._ui( this, $show[ 0 ] ) ) === false ) {
				this.blur();
				return false;
			}

			o.selected = self.anchors.index( this );

			self.abort();

			// if tab may be closed
			if ( o.collapsible ) {
				if ( $li.hasClass( "ui-tabs-selected" ) ) {
					o.selected = -1;

					if ( o.cookie ) {
						self._cookie( o.selected, o.cookie );
					}

					self.element.queue( "tabs", function() {
						hideTab( el, $hide );
					}).dequeue( "tabs" );

					this.blur();
					return false;
				} else if ( !$hide.length ) {
					if ( o.cookie ) {
						self._cookie( o.selected, o.cookie );
					}

					self.element.queue( "tabs", function() {
						showTab( el, $show );
					});

					// TODO make passing in node possible, see also http://dev.jqueryui.com/ticket/3171
					self.load( self.anchors.index( this ) );

					this.blur();
					return false;
				}
			}

			if ( o.cookie ) {
				self._cookie( o.selected, o.cookie );
			}

			// show new tab
			if ( $show.length ) {
				if ( $hide.length ) {
					self.element.queue( "tabs", function() {
						hideTab( el, $hide );
					});
				}
				self.element.queue( "tabs", function() {
					showTab( el, $show );
				});

				self.load( self.anchors.index( this ) );
			} else {
				throw "jQuery UI Tabs: Mismatching fragment identifier.";
			}

			// Prevent IE from keeping other link focussed when using the back button
			// and remove dotted border from clicked link. This is controlled via CSS
			// in modern browsers; blur() removes focus from address bar in Firefox
			// which can become a usability and annoying problem with tabs('rotate').
			if ( $.browser.msie ) {
				this.blur();
			}
		});

		// disable click in any case
		this.anchors.bind( "click.tabs", function(){
			return false;
		});
	},

    _getIndex: function( index ) {
		// meta-function to give users option to provide a href string instead of a numerical index.
		// also sanitizes numerical indexes to valid values.
		if ( typeof index == "string" ) {
			index = this.anchors.index( this.anchors.filter( "[href$=" + index + "]" ) );
		}

		return index;
	},

	destroy: function() {
		var o = this.options;

		this.abort();

		this.element
			.unbind( ".tabs" )
			.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" )
			.removeData( "tabs" );

		this.list.removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" );

		this.anchors.each(function() {
			var href = $.data( this, "href.tabs" );
			if ( href ) {
				this.href = href;
			}
			var $this = $( this ).unbind( ".tabs" );
			$.each( [ "href", "load", "cache" ], function( i, prefix ) {
				$this.removeData( prefix + ".tabs" );
			});
		});

		this.lis.unbind( ".tabs" ).add( this.panels ).each(function() {
			if ( $.data( this, "destroy.tabs" ) ) {
				$( this ).remove();
			} else {
				$( this ).removeClass([
					"ui-state-default",
					"ui-corner-top",
					"ui-tabs-selected",
					"ui-state-active",
					"ui-state-hover",
					"ui-state-focus",
					"ui-state-disabled",
					"ui-tabs-panel",
					"ui-widget-content",
					"ui-corner-bottom",
					"ui-tabs-hide"
				].join( " " ) );
			}
		});

		if ( o.cookie ) {
			this._cookie( null, o.cookie );
		}

		return this;
	},

	add: function( url, label, index ) {
		if ( index === undefined ) {
			index = this.anchors.length;
		}

		var self = this,
			o = this.options,
			$li = $( o.tabTemplate.replace( /#\{href\}/g, url ).replace( /#\{label\}/g, label ) ),
			id = !url.indexOf( "#" ) ? url.replace( "#", "" ) : this._tabId( $( "a", $li )[ 0 ] );

		$li.addClass( "ui-state-default ui-corner-top" ).data( "destroy.tabs", true );

		// try to find an existing element before creating a new one
		var $panel = self.element.find( "#" + id );
		if ( !$panel.length ) {
			$panel = $( o.panelTemplate )
				.attr( "id", id )
				.data( "destroy.tabs", true );
		}
		$panel.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom ui-tabs-hide" );

		if ( index >= this.lis.length ) {
			$li.appendTo( this.list );
			$panel.appendTo( this.list[ 0 ].parentNode );
		} else {
			$li.insertBefore( this.lis[ index ] );
			$panel.insertBefore( this.panels[ index ] );
		}

		o.disabled = $.map( o.disabled, function( n, i ) {
			return n >= index ? ++n : n;
		});

		this._tabify();

		if ( this.anchors.length == 1 ) {
			o.selected = 0;
			$li.addClass( "ui-tabs-selected ui-state-active" );
			$panel.removeClass( "ui-tabs-hide" );
			this.element.queue( "tabs", function() {
				self._trigger( "show", null, self._ui( self.anchors[ 0 ], self.panels[ 0 ] ) );
			});

			this.load( 0 );
		}

		this._trigger( "add", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
		return this;
	},

	remove: function( index ) {
		index = this._getIndex( index );
		var o = this.options,
			$li = this.lis.eq( index ).remove(),
			$panel = this.panels.eq( index ).remove();

		// If selected tab was removed focus tab to the right or
		// in case the last tab was removed the tab to the left.
		if ( $li.hasClass( "ui-tabs-selected" ) && this.anchors.length > 1) {
			this.select( index + ( index + 1 < this.anchors.length ? 1 : -1 ) );
		}

		o.disabled = $.map(
			$.grep( o.disabled, function(n, i) {
				return n != index;
			}),
			function( n, i ) {
				return n >= index ? --n : n;
			});

		this._tabify();

		this._trigger( "remove", null, this._ui( $li.find( "a" )[ 0 ], $panel[ 0 ] ) );
		return this;
	},

	enable: function( index ) {
		index = this._getIndex( index );
		var o = this.options;
		if ( $.inArray( index, o.disabled ) == -1 ) {
			return;
		}

		this.lis.eq( index ).removeClass( "ui-state-disabled" );
		o.disabled = $.grep( o.disabled, function( n, i ) {
			return n != index;
		});

		this._trigger( "enable", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
		return this;
	},

	disable: function( index ) {
		index = this._getIndex( index );
		var self = this, o = this.options;
		// cannot disable already selected tab
		if ( index != o.selected ) {
			this.lis.eq( index ).addClass( "ui-state-disabled" );

			o.disabled.push( index );
			o.disabled.sort();

			this._trigger( "disable", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
		}

		return this;
	},

	select: function( index ) {
		index = this._getIndex( index );
		if ( index == -1 ) {
			if ( this.options.collapsible && this.options.selected != -1 ) {
				index = this.options.selected;
			} else {
				return this;
			}
		}
		this.anchors.eq( index ).trigger( this.options.event + ".tabs" );
		return this;
	},

	load: function( index ) {
		index = this._getIndex( index );
		var self = this,
			o = this.options,
			a = this.anchors.eq( index )[ 0 ],
			url = $.data( a, "load.tabs" );

		this.abort();

		// not remote or from cache
		if ( !url || this.element.queue( "tabs" ).length !== 0 && $.data( a, "cache.tabs" ) ) {
			this.element.dequeue( "tabs" );
			return;
		}

		// load remote from here on
		this.lis.eq( index ).addClass( "ui-state-processing" );

		if ( o.spinner ) {
			var span = $( "span", a );
			span.data( "label.tabs", span.html() ).html( o.spinner );
		}

		this.xhr = $.ajax( $.extend( {}, o.ajaxOptions, {
			url: url,
			success: function( r, s ) {
				self.element.find( self._sanitizeSelector( a.hash ) ).html( r );

				// take care of tab labels
				self._cleanup();

				if ( o.cache ) {
					$.data( a, "cache.tabs", true );
				}

				self._trigger( "load", null, self._ui( self.anchors[ index ], self.panels[ index ] ) );
				try {
					o.ajaxOptions.success( r, s );
				}
				catch ( e ) {}
			},
			error: function( xhr, s, e ) {
				// take care of tab labels
				self._cleanup();

				self._trigger( "load", null, self._ui( self.anchors[ index ], self.panels[ index ] ) );
				try {
					// Passing index avoid a race condition when this method is
					// called after the user has selected another tab.
					// Pass the anchor that initiated this request allows
					// loadError to manipulate the tab content panel via $(a.hash)
					o.ajaxOptions.error( xhr, s, index, a );
				}
				catch ( e ) {}
			}
		} ) );

		// last, so that load event is fired before show...
		self.element.dequeue( "tabs" );

		return this;
	},

	abort: function() {
		// stop possibly running animations
		this.element.queue( [] );
		this.panels.stop( false, true );

		// "tabs" queue must not contain more than two elements,
		// which are the callbacks for the latest clicked tab...
		this.element.queue( "tabs", this.element.queue( "tabs" ).splice( -2, 2 ) );

		// terminate pending requests from other tabs
		if ( this.xhr ) {
			this.xhr.abort();
			delete this.xhr;
		}

		// take care of tab labels
		this._cleanup();
		return this;
	},

	url: function( index, url ) {
		this.anchors.eq( index ).removeData( "cache.tabs" ).data( "load.tabs", url );
		return this;
	},

	length: function() {
		return this.anchors.length;
	}
});

$.extend( $.ui.tabs, {
	version: "1.8.11"
});

/*
 * Tabs Extensions
 */

/*
 * Rotate
 */
$.extend( $.ui.tabs.prototype, {
	rotation: null,
	rotate: function( ms, continuing ) {
		var self = this,
			o = this.options;

		var rotate = self._rotate || ( self._rotate = function( e ) {
			clearTimeout( self.rotation );
			self.rotation = setTimeout(function() {
				var t = o.selected;
				self.select( ++t < self.anchors.length ? t : 0 );
			}, ms );
			
			if ( e ) {
				e.stopPropagation();
			}
		});

		var stop = self._unrotate || ( self._unrotate = !continuing
			? function(e) {
				if (e.clientX) { // in case of a true click
					self.rotate(null);
				}
			}
			: function( e ) {
				t = o.selected;
				rotate();
			});

		// start rotation
		if ( ms ) {
			this.element.bind( "tabsshow", rotate );
			this.anchors.bind( o.event + ".tabs", stop );
			rotate();
		// stop rotation
		} else {
			clearTimeout( self.rotation );
			this.element.unbind( "tabsshow", rotate );
			this.anchors.unbind( o.event + ".tabs", stop );
			delete this._rotate;
			delete this._unrotate;
		}

		return this;
	}
});

})( jQuery );
/*
 * jQuery UI Datepicker 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Datepicker
 *
 * Depends:
 *	jquery.ui.core.js
 */
(function( $, undefined ) {

$.extend($.ui, { datepicker: { version: "1.8.11" } });

var PROP_NAME = 'datepicker';
var dpuuid = new Date().getTime();

/* Date picker manager.
   Use the singleton instance of this class, $.datepicker, to interact with the date picker.
   Settings for (groups of) date pickers are maintained in an instance object,
   allowing multiple different settings on the same page. */

function Datepicker() {
	this.debug = false; // Change this to true to start debugging
	this._curInst = null; // The current instance in use
	this._keyEvent = false; // If the last event was a key event
	this._disabledInputs = []; // List of date picker inputs that have been disabled
	this._datepickerShowing = false; // True if the popup picker is showing , false if not
	this._inDialog = false; // True if showing within a "dialog", false if not
	this._mainDivId = 'ui-datepicker-div'; // The ID of the main datepicker division
	this._inlineClass = 'ui-datepicker-inline'; // The name of the inline marker class
	this._appendClass = 'ui-datepicker-append'; // The name of the append marker class
	this._triggerClass = 'ui-datepicker-trigger'; // The name of the trigger marker class
	this._dialogClass = 'ui-datepicker-dialog'; // The name of the dialog marker class
	this._disableClass = 'ui-datepicker-disabled'; // The name of the disabled covering marker class
	this._unselectableClass = 'ui-datepicker-unselectable'; // The name of the unselectable cell marker class
	this._currentClass = 'ui-datepicker-current-day'; // The name of the current day marker class
	this._dayOverClass = 'ui-datepicker-days-cell-over'; // The name of the day hover marker class
	this.regional = []; // Available regional settings, indexed by language code
	this.regional[''] = { // Default regional settings
		closeText: 'Done', // Display text for close link
		prevText: 'Prev', // Display text for previous month link
		nextText: 'Next', // Display text for next month link
		currentText: 'Today', // Display text for current month link
		monthNames: ['January','February','March','April','May','June',
			'July','August','September','October','November','December'], // Names of months for drop-down and formatting
		monthNamesShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], // For formatting
		dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], // For formatting
		dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], // For formatting
		dayNamesMin: ['Su','Mo','Tu','We','Th','Fr','Sa'], // Column headings for days starting at Sunday
		weekHeader: 'Wk', // Column header for week of the year
		dateFormat: 'mm/dd/yy', // See format options on parseDate
		firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
		isRTL: false, // True if right-to-left language, false if left-to-right
		showMonthAfterYear: false, // True if the year select precedes month, false for month then year
		yearSuffix: '' // Additional text to append to the year in the month headers
	};
	this._defaults = { // Global defaults for all the date picker instances
		showOn: 'focus', // 'focus' for popup on focus,
			// 'button' for trigger button, or 'both' for either
		showAnim: 'fadeIn', // Name of jQuery animation for popup
		showOptions: {}, // Options for enhanced animations
		defaultDate: null, // Used when field is blank: actual date,
			// +/-number for offset from today, null for today
		appendText: '', // Display text following the input box, e.g. showing the format
		buttonText: '...', // Text for trigger button
		buttonImage: '', // URL for trigger button image
		buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
		hideIfNoPrevNext: false, // True to hide next/previous month links
			// if not applicable, false to just disable them
		navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
		gotoCurrent: false, // True if today link goes back to current selection instead
		changeMonth: false, // True if month can be selected directly, false if only prev/next
		changeYear: false, // True if year can be selected directly, false if only prev/next
		yearRange: 'c-10:c+10', // Range of years to display in drop-down,
			// either relative to today's year (-nn:+nn), relative to currently displayed year
			// (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
		showOtherMonths: false, // True to show dates in other months, false to leave blank
		selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
		showWeek: false, // True to show week of the year, false to not show it
		calculateWeek: this.iso8601Week, // How to calculate the week of the year,
			// takes a Date and returns the number of the week for it
		shortYearCutoff: '+10', // Short year values < this are in the current century,
			// > this are in the previous century,
			// string value starting with '+' for current year + value
		minDate: null, // The earliest selectable date, or null for no limit
		maxDate: null, // The latest selectable date, or null for no limit
		duration: 'fast', // Duration of display/closure
		beforeShowDay: null, // Function that takes a date and returns an array with
			// [0] = true if selectable, false if not, [1] = custom CSS class name(s) or '',
			// [2] = cell title (optional), e.g. $.datepicker.noWeekends
		beforeShow: null, // Function that takes an input field and
			// returns a set of custom settings for the date picker
		onSelect: null, // Define a callback function when a date is selected
		onChangeMonthYear: null, // Define a callback function when the month or year is changed
		onClose: null, // Define a callback function when the datepicker is closed
		numberOfMonths: 1, // Number of months to show at a time
		showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
		stepMonths: 1, // Number of months to step back/forward
		stepBigMonths: 12, // Number of months to step back/forward for the big links
		altField: '', // Selector for an alternate field to store selected dates into
		altFormat: '', // The date format to use for the alternate field
		constrainInput: true, // The input is constrained by the current date format
		showButtonPanel: false, // True to show button panel, false to not show it
		autoSize: false // True to size the input for the date format, false to leave as is
	};
	$.extend(this._defaults, this.regional['']);
	this.dpDiv = $('<div id="' + this._mainDivId + '" class="ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>');
}

$.extend(Datepicker.prototype, {
	/* Class name added to elements to indicate already configured with a date picker. */
	markerClassName: 'hasDatepicker',

	/* Debug logging (if enabled). */
	log: function () {
		if (this.debug)
			console.log.apply('', arguments);
	},
	
	// TODO rename to "widget" when switching to widget factory
	_widgetDatepicker: function() {
		return this.dpDiv;
	},

	/* Override the default settings for all instances of the date picker.
	   @param  settings  object - the new settings to use as defaults (anonymous object)
	   @return the manager object */
	setDefaults: function(settings) {
		extendRemove(this._defaults, settings || {});
		return this;
	},

	/* Attach the date picker to a jQuery selection.
	   @param  target    element - the target input field or division or span
	   @param  settings  object - the new settings to use for this date picker instance (anonymous) */
	_attachDatepicker: function(target, settings) {
		// check for settings on the control itself - in namespace 'date:'
		var inlineSettings = null;
		for (var attrName in this._defaults) {
			var attrValue = target.getAttribute('date:' + attrName);
			if (attrValue) {
				inlineSettings = inlineSettings || {};
				try {
					inlineSettings[attrName] = eval(attrValue);
				} catch (err) {
					inlineSettings[attrName] = attrValue;
				}
			}
		}
		var nodeName = target.nodeName.toLowerCase();
		var inline = (nodeName == 'div' || nodeName == 'span');
		if (!target.id) {
			this.uuid += 1;
			target.id = 'dp' + this.uuid;
		}
		var inst = this._newInst($(target), inline);
		inst.settings = $.extend({}, settings || {}, inlineSettings || {});
		if (nodeName == 'input') {
			this._connectDatepicker(target, inst);
		} else if (inline) {
			this._inlineDatepicker(target, inst);
		}
	},

	/* Create a new instance object. */
	_newInst: function(target, inline) {
		var id = target[0].id.replace(/([^A-Za-z0-9_-])/g, '\\\\$1'); // escape jQuery meta chars
		return {id: id, input: target, // associated target
			selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
			drawMonth: 0, drawYear: 0, // month being drawn
			inline: inline, // is datepicker inline or not
			dpDiv: (!inline ? this.dpDiv : // presentation div
			$('<div class="' + this._inlineClass + ' ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>'))};
	},

	/* Attach the date picker to an input field. */
	_connectDatepicker: function(target, inst) {
		var input = $(target);
		inst.append = $([]);
		inst.trigger = $([]);
		if (input.hasClass(this.markerClassName))
			return;
		this._attachments(input, inst);
		input.addClass(this.markerClassName).keydown(this._doKeyDown).
			keypress(this._doKeyPress).keyup(this._doKeyUp).
			bind("setData.datepicker", function(event, key, value) {
				inst.settings[key] = value;
			}).bind("getData.datepicker", function(event, key) {
				return this._get(inst, key);
			});
		this._autoSize(inst);
		$.data(target, PROP_NAME, inst);
	},

	/* Make attachments based on settings. */
	_attachments: function(input, inst) {
		var appendText = this._get(inst, 'appendText');
		var isRTL = this._get(inst, 'isRTL');
		if (inst.append)
			inst.append.remove();
		if (appendText) {
			inst.append = $('<span class="' + this._appendClass + '">' + appendText + '</span>');
			input[isRTL ? 'before' : 'after'](inst.append);
		}
		input.unbind('focus', this._showDatepicker);
		if (inst.trigger)
			inst.trigger.remove();
		var showOn = this._get(inst, 'showOn');
		if (showOn == 'focus' || showOn == 'both') // pop-up date picker when in the marked field
			input.focus(this._showDatepicker);
		if (showOn == 'button' || showOn == 'both') { // pop-up date picker when button clicked
			var buttonText = this._get(inst, 'buttonText');
			var buttonImage = this._get(inst, 'buttonImage');
			inst.trigger = $(this._get(inst, 'buttonImageOnly') ?
				$('<img/>').addClass(this._triggerClass).
					attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
				$('<button type="button"></button>').addClass(this._triggerClass).
					html(buttonImage == '' ? buttonText : $('<img/>').attr(
					{ src:buttonImage, alt:buttonText, title:buttonText })));
			input[isRTL ? 'before' : 'after'](inst.trigger);
			inst.trigger.click(function() {
				if ($.datepicker._datepickerShowing && $.datepicker._lastInput == input[0])
					$.datepicker._hideDatepicker();
				else
					$.datepicker._showDatepicker(input[0]);
				return false;
			});
		}
	},

	/* Apply the maximum length for the date format. */
	_autoSize: function(inst) {
		if (this._get(inst, 'autoSize') && !inst.inline) {
			var date = new Date(2009, 12 - 1, 20); // Ensure double digits
			var dateFormat = this._get(inst, 'dateFormat');
			if (dateFormat.match(/[DM]/)) {
				var findMax = function(names) {
					var max = 0;
					var maxI = 0;
					for (var i = 0; i < names.length; i++) {
						if (names[i].length > max) {
							max = names[i].length;
							maxI = i;
						}
					}
					return maxI;
				};
				date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
					'monthNames' : 'monthNamesShort'))));
				date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
					'dayNames' : 'dayNamesShort'))) + 20 - date.getDay());
			}
			inst.input.attr('size', this._formatDate(inst, date).length);
		}
	},

	/* Attach an inline date picker to a div. */
	_inlineDatepicker: function(target, inst) {
		var divSpan = $(target);
		if (divSpan.hasClass(this.markerClassName))
			return;
		divSpan.addClass(this.markerClassName).append(inst.dpDiv).
			bind("setData.datepicker", function(event, key, value){
				inst.settings[key] = value;
			}).bind("getData.datepicker", function(event, key){
				return this._get(inst, key);
			});
		$.data(target, PROP_NAME, inst);
		this._setDate(inst, this._getDefaultDate(inst), true);
		this._updateDatepicker(inst);
		this._updateAlternate(inst);
		inst.dpDiv.show();
	},

	/* Pop-up the date picker in a "dialog" box.
	   @param  input     element - ignored
	   @param  date      string or Date - the initial date to display
	   @param  onSelect  function - the function to call when a date is selected
	   @param  settings  object - update the dialog date picker instance's settings (anonymous object)
	   @param  pos       int[2] - coordinates for the dialog's position within the screen or
	                     event - with x/y coordinates or
	                     leave empty for default (screen centre)
	   @return the manager object */
	_dialogDatepicker: function(input, date, onSelect, settings, pos) {
		var inst = this._dialogInst; // internal instance
		if (!inst) {
			this.uuid += 1;
			var id = 'dp' + this.uuid;
			this._dialogInput = $('<input type="text" id="' + id +
				'" style="position: absolute; top: -100px; width: 0px; z-index: -10;"/>');
			this._dialogInput.keydown(this._doKeyDown);
			$('body').append(this._dialogInput);
			inst = this._dialogInst = this._newInst(this._dialogInput, false);
			inst.settings = {};
			$.data(this._dialogInput[0], PROP_NAME, inst);
		}
		extendRemove(inst.settings, settings || {});
		date = (date && date.constructor == Date ? this._formatDate(inst, date) : date);
		this._dialogInput.val(date);

		this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
		if (!this._pos) {
			var browserWidth = document.documentElement.clientWidth;
			var browserHeight = document.documentElement.clientHeight;
			var scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
			var scrollY = document.documentElement.scrollTop || document.body.scrollTop;
			this._pos = // should use actual width/height below
				[(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
		}

		// move input on screen for focus, but hidden behind dialog
		this._dialogInput.css('left', (this._pos[0] + 20) + 'px').css('top', this._pos[1] + 'px');
		inst.settings.onSelect = onSelect;
		this._inDialog = true;
		this.dpDiv.addClass(this._dialogClass);
		this._showDatepicker(this._dialogInput[0]);
		if ($.blockUI)
			$.blockUI(this.dpDiv);
		$.data(this._dialogInput[0], PROP_NAME, inst);
		return this;
	},

	/* Detach a datepicker from its control.
	   @param  target    element - the target input field or division or span */
	_destroyDatepicker: function(target) {
		var $target = $(target);
		var inst = $.data(target, PROP_NAME);
		if (!$target.hasClass(this.markerClassName)) {
			return;
		}
		var nodeName = target.nodeName.toLowerCase();
		$.removeData(target, PROP_NAME);
		if (nodeName == 'input') {
			inst.append.remove();
			inst.trigger.remove();
			$target.removeClass(this.markerClassName).
				unbind('focus', this._showDatepicker).
				unbind('keydown', this._doKeyDown).
				unbind('keypress', this._doKeyPress).
				unbind('keyup', this._doKeyUp);
		} else if (nodeName == 'div' || nodeName == 'span')
			$target.removeClass(this.markerClassName).empty();
	},

	/* Enable the date picker to a jQuery selection.
	   @param  target    element - the target input field or division or span */
	_enableDatepicker: function(target) {
		var $target = $(target);
		var inst = $.data(target, PROP_NAME);
		if (!$target.hasClass(this.markerClassName)) {
			return;
		}
		var nodeName = target.nodeName.toLowerCase();
		if (nodeName == 'input') {
			target.disabled = false;
			inst.trigger.filter('button').
				each(function() { this.disabled = false; }).end().
				filter('img').css({opacity: '1.0', cursor: ''});
		}
		else if (nodeName == 'div' || nodeName == 'span') {
			var inline = $target.children('.' + this._inlineClass);
			inline.children().removeClass('ui-state-disabled');
		}
		this._disabledInputs = $.map(this._disabledInputs,
			function(value) { return (value == target ? null : value); }); // delete entry
	},

	/* Disable the date picker to a jQuery selection.
	   @param  target    element - the target input field or division or span */
	_disableDatepicker: function(target) {
		var $target = $(target);
		var inst = $.data(target, PROP_NAME);
		if (!$target.hasClass(this.markerClassName)) {
			return;
		}
		var nodeName = target.nodeName.toLowerCase();
		if (nodeName == 'input') {
			target.disabled = true;
			inst.trigger.filter('button').
				each(function() { this.disabled = true; }).end().
				filter('img').css({opacity: '0.5', cursor: 'default'});
		}
		else if (nodeName == 'div' || nodeName == 'span') {
			var inline = $target.children('.' + this._inlineClass);
			inline.children().addClass('ui-state-disabled');
		}
		this._disabledInputs = $.map(this._disabledInputs,
			function(value) { return (value == target ? null : value); }); // delete entry
		this._disabledInputs[this._disabledInputs.length] = target;
	},

	/* Is the first field in a jQuery collection disabled as a datepicker?
	   @param  target    element - the target input field or division or span
	   @return boolean - true if disabled, false if enabled */
	_isDisabledDatepicker: function(target) {
		if (!target) {
			return false;
		}
		for (var i = 0; i < this._disabledInputs.length; i++) {
			if (this._disabledInputs[i] == target)
				return true;
		}
		return false;
	},

	/* Retrieve the instance data for the target control.
	   @param  target  element - the target input field or division or span
	   @return  object - the associated instance data
	   @throws  error if a jQuery problem getting data */
	_getInst: function(target) {
		try {
			return $.data(target, PROP_NAME);
		}
		catch (err) {
			throw 'Missing instance data for this datepicker';
		}
	},

	/* Update or retrieve the settings for a date picker attached to an input field or division.
	   @param  target  element - the target input field or division or span
	   @param  name    object - the new settings to update or
	                   string - the name of the setting to change or retrieve,
	                   when retrieving also 'all' for all instance settings or
	                   'defaults' for all global defaults
	   @param  value   any - the new value for the setting
	                   (omit if above is an object or to retrieve a value) */
	_optionDatepicker: function(target, name, value) {
		var inst = this._getInst(target);
		if (arguments.length == 2 && typeof name == 'string') {
			return (name == 'defaults' ? $.extend({}, $.datepicker._defaults) :
				(inst ? (name == 'all' ? $.extend({}, inst.settings) :
				this._get(inst, name)) : null));
		}
		var settings = name || {};
		if (typeof name == 'string') {
			settings = {};
			settings[name] = value;
		}
		if (inst) {
			if (this._curInst == inst) {
				this._hideDatepicker();
			}
			var date = this._getDateDatepicker(target, true);
			var minDate = this._getMinMaxDate(inst, 'min');
			var maxDate = this._getMinMaxDate(inst, 'max');
			extendRemove(inst.settings, settings);
			// reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
			if (minDate !== null && settings['dateFormat'] !== undefined && settings['minDate'] === undefined)
				inst.settings.minDate = this._formatDate(inst, minDate);
			if (maxDate !== null && settings['dateFormat'] !== undefined && settings['maxDate'] === undefined)
				inst.settings.maxDate = this._formatDate(inst, maxDate);
			this._attachments($(target), inst);
			this._autoSize(inst);
			this._setDateDatepicker(target, date);
			this._updateDatepicker(inst);
		}
	},

	// change method deprecated
	_changeDatepicker: function(target, name, value) {
		this._optionDatepicker(target, name, value);
	},

	/* Redraw the date picker attached to an input field or division.
	   @param  target  element - the target input field or division or span */
	_refreshDatepicker: function(target) {
		var inst = this._getInst(target);
		if (inst) {
			this._updateDatepicker(inst);
		}
	},

	/* Set the dates for a jQuery selection.
	   @param  target   element - the target input field or division or span
	   @param  date     Date - the new date */
	_setDateDatepicker: function(target, date) {
		var inst = this._getInst(target);
		if (inst) {
			this._setDate(inst, date);
			this._updateDatepicker(inst);
			this._updateAlternate(inst);
		}
	},

	/* Get the date(s) for the first entry in a jQuery selection.
	   @param  target     element - the target input field or division or span
	   @param  noDefault  boolean - true if no default date is to be used
	   @return Date - the current date */
	_getDateDatepicker: function(target, noDefault) {
		var inst = this._getInst(target);
		if (inst && !inst.inline)
			this._setDateFromField(inst, noDefault);
		return (inst ? this._getDate(inst) : null);
	},

	/* Handle keystrokes. */
	_doKeyDown: function(event) {
		var inst = $.datepicker._getInst(event.target);
		var handled = true;
		var isRTL = inst.dpDiv.is('.ui-datepicker-rtl');
		inst._keyEvent = true;
		if ($.datepicker._datepickerShowing)
			switch (event.keyCode) {
				case 9: $.datepicker._hideDatepicker();
						handled = false;
						break; // hide on tab out
				case 13: var sel = $('td.' + $.datepicker._dayOverClass + ':not(.' + 
									$.datepicker._currentClass + ')', inst.dpDiv);
						if (sel[0])
							$.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
						else
							$.datepicker._hideDatepicker();
						return false; // don't submit the form
						break; // select the value on enter
				case 27: $.datepicker._hideDatepicker();
						break; // hide on escape
				case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
							-$.datepicker._get(inst, 'stepBigMonths') :
							-$.datepicker._get(inst, 'stepMonths')), 'M');
						break; // previous month/year on page up/+ ctrl
				case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
							+$.datepicker._get(inst, 'stepBigMonths') :
							+$.datepicker._get(inst, 'stepMonths')), 'M');
						break; // next month/year on page down/+ ctrl
				case 35: if (event.ctrlKey || event.metaKey) $.datepicker._clearDate(event.target);
						handled = event.ctrlKey || event.metaKey;
						break; // clear on ctrl or command +end
				case 36: if (event.ctrlKey || event.metaKey) $.datepicker._gotoToday(event.target);
						handled = event.ctrlKey || event.metaKey;
						break; // current on ctrl or command +home
				case 37: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), 'D');
						handled = event.ctrlKey || event.metaKey;
						// -1 day on ctrl or command +left
						if (event.originalEvent.altKey) $.datepicker._adjustDate(event.target, (event.ctrlKey ?
									-$.datepicker._get(inst, 'stepBigMonths') :
									-$.datepicker._get(inst, 'stepMonths')), 'M');
						// next month/year on alt +left on Mac
						break;
				case 38: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, -7, 'D');
						handled = event.ctrlKey || event.metaKey;
						break; // -1 week on ctrl or command +up
				case 39: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), 'D');
						handled = event.ctrlKey || event.metaKey;
						// +1 day on ctrl or command +right
						if (event.originalEvent.altKey) $.datepicker._adjustDate(event.target, (event.ctrlKey ?
									+$.datepicker._get(inst, 'stepBigMonths') :
									+$.datepicker._get(inst, 'stepMonths')), 'M');
						// next month/year on alt +right
						break;
				case 40: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, +7, 'D');
						handled = event.ctrlKey || event.metaKey;
						break; // +1 week on ctrl or command +down
				default: handled = false;
			}
		else if (event.keyCode == 36 && event.ctrlKey) // display the date picker on ctrl+home
			$.datepicker._showDatepicker(this);
		else {
			handled = false;
		}
		if (handled) {
			event.preventDefault();
			event.stopPropagation();
		}
	},

	/* Filter entered characters - based on date format. */
	_doKeyPress: function(event) {
		var inst = $.datepicker._getInst(event.target);
		if ($.datepicker._get(inst, 'constrainInput')) {
			var chars = $.datepicker._possibleChars($.datepicker._get(inst, 'dateFormat'));
			var chr = String.fromCharCode(event.charCode == undefined ? event.keyCode : event.charCode);
			return event.ctrlKey || event.metaKey || (chr < ' ' || !chars || chars.indexOf(chr) > -1);
		}
	},

	/* Synchronise manual entry and field/alternate field. */
	_doKeyUp: function(event) {
		var inst = $.datepicker._getInst(event.target);
		if (inst.input.val() != inst.lastVal) {
			try {
				var date = $.datepicker.parseDate($.datepicker._get(inst, 'dateFormat'),
					(inst.input ? inst.input.val() : null),
					$.datepicker._getFormatConfig(inst));
				if (date) { // only if valid
					$.datepicker._setDateFromField(inst);
					$.datepicker._updateAlternate(inst);
					$.datepicker._updateDatepicker(inst);
				}
			}
			catch (event) {
				$.datepicker.log(event);
			}
		}
		return true;
	},

	/* Pop-up the date picker for a given input field.
	   @param  input  element - the input field attached to the date picker or
	                  event - if triggered by focus */
	_showDatepicker: function(input) {
		input = input.target || input;
		if (input.nodeName.toLowerCase() != 'input') // find from button/image trigger
			input = $('input', input.parentNode)[0];
		if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput == input) // already here
			return;
		var inst = $.datepicker._getInst(input);
		if ($.datepicker._curInst && $.datepicker._curInst != inst) {
			$.datepicker._curInst.dpDiv.stop(true, true);
		}
		var beforeShow = $.datepicker._get(inst, 'beforeShow');
		extendRemove(inst.settings, (beforeShow ? beforeShow.apply(input, [input, inst]) : {}));
		inst.lastVal = null;
		$.datepicker._lastInput = input;
		$.datepicker._setDateFromField(inst);
		if ($.datepicker._inDialog) // hide cursor
			input.value = '';
		if (!$.datepicker._pos) { // position below input
			$.datepicker._pos = $.datepicker._findPos(input);
			$.datepicker._pos[1] += input.offsetHeight; // add the height
		}
		var isFixed = false;
		$(input).parents().each(function() {
			isFixed |= $(this).css('position') == 'fixed';
			return !isFixed;
		});
		if (isFixed && $.browser.opera) { // correction for Opera when fixed and scrolled
			$.datepicker._pos[0] -= document.documentElement.scrollLeft;
			$.datepicker._pos[1] -= document.documentElement.scrollTop;
		}
		var offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
		$.datepicker._pos = null;
		//to avoid flashes on Firefox
		inst.dpDiv.empty();
		// determine sizing offscreen
		inst.dpDiv.css({position: 'absolute', display: 'block', top: '-1000px'});
		$.datepicker._updateDatepicker(inst);
		// fix width for dynamic number of date pickers
		// and adjust position before showing
		offset = $.datepicker._checkOffset(inst, offset, isFixed);
		inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
			'static' : (isFixed ? 'fixed' : 'absolute')), display: 'none',
			left: offset.left + 'px', top: offset.top + 'px'});
		if (!inst.inline) {
			var showAnim = $.datepicker._get(inst, 'showAnim');
			var duration = $.datepicker._get(inst, 'duration');
			var postProcess = function() {
				$.datepicker._datepickerShowing = true;
				var cover = inst.dpDiv.find('iframe.ui-datepicker-cover'); // IE6- only
				if( !! cover.length ){
					var borders = $.datepicker._getBorders(inst.dpDiv);
					cover.css({left: -borders[0], top: -borders[1],
						width: inst.dpDiv.outerWidth(), height: inst.dpDiv.outerHeight()});
				}
			};
			inst.dpDiv.zIndex($(input).zIndex()+1);
			if ($.effects && $.effects[showAnim])
				inst.dpDiv.show(showAnim, $.datepicker._get(inst, 'showOptions'), duration, postProcess);
			else
				inst.dpDiv[showAnim || 'show']((showAnim ? duration : null), postProcess);
			if (!showAnim || !duration)
				postProcess();
			if (inst.input.is(':visible') && !inst.input.is(':disabled'))
				inst.input.focus();
			$.datepicker._curInst = inst;
		}
	},

	/* Generate the date picker content. */
	_updateDatepicker: function(inst) {
		var self = this;
		var borders = $.datepicker._getBorders(inst.dpDiv);
		inst.dpDiv.empty().append(this._generateHTML(inst));
		var cover = inst.dpDiv.find('iframe.ui-datepicker-cover'); // IE6- only
		if( !!cover.length ){ //avoid call to outerXXXX() when not in IE6
			cover.css({left: -borders[0], top: -borders[1], width: inst.dpDiv.outerWidth(), height: inst.dpDiv.outerHeight()})
		}
		inst.dpDiv.find('button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a')
				.bind('mouseout', function(){
					$(this).removeClass('ui-state-hover');
					if(this.className.indexOf('ui-datepicker-prev') != -1) $(this).removeClass('ui-datepicker-prev-hover');
					if(this.className.indexOf('ui-datepicker-next') != -1) $(this).removeClass('ui-datepicker-next-hover');
				})
				.bind('mouseover', function(){
					if (!self._isDisabledDatepicker( inst.inline ? inst.dpDiv.parent()[0] : inst.input[0])) {
						$(this).parents('.ui-datepicker-calendar').find('a').removeClass('ui-state-hover');
						$(this).addClass('ui-state-hover');
						if(this.className.indexOf('ui-datepicker-prev') != -1) $(this).addClass('ui-datepicker-prev-hover');
						if(this.className.indexOf('ui-datepicker-next') != -1) $(this).addClass('ui-datepicker-next-hover');
					}
				})
			.end()
			.find('.' + this._dayOverClass + ' a')
				.trigger('mouseover')
			.end();
		var numMonths = this._getNumberOfMonths(inst);
		var cols = numMonths[1];
		var width = 17;
		if (cols > 1)
			inst.dpDiv.addClass('ui-datepicker-multi-' + cols).css('width', (width * cols) + 'em');
		else
			inst.dpDiv.removeClass('ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4').width('');
		inst.dpDiv[(numMonths[0] != 1 || numMonths[1] != 1 ? 'add' : 'remove') +
			'Class']('ui-datepicker-multi');
		inst.dpDiv[(this._get(inst, 'isRTL') ? 'add' : 'remove') +
			'Class']('ui-datepicker-rtl');
		if (inst == $.datepicker._curInst && $.datepicker._datepickerShowing && inst.input &&
				// #6694 - don't focus the input if it's already focused
				// this breaks the change event in IE
				inst.input.is(':visible') && !inst.input.is(':disabled') && inst.input[0] != document.activeElement)
			inst.input.focus();
		// deffered render of the years select (to avoid flashes on Firefox) 
		if( inst.yearshtml ){
			var origyearshtml = inst.yearshtml;
			setTimeout(function(){
				//assure that inst.yearshtml didn't change.
				if( origyearshtml === inst.yearshtml ){
					inst.dpDiv.find('select.ui-datepicker-year:first').replaceWith(inst.yearshtml);
				}
				origyearshtml = inst.yearshtml = null;
			}, 0);
		}
	},

	/* Retrieve the size of left and top borders for an element.
	   @param  elem  (jQuery object) the element of interest
	   @return  (number[2]) the left and top borders */
	_getBorders: function(elem) {
		var convert = function(value) {
			return {thin: 1, medium: 2, thick: 3}[value] || value;
		};
		return [parseFloat(convert(elem.css('border-left-width'))),
			parseFloat(convert(elem.css('border-top-width')))];
	},

	/* Check positioning to remain on screen. */
	_checkOffset: function(inst, offset, isFixed) {
		var dpWidth = inst.dpDiv.outerWidth();
		var dpHeight = inst.dpDiv.outerHeight();
		var inputWidth = inst.input ? inst.input.outerWidth() : 0;
		var inputHeight = inst.input ? inst.input.outerHeight() : 0;
		var viewWidth = document.documentElement.clientWidth + $(document).scrollLeft();
		var viewHeight = document.documentElement.clientHeight + $(document).scrollTop();

		offset.left -= (this._get(inst, 'isRTL') ? (dpWidth - inputWidth) : 0);
		offset.left -= (isFixed && offset.left == inst.input.offset().left) ? $(document).scrollLeft() : 0;
		offset.top -= (isFixed && offset.top == (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;

		// now check if datepicker is showing outside window viewport - move to a better place if so.
		offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
			Math.abs(offset.left + dpWidth - viewWidth) : 0);
		offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
			Math.abs(dpHeight + inputHeight) : 0);

		return offset;
	},

	/* Find an object's position on the screen. */
	_findPos: function(obj) {
		var inst = this._getInst(obj);
		var isRTL = this._get(inst, 'isRTL');
        while (obj && (obj.type == 'hidden' || obj.nodeType != 1 || $.expr.filters.hidden(obj))) {
            obj = obj[isRTL ? 'previousSibling' : 'nextSibling'];
        }
        var position = $(obj).offset();
	    return [position.left, position.top];
	},

	/* Hide the date picker from view.
	   @param  input  element - the input field attached to the date picker */
	_hideDatepicker: function(input) {
		var inst = this._curInst;
		if (!inst || (input && inst != $.data(input, PROP_NAME)))
			return;
		if (this._datepickerShowing) {
			var showAnim = this._get(inst, 'showAnim');
			var duration = this._get(inst, 'duration');
			var postProcess = function() {
				$.datepicker._tidyDialog(inst);
				this._curInst = null;
			};
			if ($.effects && $.effects[showAnim])
				inst.dpDiv.hide(showAnim, $.datepicker._get(inst, 'showOptions'), duration, postProcess);
			else
				inst.dpDiv[(showAnim == 'slideDown' ? 'slideUp' :
					(showAnim == 'fadeIn' ? 'fadeOut' : 'hide'))]((showAnim ? duration : null), postProcess);
			if (!showAnim)
				postProcess();
			var onClose = this._get(inst, 'onClose');
			if (onClose)
				onClose.apply((inst.input ? inst.input[0] : null),
					[(inst.input ? inst.input.val() : ''), inst]);  // trigger custom callback
			this._datepickerShowing = false;
			this._lastInput = null;
			if (this._inDialog) {
				this._dialogInput.css({ position: 'absolute', left: '0', top: '-100px' });
				if ($.blockUI) {
					$.unblockUI();
					$('body').append(this.dpDiv);
				}
			}
			this._inDialog = false;
		}
	},

	/* Tidy up after a dialog display. */
	_tidyDialog: function(inst) {
		inst.dpDiv.removeClass(this._dialogClass).unbind('.ui-datepicker-calendar');
	},

	/* Close date picker if clicked elsewhere. */
	_checkExternalClick: function(event) {
		if (!$.datepicker._curInst)
			return;
		var $target = $(event.target);
		if ($target[0].id != $.datepicker._mainDivId &&
				$target.parents('#' + $.datepicker._mainDivId).length == 0 &&
				!$target.hasClass($.datepicker.markerClassName) &&
				!$target.hasClass($.datepicker._triggerClass) &&
				$.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI))
			$.datepicker._hideDatepicker();
	},

	/* Adjust one of the date sub-fields. */
	_adjustDate: function(id, offset, period) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		if (this._isDisabledDatepicker(target[0])) {
			return;
		}
		this._adjustInstDate(inst, offset +
			(period == 'M' ? this._get(inst, 'showCurrentAtPos') : 0), // undo positioning
			period);
		this._updateDatepicker(inst);
	},

	/* Action for current link. */
	_gotoToday: function(id) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		if (this._get(inst, 'gotoCurrent') && inst.currentDay) {
			inst.selectedDay = inst.currentDay;
			inst.drawMonth = inst.selectedMonth = inst.currentMonth;
			inst.drawYear = inst.selectedYear = inst.currentYear;
		}
		else {
			var date = new Date();
			inst.selectedDay = date.getDate();
			inst.drawMonth = inst.selectedMonth = date.getMonth();
			inst.drawYear = inst.selectedYear = date.getFullYear();
		}
		this._notifyChange(inst);
		this._adjustDate(target);
	},

	/* Action for selecting a new month/year. */
	_selectMonthYear: function(id, select, period) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		inst._selectingMonthYear = false;
		inst['selected' + (period == 'M' ? 'Month' : 'Year')] =
		inst['draw' + (period == 'M' ? 'Month' : 'Year')] =
			parseInt(select.options[select.selectedIndex].value,10);
		this._notifyChange(inst);
		this._adjustDate(target);
	},

	/* Restore input focus after not changing month/year. */
	_clickMonthYear: function(id) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		if (inst.input && inst._selectingMonthYear) {
			setTimeout(function() {
				inst.input.focus();
			}, 0);
		}
		inst._selectingMonthYear = !inst._selectingMonthYear;
	},

	/* Action for selecting a day. */
	_selectDay: function(id, month, year, td) {
		var target = $(id);
		if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
			return;
		}
		var inst = this._getInst(target[0]);
		inst.selectedDay = inst.currentDay = $('a', td).html();
		inst.selectedMonth = inst.currentMonth = month;
		inst.selectedYear = inst.currentYear = year;
		this._selectDate(id, this._formatDate(inst,
			inst.currentDay, inst.currentMonth, inst.currentYear));
	},

	/* Erase the input field and hide the date picker. */
	_clearDate: function(id) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		this._selectDate(target, '');
	},

	/* Update the input field with the selected date. */
	_selectDate: function(id, dateStr) {
		var target = $(id);
		var inst = this._getInst(target[0]);
		dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
		if (inst.input)
			inst.input.val(dateStr);
		this._updateAlternate(inst);
		var onSelect = this._get(inst, 'onSelect');
		if (onSelect)
			onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
		else if (inst.input)
			inst.input.trigger('change'); // fire the change event
		if (inst.inline)
			this._updateDatepicker(inst);
		else {
			this._hideDatepicker();
			this._lastInput = inst.input[0];
			if (typeof(inst.input[0]) != 'object')
				inst.input.focus(); // restore focus
			this._lastInput = null;
		}
	},

	/* Update any alternate field to synchronise with the main field. */
	_updateAlternate: function(inst) {
		var altField = this._get(inst, 'altField');
		if (altField) { // update alternate field too
			var altFormat = this._get(inst, 'altFormat') || this._get(inst, 'dateFormat');
			var date = this._getDate(inst);
			var dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
			$(altField).each(function() { $(this).val(dateStr); });
		}
	},

	/* Set as beforeShowDay function to prevent selection of weekends.
	   @param  date  Date - the date to customise
	   @return [boolean, string] - is this date selectable?, what is its CSS class? */
	noWeekends: function(date) {
		var day = date.getDay();
		return [(day > 0 && day < 6), ''];
	},

	/* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
	   @param  date  Date - the date to get the week for
	   @return  number - the number of the week within the year that contains this date */
	iso8601Week: function(date) {
		var checkDate = new Date(date.getTime());
		// Find Thursday of this week starting on Monday
		checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
		var time = checkDate.getTime();
		checkDate.setMonth(0); // Compare with Jan 1
		checkDate.setDate(1);
		return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
	},

	/* Parse a string value into a date object.
	   See formatDate below for the possible formats.

	   @param  format    string - the expected format of the date
	   @param  value     string - the date in the above format
	   @param  settings  Object - attributes include:
	                     shortYearCutoff  number - the cutoff year for determining the century (optional)
	                     dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
	                     dayNames         string[7] - names of the days from Sunday (optional)
	                     monthNamesShort  string[12] - abbreviated names of the months (optional)
	                     monthNames       string[12] - names of the months (optional)
	   @return  Date - the extracted date value or null if value is blank */
	parseDate: function (format, value, settings) {
		if (format == null || value == null)
			throw 'Invalid arguments';
		value = (typeof value == 'object' ? value.toString() : value + '');
		if (value == '')
			return null;
		var shortYearCutoff = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff;
		shortYearCutoff = (typeof shortYearCutoff != 'string' ? shortYearCutoff :
				new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
		var dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort;
		var dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames;
		var monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort;
		var monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames;
		var year = -1;
		var month = -1;
		var day = -1;
		var doy = -1;
		var literal = false;
		// Check whether a format character is doubled
		var lookAhead = function(match) {
			var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
			if (matches)
				iFormat++;
			return matches;
		};
		// Extract a number from the string value
		var getNumber = function(match) {
			var isDoubled = lookAhead(match);
			var size = (match == '@' ? 14 : (match == '!' ? 20 :
				(match == 'y' && isDoubled ? 4 : (match == 'o' ? 3 : 2))));
			var digits = new RegExp('^\\d{1,' + size + '}');
			var num = value.substring(iValue).match(digits);
			if (!num)
				throw 'Missing number at position ' + iValue;
			iValue += num[0].length;
			return parseInt(num[0], 10);
		};
		// Extract a name from the string value and convert to an index
		var getName = function(match, shortNames, longNames) {
			var names = (lookAhead(match) ? longNames : shortNames);
			for (var i = 0; i < names.length; i++) {
				if (value.substr(iValue, names[i].length).toLowerCase() == names[i].toLowerCase()) {
					iValue += names[i].length;
					return i + 1;
				}
			}
			throw 'Unknown name at position ' + iValue;
		};
		// Confirm that a literal character matches the string value
		var checkLiteral = function() {
			if (value.charAt(iValue) != format.charAt(iFormat))
				throw 'Unexpected literal at position ' + iValue;
			iValue++;
		};
		var iValue = 0;
		for (var iFormat = 0; iFormat < format.length; iFormat++) {
			if (literal)
				if (format.charAt(iFormat) == "'" && !lookAhead("'"))
					literal = false;
				else
					checkLiteral();
			else
				switch (format.charAt(iFormat)) {
					case 'd':
						day = getNumber('d');
						break;
					case 'D':
						getName('D', dayNamesShort, dayNames);
						break;
					case 'o':
						doy = getNumber('o');
						break;
					case 'm':
						month = getNumber('m');
						break;
					case 'M':
						month = getName('M', monthNamesShort, monthNames);
						break;
					case 'y':
						year = getNumber('y');
						break;
					case '@':
						var date = new Date(getNumber('@'));
						year = date.getFullYear();
						month = date.getMonth() + 1;
						day = date.getDate();
						break;
					case '!':
						var date = new Date((getNumber('!') - this._ticksTo1970) / 10000);
						year = date.getFullYear();
						month = date.getMonth() + 1;
						day = date.getDate();
						break;
					case "'":
						if (lookAhead("'"))
							checkLiteral();
						else
							literal = true;
						break;
					default:
						checkLiteral();
				}
		}
		if (year == -1)
			year = new Date().getFullYear();
		else if (year < 100)
			year += new Date().getFullYear() - new Date().getFullYear() % 100 +
				(year <= shortYearCutoff ? 0 : -100);
		if (doy > -1) {
			month = 1;
			day = doy;
			do {
				var dim = this._getDaysInMonth(year, month - 1);
				if (day <= dim)
					break;
				month++;
				day -= dim;
			} while (true);
		}
		var date = this._daylightSavingAdjust(new Date(year, month - 1, day));
		if (date.getFullYear() != year || date.getMonth() + 1 != month || date.getDate() != day)
			throw 'Invalid date'; // E.g. 31/02/*
		return date;
	},

	/* Standard date formats. */
	ATOM: 'yy-mm-dd', // RFC 3339 (ISO 8601)
	COOKIE: 'D, dd M yy',
	ISO_8601: 'yy-mm-dd',
	RFC_822: 'D, d M y',
	RFC_850: 'DD, dd-M-y',
	RFC_1036: 'D, d M y',
	RFC_1123: 'D, d M yy',
	RFC_2822: 'D, d M yy',
	RSS: 'D, d M y', // RFC 822
	TICKS: '!',
	TIMESTAMP: '@',
	W3C: 'yy-mm-dd', // ISO 8601

	_ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
		Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),

	/* Format a date object into a string value.
	   The format can be combinations of the following:
	   d  - day of month (no leading zero)
	   dd - day of month (two digit)
	   o  - day of year (no leading zeros)
	   oo - day of year (three digit)
	   D  - day name short
	   DD - day name long
	   m  - month of year (no leading zero)
	   mm - month of year (two digit)
	   M  - month name short
	   MM - month name long
	   y  - year (two digit)
	   yy - year (four digit)
	   @ - Unix timestamp (ms since 01/01/1970)
	   ! - Windows ticks (100ns since 01/01/0001)
	   '...' - literal text
	   '' - single quote

	   @param  format    string - the desired format of the date
	   @param  date      Date - the date value to format
	   @param  settings  Object - attributes include:
	                     dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
	                     dayNames         string[7] - names of the days from Sunday (optional)
	                     monthNamesShort  string[12] - abbreviated names of the months (optional)
	                     monthNames       string[12] - names of the months (optional)
	   @return  string - the date in the above format */
	formatDate: function (format, date, settings) {
		if (!date)
			return '';
		var dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort;
		var dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames;
		var monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort;
		var monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames;
		// Check whether a format character is doubled
		var lookAhead = function(match) {
			var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
			if (matches)
				iFormat++;
			return matches;
		};
		// Format a number, with leading zero if necessary
		var formatNumber = function(match, value, len) {
			var num = '' + value;
			if (lookAhead(match))
				while (num.length < len)
					num = '0' + num;
			return num;
		};
		// Format a name, short or long as requested
		var formatName = function(match, value, shortNames, longNames) {
			return (lookAhead(match) ? longNames[value] : shortNames[value]);
		};
		var output = '';
		var literal = false;
		if (date)
			for (var iFormat = 0; iFormat < format.length; iFormat++) {
				if (literal)
					if (format.charAt(iFormat) == "'" && !lookAhead("'"))
						literal = false;
					else
						output += format.charAt(iFormat);
				else
					switch (format.charAt(iFormat)) {
						case 'd':
							output += formatNumber('d', date.getDate(), 2);
							break;
						case 'D':
							output += formatName('D', date.getDay(), dayNamesShort, dayNames);
							break;
						case 'o':
							output += formatNumber('o',
								(date.getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000, 3);
							break;
						case 'm':
							output += formatNumber('m', date.getMonth() + 1, 2);
							break;
						case 'M':
							output += formatName('M', date.getMonth(), monthNamesShort, monthNames);
							break;
						case 'y':
							output += (lookAhead('y') ? date.getFullYear() :
								(date.getYear() % 100 < 10 ? '0' : '') + date.getYear() % 100);
							break;
						case '@':
							output += date.getTime();
							break;
						case '!':
							output += date.getTime() * 10000 + this._ticksTo1970;
							break;
						case "'":
							if (lookAhead("'"))
								output += "'";
							else
								literal = true;
							break;
						default:
							output += format.charAt(iFormat);
					}
			}
		return output;
	},

	/* Extract all possible characters from the date format. */
	_possibleChars: function (format) {
		var chars = '';
		var literal = false;
		// Check whether a format character is doubled
		var lookAhead = function(match) {
			var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
			if (matches)
				iFormat++;
			return matches;
		};
		for (var iFormat = 0; iFormat < format.length; iFormat++)
			if (literal)
				if (format.charAt(iFormat) == "'" && !lookAhead("'"))
					literal = false;
				else
					chars += format.charAt(iFormat);
			else
				switch (format.charAt(iFormat)) {
					case 'd': case 'm': case 'y': case '@':
						chars += '0123456789';
						break;
					case 'D': case 'M':
						return null; // Accept anything
					case "'":
						if (lookAhead("'"))
							chars += "'";
						else
							literal = true;
						break;
					default:
						chars += format.charAt(iFormat);
				}
		return chars;
	},

	/* Get a setting value, defaulting if necessary. */
	_get: function(inst, name) {
		return inst.settings[name] !== undefined ?
			inst.settings[name] : this._defaults[name];
	},

	/* Parse existing date and initialise date picker. */
	_setDateFromField: function(inst, noDefault) {
		if (inst.input.val() == inst.lastVal) {
			return;
		}
		var dateFormat = this._get(inst, 'dateFormat');
		var dates = inst.lastVal = inst.input ? inst.input.val() : null;
		var date, defaultDate;
		date = defaultDate = this._getDefaultDate(inst);
		var settings = this._getFormatConfig(inst);
		try {
			date = this.parseDate(dateFormat, dates, settings) || defaultDate;
		} catch (event) {
			this.log(event);
			dates = (noDefault ? '' : dates);
		}
		inst.selectedDay = date.getDate();
		inst.drawMonth = inst.selectedMonth = date.getMonth();
		inst.drawYear = inst.selectedYear = date.getFullYear();
		inst.currentDay = (dates ? date.getDate() : 0);
		inst.currentMonth = (dates ? date.getMonth() : 0);
		inst.currentYear = (dates ? date.getFullYear() : 0);
		this._adjustInstDate(inst);
	},

	/* Retrieve the default date shown on opening. */
	_getDefaultDate: function(inst) {
		return this._restrictMinMax(inst,
			this._determineDate(inst, this._get(inst, 'defaultDate'), new Date()));
	},

	/* A date may be specified as an exact value or a relative one. */
	_determineDate: function(inst, date, defaultDate) {
		var offsetNumeric = function(offset) {
			var date = new Date();
			date.setDate(date.getDate() + offset);
			return date;
		};
		var offsetString = function(offset) {
			try {
				return $.datepicker.parseDate($.datepicker._get(inst, 'dateFormat'),
					offset, $.datepicker._getFormatConfig(inst));
			}
			catch (e) {
				// Ignore
			}
			var date = (offset.toLowerCase().match(/^c/) ?
				$.datepicker._getDate(inst) : null) || new Date();
			var year = date.getFullYear();
			var month = date.getMonth();
			var day = date.getDate();
			var pattern = /([+-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g;
			var matches = pattern.exec(offset);
			while (matches) {
				switch (matches[2] || 'd') {
					case 'd' : case 'D' :
						day += parseInt(matches[1],10); break;
					case 'w' : case 'W' :
						day += parseInt(matches[1],10) * 7; break;
					case 'm' : case 'M' :
						month += parseInt(matches[1],10);
						day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
						break;
					case 'y': case 'Y' :
						year += parseInt(matches[1],10);
						day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
						break;
				}
				matches = pattern.exec(offset);
			}
			return new Date(year, month, day);
		};
		var newDate = (date == null || date === '' ? defaultDate : (typeof date == 'string' ? offsetString(date) :
			(typeof date == 'number' ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
		newDate = (newDate && newDate.toString() == 'Invalid Date' ? defaultDate : newDate);
		if (newDate) {
			newDate.setHours(0);
			newDate.setMinutes(0);
			newDate.setSeconds(0);
			newDate.setMilliseconds(0);
		}
		return this._daylightSavingAdjust(newDate);
	},

	/* Handle switch to/from daylight saving.
	   Hours may be non-zero on daylight saving cut-over:
	   > 12 when midnight changeover, but then cannot generate
	   midnight datetime, so jump to 1AM, otherwise reset.
	   @param  date  (Date) the date to check
	   @return  (Date) the corrected date */
	_daylightSavingAdjust: function(date) {
		if (!date) return null;
		date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
		return date;
	},

	/* Set the date(s) directly. */
	_setDate: function(inst, date, noChange) {
		var clear = !date;
		var origMonth = inst.selectedMonth;
		var origYear = inst.selectedYear;
		var newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
		inst.selectedDay = inst.currentDay = newDate.getDate();
		inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
		inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
		if ((origMonth != inst.selectedMonth || origYear != inst.selectedYear) && !noChange)
			this._notifyChange(inst);
		this._adjustInstDate(inst);
		if (inst.input) {
			inst.input.val(clear ? '' : this._formatDate(inst));
		}
	},

	/* Retrieve the date(s) directly. */
	_getDate: function(inst) {
		var startDate = (!inst.currentYear || (inst.input && inst.input.val() == '') ? null :
			this._daylightSavingAdjust(new Date(
			inst.currentYear, inst.currentMonth, inst.currentDay)));
			return startDate;
	},

	/* Generate the HTML for the current state of the date picker. */
	_generateHTML: function(inst) {
		var today = new Date();
		today = this._daylightSavingAdjust(
			new Date(today.getFullYear(), today.getMonth(), today.getDate())); // clear time
		var isRTL = this._get(inst, 'isRTL');
		var showButtonPanel = this._get(inst, 'showButtonPanel');
		var hideIfNoPrevNext = this._get(inst, 'hideIfNoPrevNext');
		var navigationAsDateFormat = this._get(inst, 'navigationAsDateFormat');
		var numMonths = this._getNumberOfMonths(inst);
		var showCurrentAtPos = this._get(inst, 'showCurrentAtPos');
		var stepMonths = this._get(inst, 'stepMonths');
		var isMultiMonth = (numMonths[0] != 1 || numMonths[1] != 1);
		var currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
			new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
		var minDate = this._getMinMaxDate(inst, 'min');
		var maxDate = this._getMinMaxDate(inst, 'max');
		var drawMonth = inst.drawMonth - showCurrentAtPos;
		var drawYear = inst.drawYear;
		if (drawMonth < 0) {
			drawMonth += 12;
			drawYear--;
		}
		if (maxDate) {
			var maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
				maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
			maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
			while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
				drawMonth--;
				if (drawMonth < 0) {
					drawMonth = 11;
					drawYear--;
				}
			}
		}
		inst.drawMonth = drawMonth;
		inst.drawYear = drawYear;
		var prevText = this._get(inst, 'prevText');
		prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
			this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
			this._getFormatConfig(inst)));
		var prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
			'<a class="ui-datepicker-prev ui-corner-all" onclick="DP_jQuery_' + dpuuid +
			'.datepicker._adjustDate(\'#' + inst.id + '\', -' + stepMonths + ', \'M\');"' +
			' title="' + prevText + '"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'e' : 'w') + '">' + prevText + '</span></a>' :
			(hideIfNoPrevNext ? '' : '<a class="ui-datepicker-prev ui-corner-all ui-state-disabled" title="'+ prevText +'"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'e' : 'w') + '">' + prevText + '</span></a>'));
		var nextText = this._get(inst, 'nextText');
		nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
			this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
			this._getFormatConfig(inst)));
		var next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
			'<a class="ui-datepicker-next ui-corner-all" onclick="DP_jQuery_' + dpuuid +
			'.datepicker._adjustDate(\'#' + inst.id + '\', +' + stepMonths + ', \'M\');"' +
			' title="' + nextText + '"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'w' : 'e') + '">' + nextText + '</span></a>' :
			(hideIfNoPrevNext ? '' : '<a class="ui-datepicker-next ui-corner-all ui-state-disabled" title="'+ nextText + '"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'w' : 'e') + '">' + nextText + '</span></a>'));
		var currentText = this._get(inst, 'currentText');
		var gotoDate = (this._get(inst, 'gotoCurrent') && inst.currentDay ? currentDate : today);
		currentText = (!navigationAsDateFormat ? currentText :
			this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
		var controls = (!inst.inline ? '<button type="button" class="ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all" onclick="DP_jQuery_' + dpuuid +
			'.datepicker._hideDatepicker();">' + this._get(inst, 'closeText') + '</button>' : '');
		var buttonPanel = (showButtonPanel) ? '<div class="ui-datepicker-buttonpane ui-widget-content">' + (isRTL ? controls : '') +
			(this._isInRange(inst, gotoDate) ? '<button type="button" class="ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all" onclick="DP_jQuery_' + dpuuid +
			'.datepicker._gotoToday(\'#' + inst.id + '\');"' +
			'>' + currentText + '</button>' : '') + (isRTL ? '' : controls) + '</div>' : '';
		var firstDay = parseInt(this._get(inst, 'firstDay'),10);
		firstDay = (isNaN(firstDay) ? 0 : firstDay);
		var showWeek = this._get(inst, 'showWeek');
		var dayNames = this._get(inst, 'dayNames');
		var dayNamesShort = this._get(inst, 'dayNamesShort');
		var dayNamesMin = this._get(inst, 'dayNamesMin');
		var monthNames = this._get(inst, 'monthNames');
		var monthNamesShort = this._get(inst, 'monthNamesShort');
		var beforeShowDay = this._get(inst, 'beforeShowDay');
		var showOtherMonths = this._get(inst, 'showOtherMonths');
		var selectOtherMonths = this._get(inst, 'selectOtherMonths');
		var calculateWeek = this._get(inst, 'calculateWeek') || this.iso8601Week;
		var defaultDate = this._getDefaultDate(inst);
		var html = '';
		for (var row = 0; row < numMonths[0]; row++) {
			var group = '';
			for (var col = 0; col < numMonths[1]; col++) {
				var selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
				var cornerClass = ' ui-corner-all';
				var calender = '';
				if (isMultiMonth) {
					calender += '<div class="ui-datepicker-group';
					if (numMonths[1] > 1)
						switch (col) {
							case 0: calender += ' ui-datepicker-group-first';
								cornerClass = ' ui-corner-' + (isRTL ? 'right' : 'left'); break;
							case numMonths[1]-1: calender += ' ui-datepicker-group-last';
								cornerClass = ' ui-corner-' + (isRTL ? 'left' : 'right'); break;
							default: calender += ' ui-datepicker-group-middle'; cornerClass = ''; break;
						}
					calender += '">';
				}
				calender += '<div class="ui-datepicker-header ui-widget-header ui-helper-clearfix' + cornerClass + '">' +
					(/all|left/.test(cornerClass) && row == 0 ? (isRTL ? next : prev) : '') +
					(/all|right/.test(cornerClass) && row == 0 ? (isRTL ? prev : next) : '') +
					this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
					row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
					'</div><table class="ui-datepicker-calendar"><thead>' +
					'<tr>';
				var thead = (showWeek ? '<th class="ui-datepicker-week-col">' + this._get(inst, 'weekHeader') + '</th>' : '');
				for (var dow = 0; dow < 7; dow++) { // days of the week
					var day = (dow + firstDay) % 7;
					thead += '<th' + ((dow + firstDay + 6) % 7 >= 5 ? ' class="ui-datepicker-week-end"' : '') + '>' +
						'<span title="' + dayNames[day] + '">' + dayNamesMin[day] + '</span></th>';
				}
				calender += thead + '</tr></thead><tbody>';
				var daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
				if (drawYear == inst.selectedYear && drawMonth == inst.selectedMonth)
					inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
				var leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
				var numRows = (isMultiMonth ? 6 : Math.ceil((leadDays + daysInMonth) / 7)); // calculate the number of rows to generate
				var printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
				for (var dRow = 0; dRow < numRows; dRow++) { // create date picker rows
					calender += '<tr>';
					var tbody = (!showWeek ? '' : '<td class="ui-datepicker-week-col">' +
						this._get(inst, 'calculateWeek')(printDate) + '</td>');
					for (var dow = 0; dow < 7; dow++) { // create date picker days
						var daySettings = (beforeShowDay ?
							beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, '']);
						var otherMonth = (printDate.getMonth() != drawMonth);
						var unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
							(minDate && printDate < minDate) || (maxDate && printDate > maxDate);
						tbody += '<td class="' +
							((dow + firstDay + 6) % 7 >= 5 ? ' ui-datepicker-week-end' : '') + // highlight weekends
							(otherMonth ? ' ui-datepicker-other-month' : '') + // highlight days from other months
							((printDate.getTime() == selectedDate.getTime() && drawMonth == inst.selectedMonth && inst._keyEvent) || // user pressed key
							(defaultDate.getTime() == printDate.getTime() && defaultDate.getTime() == selectedDate.getTime()) ?
							// or defaultDate is current printedDate and defaultDate is selectedDate
							' ' + this._dayOverClass : '') + // highlight selected day
							(unselectable ? ' ' + this._unselectableClass + ' ui-state-disabled': '') +  // highlight unselectable days
							(otherMonth && !showOtherMonths ? '' : ' ' + daySettings[1] + // highlight custom dates
							(printDate.getTime() == currentDate.getTime() ? ' ' + this._currentClass : '') + // highlight selected day
							(printDate.getTime() == today.getTime() ? ' ui-datepicker-today' : '')) + '"' + // highlight today (if different)
							((!otherMonth || showOtherMonths) && daySettings[2] ? ' title="' + daySettings[2] + '"' : '') + // cell title
							(unselectable ? '' : ' onclick="DP_jQuery_' + dpuuid + '.datepicker._selectDay(\'#' +
							inst.id + '\',' + printDate.getMonth() + ',' + printDate.getFullYear() + ', this);return false;"') + '>' + // actions
							(otherMonth && !showOtherMonths ? '&#xa0;' : // display for other months
							(unselectable ? '<span class="ui-state-default">' + printDate.getDate() + '</span>' : '<a class="ui-state-default' +
							(printDate.getTime() == today.getTime() ? ' ui-state-highlight' : '') +
							(printDate.getTime() == currentDate.getTime() ? ' ui-state-active' : '') + // highlight selected day
							(otherMonth ? ' ui-priority-secondary' : '') + // distinguish dates from other months
							'" href="#">' + printDate.getDate() + '</a>')) + '</td>'; // display selectable date
						printDate.setDate(printDate.getDate() + 1);
						printDate = this._daylightSavingAdjust(printDate);
					}
					calender += tbody + '</tr>';
				}
				drawMonth++;
				if (drawMonth > 11) {
					drawMonth = 0;
					drawYear++;
				}
				calender += '</tbody></table>' + (isMultiMonth ? '</div>' + 
							((numMonths[0] > 0 && col == numMonths[1]-1) ? '<div class="ui-datepicker-row-break"></div>' : '') : '');
				group += calender;
			}
			html += group;
		}
		html += buttonPanel + ($.browser.msie && parseInt($.browser.version,10) < 7 && !inst.inline ?
			'<iframe src="javascript:false;" class="ui-datepicker-cover" frameborder="0"></iframe>' : '');
		inst._keyEvent = false;
		return html;
	},

	/* Generate the month and year header. */
	_generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
			secondary, monthNames, monthNamesShort) {
		var changeMonth = this._get(inst, 'changeMonth');
		var changeYear = this._get(inst, 'changeYear');
		var showMonthAfterYear = this._get(inst, 'showMonthAfterYear');
		var html = '<div class="ui-datepicker-title">';
		var monthHtml = '';
		// month selection
		if (secondary || !changeMonth)
			monthHtml += '<span class="ui-datepicker-month">' + monthNames[drawMonth] + '</span>';
		else {
			var inMinYear = (minDate && minDate.getFullYear() == drawYear);
			var inMaxYear = (maxDate && maxDate.getFullYear() == drawYear);
			monthHtml += '<select class="ui-datepicker-month" ' +
				'onchange="DP_jQuery_' + dpuuid + '.datepicker._selectMonthYear(\'#' + inst.id + '\', this, \'M\');" ' +
				'onclick="DP_jQuery_' + dpuuid + '.datepicker._clickMonthYear(\'#' + inst.id + '\');"' +
			 	'>';
			for (var month = 0; month < 12; month++) {
				if ((!inMinYear || month >= minDate.getMonth()) &&
						(!inMaxYear || month <= maxDate.getMonth()))
					monthHtml += '<option value="' + month + '"' +
						(month == drawMonth ? ' selected="selected"' : '') +
						'>' + monthNamesShort[month] + '</option>';
			}
			monthHtml += '</select>';
		}
		if (!showMonthAfterYear)
			html += monthHtml + (secondary || !(changeMonth && changeYear) ? '&#xa0;' : '');
		// year selection
		inst.yearshtml = '';
		if (secondary || !changeYear)
			html += '<span class="ui-datepicker-year">' + drawYear + '</span>';
		else {
			// determine range of years to display
			var years = this._get(inst, 'yearRange').split(':');
			var thisYear = new Date().getFullYear();
			var determineYear = function(value) {
				var year = (value.match(/c[+-].*/) ? drawYear + parseInt(value.substring(1), 10) :
					(value.match(/[+-].*/) ? thisYear + parseInt(value, 10) :
					parseInt(value, 10)));
				return (isNaN(year) ? thisYear : year);
			};
			var year = determineYear(years[0]);
			var endYear = Math.max(year, determineYear(years[1] || ''));
			year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
			endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
			inst.yearshtml += '<select class="ui-datepicker-year" ' +
				'onchange="DP_jQuery_' + dpuuid + '.datepicker._selectMonthYear(\'#' + inst.id + '\', this, \'Y\');" ' +
				'onclick="DP_jQuery_' + dpuuid + '.datepicker._clickMonthYear(\'#' + inst.id + '\');"' +
				'>';
			for (; year <= endYear; year++) {
				inst.yearshtml += '<option value="' + year + '"' +
					(year == drawYear ? ' selected="selected"' : '') +
					'>' + year + '</option>';
			}
			inst.yearshtml += '</select>';
			//when showing there is no need for later update
			if( ! $.browser.mozilla ){
				html += inst.yearshtml;
				inst.yearshtml = null;
			} else {
				// will be replaced later with inst.yearshtml
				html += '<select class="ui-datepicker-year"><option value="' + drawYear + '" selected="selected">' + drawYear + '</option></select>';
			}
		}
		html += this._get(inst, 'yearSuffix');
		if (showMonthAfterYear)
			html += (secondary || !(changeMonth && changeYear) ? '&#xa0;' : '') + monthHtml;
		html += '</div>'; // Close datepicker_header
		return html;
	},

	/* Adjust one of the date sub-fields. */
	_adjustInstDate: function(inst, offset, period) {
		var year = inst.drawYear + (period == 'Y' ? offset : 0);
		var month = inst.drawMonth + (period == 'M' ? offset : 0);
		var day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) +
			(period == 'D' ? offset : 0);
		var date = this._restrictMinMax(inst,
			this._daylightSavingAdjust(new Date(year, month, day)));
		inst.selectedDay = date.getDate();
		inst.drawMonth = inst.selectedMonth = date.getMonth();
		inst.drawYear = inst.selectedYear = date.getFullYear();
		if (period == 'M' || period == 'Y')
			this._notifyChange(inst);
	},

	/* Ensure a date is within any min/max bounds. */
	_restrictMinMax: function(inst, date) {
		var minDate = this._getMinMaxDate(inst, 'min');
		var maxDate = this._getMinMaxDate(inst, 'max');
		var newDate = (minDate && date < minDate ? minDate : date);
		newDate = (maxDate && newDate > maxDate ? maxDate : newDate);
		return newDate;
	},

	/* Notify change of month/year. */
	_notifyChange: function(inst) {
		var onChange = this._get(inst, 'onChangeMonthYear');
		if (onChange)
			onChange.apply((inst.input ? inst.input[0] : null),
				[inst.selectedYear, inst.selectedMonth + 1, inst]);
	},

	/* Determine the number of months to show. */
	_getNumberOfMonths: function(inst) {
		var numMonths = this._get(inst, 'numberOfMonths');
		return (numMonths == null ? [1, 1] : (typeof numMonths == 'number' ? [1, numMonths] : numMonths));
	},

	/* Determine the current maximum date - ensure no time components are set. */
	_getMinMaxDate: function(inst, minMax) {
		return this._determineDate(inst, this._get(inst, minMax + 'Date'), null);
	},

	/* Find the number of days in a given month. */
	_getDaysInMonth: function(year, month) {
		return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
	},

	/* Find the day of the week of the first of a month. */
	_getFirstDayOfMonth: function(year, month) {
		return new Date(year, month, 1).getDay();
	},

	/* Determines if we should allow a "next/prev" month display change. */
	_canAdjustMonth: function(inst, offset, curYear, curMonth) {
		var numMonths = this._getNumberOfMonths(inst);
		var date = this._daylightSavingAdjust(new Date(curYear,
			curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
		if (offset < 0)
			date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
		return this._isInRange(inst, date);
	},

	/* Is the given date in the accepted range? */
	_isInRange: function(inst, date) {
		var minDate = this._getMinMaxDate(inst, 'min');
		var maxDate = this._getMinMaxDate(inst, 'max');
		return ((!minDate || date.getTime() >= minDate.getTime()) &&
			(!maxDate || date.getTime() <= maxDate.getTime()));
	},

	/* Provide the configuration settings for formatting/parsing. */
	_getFormatConfig: function(inst) {
		var shortYearCutoff = this._get(inst, 'shortYearCutoff');
		shortYearCutoff = (typeof shortYearCutoff != 'string' ? shortYearCutoff :
			new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
		return {shortYearCutoff: shortYearCutoff,
			dayNamesShort: this._get(inst, 'dayNamesShort'), dayNames: this._get(inst, 'dayNames'),
			monthNamesShort: this._get(inst, 'monthNamesShort'), monthNames: this._get(inst, 'monthNames')};
	},

	/* Format the given date for display. */
	_formatDate: function(inst, day, month, year) {
		if (!day) {
			inst.currentDay = inst.selectedDay;
			inst.currentMonth = inst.selectedMonth;
			inst.currentYear = inst.selectedYear;
		}
		var date = (day ? (typeof day == 'object' ? day :
			this._daylightSavingAdjust(new Date(year, month, day))) :
			this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
		return this.formatDate(this._get(inst, 'dateFormat'), date, this._getFormatConfig(inst));
	}
});

/* jQuery extend now ignores nulls! */
function extendRemove(target, props) {
	$.extend(target, props);
	for (var name in props)
		if (props[name] == null || props[name] == undefined)
			target[name] = props[name];
	return target;
};

/* Determine whether an object is an array. */
function isArray(a) {
	return (a && (($.browser.safari && typeof a == 'object' && a.length) ||
		(a.constructor && a.constructor.toString().match(/\Array\(\)/))));
};

/* Invoke the datepicker functionality.
   @param  options  string - a command, optionally followed by additional parameters or
                    Object - settings for attaching new datepicker functionality
   @return  jQuery object */
$.fn.datepicker = function(options){
	
	/* Verify an empty collection wasn't passed - Fixes #6976 */
	if ( !this.length ) {
		return this;
	}
	
	/* Initialise the date picker. */
	if (!$.datepicker.initialized) {
		$(document).mousedown($.datepicker._checkExternalClick).
			find('body').append($.datepicker.dpDiv);
		$.datepicker.initialized = true;
	}

	var otherArgs = Array.prototype.slice.call(arguments, 1);
	if (typeof options == 'string' && (options == 'isDisabled' || options == 'getDate' || options == 'widget'))
		return $.datepicker['_' + options + 'Datepicker'].
			apply($.datepicker, [this[0]].concat(otherArgs));
	if (options == 'option' && arguments.length == 2 && typeof arguments[1] == 'string')
		return $.datepicker['_' + options + 'Datepicker'].
			apply($.datepicker, [this[0]].concat(otherArgs));
	return this.each(function() {
		typeof options == 'string' ?
			$.datepicker['_' + options + 'Datepicker'].
				apply($.datepicker, [this].concat(otherArgs)) :
			$.datepicker._attachDatepicker(this, options);
	});
};

$.datepicker = new Datepicker(); // singleton instance
$.datepicker.initialized = false;
$.datepicker.uuid = new Date().getTime();
$.datepicker.version = "1.8.11";

// Workaround for #4055
// Add another global to avoid noConflict issues with inline event handlers
window['DP_jQuery_' + dpuuid] = $;

})(jQuery);
/*
 * jQuery UI Progressbar 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Progressbar
 *
 * Depends:
 *   jquery.ui.core.js
 *   jquery.ui.widget.js
 */
(function( $, undefined ) {

$.widget( "ui.progressbar", {
	options: {
		value: 0,
		max: 100
	},

	min: 0,

	_create: function() {
		this.element
			.addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
			.attr({
				role: "progressbar",
				"aria-valuemin": this.min,
				"aria-valuemax": this.options.max,
				"aria-valuenow": this._value()
			});

		this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
			.appendTo( this.element );

		this.oldValue = this._value();
		this._refreshValue();
	},

	destroy: function() {
		this.element
			.removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
			.removeAttr( "role" )
			.removeAttr( "aria-valuemin" )
			.removeAttr( "aria-valuemax" )
			.removeAttr( "aria-valuenow" );

		this.valueDiv.remove();

		$.Widget.prototype.destroy.apply( this, arguments );
	},

	value: function( newValue ) {
		if ( newValue === undefined ) {
			return this._value();
		}

		this._setOption( "value", newValue );
		return this;
	},

	_setOption: function( key, value ) {
		if ( key === "value" ) {
			this.options.value = value;
			this._refreshValue();
			if ( this._value() === this.options.max ) {
				this._trigger( "complete" );
			}
		}

		$.Widget.prototype._setOption.apply( this, arguments );
	},

	_value: function() {
		var val = this.options.value;
		// normalize invalid value
		if ( typeof val !== "number" ) {
			val = 0;
		}
		return Math.min( this.options.max, Math.max( this.min, val ) );
	},

	_percentage: function() {
		return 100 * this._value() / this.options.max;
	},

	_refreshValue: function() {
		var value = this.value();
		var percentage = this._percentage();

		if ( this.oldValue !== value ) {
			this.oldValue = value;
			this._trigger( "change" );
		}

		this.valueDiv
			.toggleClass( "ui-corner-right", value === this.options.max )
			.width( percentage.toFixed(0) + "%" );
		this.element.attr( "aria-valuenow", value );
	}
});

$.extend( $.ui.progressbar, {
	version: "1.8.11"
});

})( jQuery );
/*
 * jQuery UI Effects 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/
 */
;jQuery.effects || (function($, undefined) {

$.effects = {};



/******************************************************************************/
/****************************** COLOR ANIMATIONS ******************************/
/******************************************************************************/

// override the animation for color styles
$.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor',
	'borderRightColor', 'borderTopColor', 'borderColor', 'color', 'outlineColor'],
function(i, attr) {
	$.fx.step[attr] = function(fx) {
		if (!fx.colorInit) {
			fx.start = getColor(fx.elem, attr);
			fx.end = getRGB(fx.end);
			fx.colorInit = true;
		}

		fx.elem.style[attr] = 'rgb(' +
			Math.max(Math.min(parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0], 10), 255), 0) + ',' +
			Math.max(Math.min(parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1], 10), 255), 0) + ',' +
			Math.max(Math.min(parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2], 10), 255), 0) + ')';
	};
});

// Color Conversion functions from highlightFade
// By Blair Mitchelmore
// http://jquery.offput.ca/highlightFade/

// Parse strings looking for color tuples [255,255,255]
function getRGB(color) {
		var result;

		// Check if we're already dealing with an array of colors
		if ( color && color.constructor == Array && color.length == 3 )
				return color;

		// Look for rgb(num,num,num)
		if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
				return [parseInt(result[1],10), parseInt(result[2],10), parseInt(result[3],10)];

		// Look for rgb(num%,num%,num%)
		if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
				return [parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55];

		// Look for #a0b1c2
		if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
				return [parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16)];

		// Look for #fff
		if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
				return [parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];

		// Look for rgba(0, 0, 0, 0) == transparent in Safari 3
		if (result = /rgba\(0, 0, 0, 0\)/.exec(color))
				return colors['transparent'];

		// Otherwise, we're most likely dealing with a named color
		return colors[$.trim(color).toLowerCase()];
}

function getColor(elem, attr) {
		var color;

		do {
				color = $.curCSS(elem, attr);

				// Keep going until we find an element that has color, or we hit the body
				if ( color != '' && color != 'transparent' || $.nodeName(elem, "body") )
						break;

				attr = "backgroundColor";
		} while ( elem = elem.parentNode );

		return getRGB(color);
};

// Some named colors to work with
// From Interface by Stefan Petre
// http://interface.eyecon.ro/

var colors = {
	aqua:[0,255,255],
	azure:[240,255,255],
	beige:[245,245,220],
	black:[0,0,0],
	blue:[0,0,255],
	brown:[165,42,42],
	cyan:[0,255,255],
	darkblue:[0,0,139],
	darkcyan:[0,139,139],
	darkgrey:[169,169,169],
	darkgreen:[0,100,0],
	darkkhaki:[189,183,107],
	darkmagenta:[139,0,139],
	darkolivegreen:[85,107,47],
	darkorange:[255,140,0],
	darkorchid:[153,50,204],
	darkred:[139,0,0],
	darksalmon:[233,150,122],
	darkviolet:[148,0,211],
	fuchsia:[255,0,255],
	gold:[255,215,0],
	green:[0,128,0],
	indigo:[75,0,130],
	khaki:[240,230,140],
	lightblue:[173,216,230],
	lightcyan:[224,255,255],
	lightgreen:[144,238,144],
	lightgrey:[211,211,211],
	lightpink:[255,182,193],
	lightyellow:[255,255,224],
	lime:[0,255,0],
	magenta:[255,0,255],
	maroon:[128,0,0],
	navy:[0,0,128],
	olive:[128,128,0],
	orange:[255,165,0],
	pink:[255,192,203],
	purple:[128,0,128],
	violet:[128,0,128],
	red:[255,0,0],
	silver:[192,192,192],
	white:[255,255,255],
	yellow:[255,255,0],
	transparent: [255,255,255]
};



/******************************************************************************/
/****************************** CLASS ANIMATIONS ******************************/
/******************************************************************************/

var classAnimationActions = ['add', 'remove', 'toggle'],
	shorthandStyles = {
		border: 1,
		borderBottom: 1,
		borderColor: 1,
		borderLeft: 1,
		borderRight: 1,
		borderTop: 1,
		borderWidth: 1,
		margin: 1,
		padding: 1
	};

function getElementStyles() {
	var style = document.defaultView
			? document.defaultView.getComputedStyle(this, null)
			: this.currentStyle,
		newStyle = {},
		key,
		camelCase;

	// webkit enumerates style porperties
	if (style && style.length && style[0] && style[style[0]]) {
		var len = style.length;
		while (len--) {
			key = style[len];
			if (typeof style[key] == 'string') {
				camelCase = key.replace(/\-(\w)/g, function(all, letter){
					return letter.toUpperCase();
				});
				newStyle[camelCase] = style[key];
			}
		}
	} else {
		for (key in style) {
			if (typeof style[key] === 'string') {
				newStyle[key] = style[key];
			}
		}
	}
	
	return newStyle;
}

function filterStyles(styles) {
	var name, value;
	for (name in styles) {
		value = styles[name];
		if (
			// ignore null and undefined values
			value == null ||
			// ignore functions (when does this occur?)
			$.isFunction(value) ||
			// shorthand styles that need to be expanded
			name in shorthandStyles ||
			// ignore scrollbars (break in IE)
			(/scrollbar/).test(name) ||

			// only colors or values that can be converted to numbers
			(!(/color/i).test(name) && isNaN(parseFloat(value)))
		) {
			delete styles[name];
		}
	}
	
	return styles;
}

function styleDifference(oldStyle, newStyle) {
	var diff = { _: 0 }, // http://dev.jquery.com/ticket/5459
		name;

	for (name in newStyle) {
		if (oldStyle[name] != newStyle[name]) {
			diff[name] = newStyle[name];
		}
	}

	return diff;
}

$.effects.animateClass = function(value, duration, easing, callback) {
	if ($.isFunction(easing)) {
		callback = easing;
		easing = null;
	}

	return this.queue('fx', function() {
		var that = $(this),
			originalStyleAttr = that.attr('style') || ' ',
			originalStyle = filterStyles(getElementStyles.call(this)),
			newStyle,
			className = that.attr('className');

		$.each(classAnimationActions, function(i, action) {
			if (value[action]) {
				that[action + 'Class'](value[action]);
			}
		});
		newStyle = filterStyles(getElementStyles.call(this));
		that.attr('className', className);

		that.animate(styleDifference(originalStyle, newStyle), duration, easing, function() {
			$.each(classAnimationActions, function(i, action) {
				if (value[action]) { that[action + 'Class'](value[action]); }
			});
			// work around bug in IE by clearing the cssText before setting it
			if (typeof that.attr('style') == 'object') {
				that.attr('style').cssText = '';
				that.attr('style').cssText = originalStyleAttr;
			} else {
				that.attr('style', originalStyleAttr);
			}
			if (callback) { callback.apply(this, arguments); }
		});

		// $.animate adds a function to the end of the queue
		// but we want it at the front
		var queue = $.queue(this),
			anim = queue.splice(queue.length - 1, 1)[0];
		queue.splice(1, 0, anim);
		$.dequeue(this);
	});
};

$.fn.extend({
	_addClass: $.fn.addClass,
	addClass: function(classNames, speed, easing, callback) {
		return speed ? $.effects.animateClass.apply(this, [{ add: classNames },speed,easing,callback]) : this._addClass(classNames);
	},

	_removeClass: $.fn.removeClass,
	removeClass: function(classNames,speed,easing,callback) {
		return speed ? $.effects.animateClass.apply(this, [{ remove: classNames },speed,easing,callback]) : this._removeClass(classNames);
	},

	_toggleClass: $.fn.toggleClass,
	toggleClass: function(classNames, force, speed, easing, callback) {
		if ( typeof force == "boolean" || force === undefined ) {
			if ( !speed ) {
				// without speed parameter;
				return this._toggleClass(classNames, force);
			} else {
				return $.effects.animateClass.apply(this, [(force?{add:classNames}:{remove:classNames}),speed,easing,callback]);
			}
		} else {
			// without switch parameter;
			return $.effects.animateClass.apply(this, [{ toggle: classNames },force,speed,easing]);
		}
	},

	switchClass: function(remove,add,speed,easing,callback) {
		return $.effects.animateClass.apply(this, [{ add: add, remove: remove },speed,easing,callback]);
	}
});



/******************************************************************************/
/*********************************** EFFECTS **********************************/
/******************************************************************************/

$.extend($.effects, {
	version: "1.8.11",

	// Saves a set of properties in a data storage
	save: function(element, set) {
		for(var i=0; i < set.length; i++) {
			if(set[i] !== null) element.data("ec.storage."+set[i], element[0].style[set[i]]);
		}
	},

	// Restores a set of previously saved properties from a data storage
	restore: function(element, set) {
		for(var i=0; i < set.length; i++) {
			if(set[i] !== null) element.css(set[i], element.data("ec.storage."+set[i]));
		}
	},

	setMode: function(el, mode) {
		if (mode == 'toggle') mode = el.is(':hidden') ? 'show' : 'hide'; // Set for toggle
		return mode;
	},

	getBaseline: function(origin, original) { // Translates a [top,left] array into a baseline value
		// this should be a little more flexible in the future to handle a string & hash
		var y, x;
		switch (origin[0]) {
			case 'top': y = 0; break;
			case 'middle': y = 0.5; break;
			case 'bottom': y = 1; break;
			default: y = origin[0] / original.height;
		};
		switch (origin[1]) {
			case 'left': x = 0; break;
			case 'center': x = 0.5; break;
			case 'right': x = 1; break;
			default: x = origin[1] / original.width;
		};
		return {x: x, y: y};
	},

	// Wraps the element around a wrapper that copies position properties
	createWrapper: function(element) {

		// if the element is already wrapped, return it
		if (element.parent().is('.ui-effects-wrapper')) {
			return element.parent();
		}

		// wrap the element
		var props = {
				width: element.outerWidth(true),
				height: element.outerHeight(true),
				'float': element.css('float')
			},
			wrapper = $('<div></div>')
				.addClass('ui-effects-wrapper')
				.css({
					fontSize: '100%',
					background: 'transparent',
					border: 'none',
					margin: 0,
					padding: 0
				});

		element.wrap(wrapper);
		wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually loose the reference to the wrapped element

		// transfer positioning properties to the wrapper
		if (element.css('position') == 'static') {
			wrapper.css({ position: 'relative' });
			element.css({ position: 'relative' });
		} else {
			$.extend(props, {
				position: element.css('position'),
				zIndex: element.css('z-index')
			});
			$.each(['top', 'left', 'bottom', 'right'], function(i, pos) {
				props[pos] = element.css(pos);
				if (isNaN(parseInt(props[pos], 10))) {
					props[pos] = 'auto';
				}
			});
			element.css({position: 'relative', top: 0, left: 0, right: 'auto', bottom: 'auto' });
		}

		return wrapper.css(props).show();
	},

	removeWrapper: function(element) {
		if (element.parent().is('.ui-effects-wrapper'))
			return element.parent().replaceWith(element);
		return element;
	},

	setTransition: function(element, list, factor, value) {
		value = value || {};
		$.each(list, function(i, x){
			unit = element.cssUnit(x);
			if (unit[0] > 0) value[x] = unit[0] * factor + unit[1];
		});
		return value;
	}
});


function _normalizeArguments(effect, options, speed, callback) {
	// shift params for method overloading
	if (typeof effect == 'object') {
		callback = options;
		speed = null;
		options = effect;
		effect = options.effect;
	}
	if ($.isFunction(options)) {
		callback = options;
		speed = null;
		options = {};
	}
        if (typeof options == 'number' || $.fx.speeds[options]) {
		callback = speed;
		speed = options;
		options = {};
	}
	if ($.isFunction(speed)) {
		callback = speed;
		speed = null;
	}

	options = options || {};

	speed = speed || options.duration;
	speed = $.fx.off ? 0 : typeof speed == 'number'
		? speed : speed in $.fx.speeds ? $.fx.speeds[speed] : $.fx.speeds._default;

	callback = callback || options.complete;

	return [effect, options, speed, callback];
}

function standardSpeed( speed ) {
	// valid standard speeds
	if ( !speed || typeof speed === "number" || $.fx.speeds[ speed ] ) {
		return true;
	}
	
	// invalid strings - treat as "normal" speed
	if ( typeof speed === "string" && !$.effects[ speed ] ) {
		return true;
	}
	
	return false;
}

$.fn.extend({
	effect: function(effect, options, speed, callback) {
		var args = _normalizeArguments.apply(this, arguments),
			// TODO: make effects take actual parameters instead of a hash
			args2 = {
				options: args[1],
				duration: args[2],
				callback: args[3]
			},
			mode = args2.options.mode,
			effectMethod = $.effects[effect];
		
		if ( $.fx.off || !effectMethod ) {
			// delegate to the original method (e.g., .show()) if possible
			if ( mode ) {
				return this[ mode ]( args2.duration, args2.callback );
			} else {
				return this.each(function() {
					if ( args2.callback ) {
						args2.callback.call( this );
					}
				});
			}
		}
		
		return effectMethod.call(this, args2);
	},

	_show: $.fn.show,
	show: function(speed) {
		if ( standardSpeed( speed ) ) {
			return this._show.apply(this, arguments);
		} else {
			var args = _normalizeArguments.apply(this, arguments);
			args[1].mode = 'show';
			return this.effect.apply(this, args);
		}
	},

	_hide: $.fn.hide,
	hide: function(speed) {
		if ( standardSpeed( speed ) ) {
			return this._hide.apply(this, arguments);
		} else {
			var args = _normalizeArguments.apply(this, arguments);
			args[1].mode = 'hide';
			return this.effect.apply(this, args);
		}
	},

	// jQuery core overloads toggle and creates _toggle
	__toggle: $.fn.toggle,
	toggle: function(speed) {
		if ( standardSpeed( speed ) || typeof speed === "boolean" || $.isFunction( speed ) ) {
			return this.__toggle.apply(this, arguments);
		} else {
			var args = _normalizeArguments.apply(this, arguments);
			args[1].mode = 'toggle';
			return this.effect.apply(this, args);
		}
	},

	// helper functions
	cssUnit: function(key) {
		var style = this.css(key), val = [];
		$.each( ['em','px','%','pt'], function(i, unit){
			if(style.indexOf(unit) > 0)
				val = [parseFloat(style), unit];
		});
		return val;
	}
});



/******************************************************************************/
/*********************************** EASING ***********************************/
/******************************************************************************/

/*
 * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
 *
 * Uses the built in easing capabilities added In jQuery 1.1
 * to offer multiple easing options
 *
 * TERMS OF USE - jQuery Easing
 *
 * Open source under the BSD License.
 *
 * Copyright 2008 George McGinley Smith
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * Neither the name of the author nor the names of contributors may be used to endorse
 * or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

// t: current time, b: begInnIng value, c: change In value, d: duration
$.easing.jswing = $.easing.swing;

$.extend($.easing,
{
	def: 'easeOutQuad',
	swing: function (x, t, b, c, d) {
		//alert($.easing.default);
		return $.easing[$.easing.def](x, t, b, c, d);
	},
	easeInQuad: function (x, t, b, c, d) {
		return c*(t/=d)*t + b;
	},
	easeOutQuad: function (x, t, b, c, d) {
		return -c *(t/=d)*(t-2) + b;
	},
	easeInOutQuad: function (x, t, b, c, d) {
		if ((t/=d/2) < 1) return c/2*t*t + b;
		return -c/2 * ((--t)*(t-2) - 1) + b;
	},
	easeInCubic: function (x, t, b, c, d) {
		return c*(t/=d)*t*t + b;
	},
	easeOutCubic: function (x, t, b, c, d) {
		return c*((t=t/d-1)*t*t + 1) + b;
	},
	easeInOutCubic: function (x, t, b, c, d) {
		if ((t/=d/2) < 1) return c/2*t*t*t + b;
		return c/2*((t-=2)*t*t + 2) + b;
	},
	easeInQuart: function (x, t, b, c, d) {
		return c*(t/=d)*t*t*t + b;
	},
	easeOutQuart: function (x, t, b, c, d) {
		return -c * ((t=t/d-1)*t*t*t - 1) + b;
	},
	easeInOutQuart: function (x, t, b, c, d) {
		if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
		return -c/2 * ((t-=2)*t*t*t - 2) + b;
	},
	easeInQuint: function (x, t, b, c, d) {
		return c*(t/=d)*t*t*t*t + b;
	},
	easeOutQuint: function (x, t, b, c, d) {
		return c*((t=t/d-1)*t*t*t*t + 1) + b;
	},
	easeInOutQuint: function (x, t, b, c, d) {
		if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
		return c/2*((t-=2)*t*t*t*t + 2) + b;
	},
	easeInSine: function (x, t, b, c, d) {
		return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
	},
	easeOutSine: function (x, t, b, c, d) {
		return c * Math.sin(t/d * (Math.PI/2)) + b;
	},
	easeInOutSine: function (x, t, b, c, d) {
		return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
	},
	easeInExpo: function (x, t, b, c, d) {
		return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
	},
	easeOutExpo: function (x, t, b, c, d) {
		return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
	},
	easeInOutExpo: function (x, t, b, c, d) {
		if (t==0) return b;
		if (t==d) return b+c;
		if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
		return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
	},
	easeInCirc: function (x, t, b, c, d) {
		return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
	},
	easeOutCirc: function (x, t, b, c, d) {
		return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
	},
	easeInOutCirc: function (x, t, b, c, d) {
		if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
		return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
	},
	easeInElastic: function (x, t, b, c, d) {
		var s=1.70158;var p=0;var a=c;
		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
		if (a < Math.abs(c)) { a=c; var s=p/4; }
		else var s = p/(2*Math.PI) * Math.asin (c/a);
		return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
	},
	easeOutElastic: function (x, t, b, c, d) {
		var s=1.70158;var p=0;var a=c;
		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
		if (a < Math.abs(c)) { a=c; var s=p/4; }
		else var s = p/(2*Math.PI) * Math.asin (c/a);
		return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
	},
	easeInOutElastic: function (x, t, b, c, d) {
		var s=1.70158;var p=0;var a=c;
		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
		if (a < Math.abs(c)) { a=c; var s=p/4; }
		else var s = p/(2*Math.PI) * Math.asin (c/a);
		if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
		return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
	},
	easeInBack: function (x, t, b, c, d, s) {
		if (s == undefined) s = 1.70158;
		return c*(t/=d)*t*((s+1)*t - s) + b;
	},
	easeOutBack: function (x, t, b, c, d, s) {
		if (s == undefined) s = 1.70158;
		return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
	},
	easeInOutBack: function (x, t, b, c, d, s) {
		if (s == undefined) s = 1.70158;
		if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
		return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
	},
	easeInBounce: function (x, t, b, c, d) {
		return c - $.easing.easeOutBounce (x, d-t, 0, c, d) + b;
	},
	easeOutBounce: function (x, t, b, c, d) {
		if ((t/=d) < (1/2.75)) {
			return c*(7.5625*t*t) + b;
		} else if (t < (2/2.75)) {
			return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
		} else if (t < (2.5/2.75)) {
			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
		} else {
			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
		}
	},
	easeInOutBounce: function (x, t, b, c, d) {
		if (t < d/2) return $.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
		return $.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
	}
});

/*
 *
 * TERMS OF USE - EASING EQUATIONS
 *
 * Open source under the BSD License.
 *
 * Copyright 2001 Robert Penner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * Neither the name of the author nor the names of contributors may be used to endorse
 * or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

})(jQuery);
/*
 * jQuery UI Effects Blind 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Blind
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.blind = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
		var direction = o.options.direction || 'vertical'; // Default direction

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
		var ref = (direction == 'vertical') ? 'height' : 'width';
		var distance = (direction == 'vertical') ? wrapper.height() : wrapper.width();
		if(mode == 'show') wrapper.css(ref, 0); // Shift

		// Animation
		var animation = {};
		animation[ref] = mode == 'show' ? distance : 0;

		// Animate
		wrapper.animate(animation, o.duration, o.options.easing, function() {
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(el[0], arguments); // Callback
			el.dequeue();
		});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Bounce 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Bounce
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.bounce = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
		var direction = o.options.direction || 'up'; // Default direction
		var distance = o.options.distance || 20; // Default distance
		var times = o.options.times || 5; // Default # of times
		var speed = o.duration || 250; // Default speed per bounce
		if (/show|hide/.test(mode)) props.push('opacity'); // Avoid touching opacity to prevent clearType and PNG issues in IE

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		$.effects.createWrapper(el); // Create Wrapper
		var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
		var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
		var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) / 3 : el.outerWidth({margin:true}) / 3);
		if (mode == 'show') el.css('opacity', 0).css(ref, motion == 'pos' ? -distance : distance); // Shift
		if (mode == 'hide') distance = distance / (times * 2);
		if (mode != 'hide') times--;

		// Animate
		if (mode == 'show') { // Show Bounce
			var animation = {opacity: 1};
			animation[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
			el.animate(animation, speed / 2, o.options.easing);
			distance = distance / 2;
			times--;
		};
		for (var i = 0; i < times; i++) { // Bounces
			var animation1 = {}, animation2 = {};
			animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
			animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
			el.animate(animation1, speed / 2, o.options.easing).animate(animation2, speed / 2, o.options.easing);
			distance = (mode == 'hide') ? distance * 2 : distance / 2;
		};
		if (mode == 'hide') { // Last Bounce
			var animation = {opacity: 0};
			animation[ref] = (motion == 'pos' ? '-=' : '+=')  + distance;
			el.animate(animation, speed / 2, o.options.easing, function(){
				el.hide(); // Hide
				$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
				if(o.callback) o.callback.apply(this, arguments); // Callback
			});
		} else {
			var animation1 = {}, animation2 = {};
			animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
			animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
			el.animate(animation1, speed / 2, o.options.easing).animate(animation2, speed / 2, o.options.easing, function(){
				$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
				if(o.callback) o.callback.apply(this, arguments); // Callback
			});
		};
		el.queue('fx', function() { el.dequeue(); });
		el.dequeue();
	});

};

})(jQuery);
/*
 * jQuery UI Effects Clip 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Clip
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.clip = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right','height','width'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
		var direction = o.options.direction || 'vertical'; // Default direction

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
		var animate = el[0].tagName == 'IMG' ? wrapper : el;
		var ref = {
			size: (direction == 'vertical') ? 'height' : 'width',
			position: (direction == 'vertical') ? 'top' : 'left'
		};
		var distance = (direction == 'vertical') ? animate.height() : animate.width();
		if(mode == 'show') { animate.css(ref.size, 0); animate.css(ref.position, distance / 2); } // Shift

		// Animation
		var animation = {};
		animation[ref.size] = mode == 'show' ? distance : 0;
		animation[ref.position] = mode == 'show' ? 0 : distance / 2;

		// Animate
		animate.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(el[0], arguments); // Callback
			el.dequeue();
		}});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Drop 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Drop
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.drop = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right','opacity'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
		var direction = o.options.direction || 'left'; // Default Direction

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		$.effects.createWrapper(el); // Create Wrapper
		var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
		var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
		var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) / 2 : el.outerWidth({margin:true}) / 2);
		if (mode == 'show') el.css('opacity', 0).css(ref, motion == 'pos' ? -distance : distance); // Shift

		// Animation
		var animation = {opacity: mode == 'show' ? 1 : 0};
		animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;

		// Animate
		el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(this, arguments); // Callback
			el.dequeue();
		}});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Explode 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Explode
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.explode = function(o) {

	return this.queue(function() {

	var rows = o.options.pieces ? Math.round(Math.sqrt(o.options.pieces)) : 3;
	var cells = o.options.pieces ? Math.round(Math.sqrt(o.options.pieces)) : 3;

	o.options.mode = o.options.mode == 'toggle' ? ($(this).is(':visible') ? 'hide' : 'show') : o.options.mode;
	var el = $(this).show().css('visibility', 'hidden');
	var offset = el.offset();

	//Substract the margins - not fixing the problem yet.
	offset.top -= parseInt(el.css("marginTop"),10) || 0;
	offset.left -= parseInt(el.css("marginLeft"),10) || 0;

	var width = el.outerWidth(true);
	var height = el.outerHeight(true);

	for(var i=0;i<rows;i++) { // =
		for(var j=0;j<cells;j++) { // ||
			el
				.clone()
				.appendTo('body')
				.wrap('<div></div>')
				.css({
					position: 'absolute',
					visibility: 'visible',
					left: -j*(width/cells),
					top: -i*(height/rows)
				})
				.parent()
				.addClass('ui-effects-explode')
				.css({
					position: 'absolute',
					overflow: 'hidden',
					width: width/cells,
					height: height/rows,
					left: offset.left + j*(width/cells) + (o.options.mode == 'show' ? (j-Math.floor(cells/2))*(width/cells) : 0),
					top: offset.top + i*(height/rows) + (o.options.mode == 'show' ? (i-Math.floor(rows/2))*(height/rows) : 0),
					opacity: o.options.mode == 'show' ? 0 : 1
				}).animate({
					left: offset.left + j*(width/cells) + (o.options.mode == 'show' ? 0 : (j-Math.floor(cells/2))*(width/cells)),
					top: offset.top + i*(height/rows) + (o.options.mode == 'show' ? 0 : (i-Math.floor(rows/2))*(height/rows)),
					opacity: o.options.mode == 'show' ? 1 : 0
				}, o.duration || 500);
		}
	}

	// Set a timeout, to call the callback approx. when the other animations have finished
	setTimeout(function() {

		o.options.mode == 'show' ? el.css({ visibility: 'visible' }) : el.css({ visibility: 'visible' }).hide();
				if(o.callback) o.callback.apply(el[0]); // Callback
				el.dequeue();

				$('div.ui-effects-explode').remove();

	}, o.duration || 500);


	});

};

})(jQuery);
/*
 * jQuery UI Effects Fade 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Fade
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.fade = function(o) {
	return this.queue(function() {
		var elem = $(this),
			mode = $.effects.setMode(elem, o.options.mode || 'hide');

		elem.animate({ opacity: mode }, {
			queue: false,
			duration: o.duration,
			easing: o.options.easing,
			complete: function() {
				(o.callback && o.callback.apply(this, arguments));
				elem.dequeue();
			}
		});
	});
};

})(jQuery);
/*
 * jQuery UI Effects Fold 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Fold
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.fold = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
		var size = o.options.size || 15; // Default fold size
		var horizFirst = !(!o.options.horizFirst); // Ensure a boolean value
		var duration = o.duration ? o.duration / 2 : $.fx.speeds._default / 2;

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
		var widthFirst = ((mode == 'show') != horizFirst);
		var ref = widthFirst ? ['width', 'height'] : ['height', 'width'];
		var distance = widthFirst ? [wrapper.width(), wrapper.height()] : [wrapper.height(), wrapper.width()];
		var percent = /([0-9]+)%/.exec(size);
		if(percent) size = parseInt(percent[1],10) / 100 * distance[mode == 'hide' ? 0 : 1];
		if(mode == 'show') wrapper.css(horizFirst ? {height: 0, width: size} : {height: size, width: 0}); // Shift

		// Animation
		var animation1 = {}, animation2 = {};
		animation1[ref[0]] = mode == 'show' ? distance[0] : size;
		animation2[ref[1]] = mode == 'show' ? distance[1] : 0;

		// Animate
		wrapper.animate(animation1, duration, o.options.easing)
		.animate(animation2, duration, o.options.easing, function() {
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(el[0], arguments); // Callback
			el.dequeue();
		});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Highlight 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Highlight
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.highlight = function(o) {
	return this.queue(function() {
		var elem = $(this),
			props = ['backgroundImage', 'backgroundColor', 'opacity'],
			mode = $.effects.setMode(elem, o.options.mode || 'show'),
			animation = {
				backgroundColor: elem.css('backgroundColor')
			};

		if (mode == 'hide') {
			animation.opacity = 0;
		}

		$.effects.save(elem, props);
		elem
			.show()
			.css({
				backgroundImage: 'none',
				backgroundColor: o.options.color || '#ffff99'
			})
			.animate(animation, {
				queue: false,
				duration: o.duration,
				easing: o.options.easing,
				complete: function() {
					(mode == 'hide' && elem.hide());
					$.effects.restore(elem, props);
					(mode == 'show' && !$.support.opacity && this.style.removeAttribute('filter'));
					(o.callback && o.callback.apply(this, arguments));
					elem.dequeue();
				}
			});
	});
};

})(jQuery);
/*
 * jQuery UI Effects Pulsate 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Pulsate
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.pulsate = function(o) {
	return this.queue(function() {
		var elem = $(this),
			mode = $.effects.setMode(elem, o.options.mode || 'show');
			times = ((o.options.times || 5) * 2) - 1;
			duration = o.duration ? o.duration / 2 : $.fx.speeds._default / 2,
			isVisible = elem.is(':visible'),
			animateTo = 0;

		if (!isVisible) {
			elem.css('opacity', 0).show();
			animateTo = 1;
		}

		if ((mode == 'hide' && isVisible) || (mode == 'show' && !isVisible)) {
			times--;
		}

		for (var i = 0; i < times; i++) {
			elem.animate({ opacity: animateTo }, duration, o.options.easing);
			animateTo = (animateTo + 1) % 2;
		}

		elem.animate({ opacity: animateTo }, duration, o.options.easing, function() {
			if (animateTo == 0) {
				elem.hide();
			}
			(o.callback && o.callback.apply(this, arguments));
		});

		elem
			.queue('fx', function() { elem.dequeue(); })
			.dequeue();
	});
};

})(jQuery);
/*
 * jQuery UI Effects Scale 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Scale
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.puff = function(o) {
	return this.queue(function() {
		var elem = $(this),
			mode = $.effects.setMode(elem, o.options.mode || 'hide'),
			percent = parseInt(o.options.percent, 10) || 150,
			factor = percent / 100,
			original = { height: elem.height(), width: elem.width() };

		$.extend(o.options, {
			fade: true,
			mode: mode,
			percent: mode == 'hide' ? percent : 100,
			from: mode == 'hide'
				? original
				: {
					height: original.height * factor,
					width: original.width * factor
				}
		});

		elem.effect('scale', o.options, o.duration, o.callback);
		elem.dequeue();
	});
};

$.effects.scale = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this);

		// Set options
		var options = $.extend(true, {}, o.options);
		var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
		var percent = parseInt(o.options.percent,10) || (parseInt(o.options.percent,10) == 0 ? 0 : (mode == 'hide' ? 0 : 100)); // Set default scaling percent
		var direction = o.options.direction || 'both'; // Set default axis
		var origin = o.options.origin; // The origin of the scaling
		if (mode != 'effect') { // Set default origin and restore for show/hide
			options.origin = origin || ['middle','center'];
			options.restore = true;
		}
		var original = {height: el.height(), width: el.width()}; // Save original
		el.from = o.options.from || (mode == 'show' ? {height: 0, width: 0} : original); // Default from state

		// Adjust
		var factor = { // Set scaling factor
			y: direction != 'horizontal' ? (percent / 100) : 1,
			x: direction != 'vertical' ? (percent / 100) : 1
		};
		el.to = {height: original.height * factor.y, width: original.width * factor.x}; // Set to state

		if (o.options.fade) { // Fade option to support puff
			if (mode == 'show') {el.from.opacity = 0; el.to.opacity = 1;};
			if (mode == 'hide') {el.from.opacity = 1; el.to.opacity = 0;};
		};

		// Animation
		options.from = el.from; options.to = el.to; options.mode = mode;

		// Animate
		el.effect('size', options, o.duration, o.callback);
		el.dequeue();
	});

};

$.effects.size = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right','width','height','overflow','opacity'];
		var props1 = ['position','top','bottom','left','right','overflow','opacity']; // Always restore
		var props2 = ['width','height','overflow']; // Copy for children
		var cProps = ['fontSize'];
		var vProps = ['borderTopWidth', 'borderBottomWidth', 'paddingTop', 'paddingBottom'];
		var hProps = ['borderLeftWidth', 'borderRightWidth', 'paddingLeft', 'paddingRight'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
		var restore = o.options.restore || false; // Default restore
		var scale = o.options.scale || 'both'; // Default scale mode
		var origin = o.options.origin; // The origin of the sizing
		var original = {height: el.height(), width: el.width()}; // Save original
		el.from = o.options.from || original; // Default from state
		el.to = o.options.to || original; // Default to state
		// Adjust
		if (origin) { // Calculate baseline shifts
			var baseline = $.effects.getBaseline(origin, original);
			el.from.top = (original.height - el.from.height) * baseline.y;
			el.from.left = (original.width - el.from.width) * baseline.x;
			el.to.top = (original.height - el.to.height) * baseline.y;
			el.to.left = (original.width - el.to.width) * baseline.x;
		};
		var factor = { // Set scaling factor
			from: {y: el.from.height / original.height, x: el.from.width / original.width},
			to: {y: el.to.height / original.height, x: el.to.width / original.width}
		};
		if (scale == 'box' || scale == 'both') { // Scale the css box
			if (factor.from.y != factor.to.y) { // Vertical props scaling
				props = props.concat(vProps);
				el.from = $.effects.setTransition(el, vProps, factor.from.y, el.from);
				el.to = $.effects.setTransition(el, vProps, factor.to.y, el.to);
			};
			if (factor.from.x != factor.to.x) { // Horizontal props scaling
				props = props.concat(hProps);
				el.from = $.effects.setTransition(el, hProps, factor.from.x, el.from);
				el.to = $.effects.setTransition(el, hProps, factor.to.x, el.to);
			};
		};
		if (scale == 'content' || scale == 'both') { // Scale the content
			if (factor.from.y != factor.to.y) { // Vertical props scaling
				props = props.concat(cProps);
				el.from = $.effects.setTransition(el, cProps, factor.from.y, el.from);
				el.to = $.effects.setTransition(el, cProps, factor.to.y, el.to);
			};
		};
		$.effects.save(el, restore ? props : props1); el.show(); // Save & Show
		$.effects.createWrapper(el); // Create Wrapper
		el.css('overflow','hidden').css(el.from); // Shift

		// Animate
		if (scale == 'content' || scale == 'both') { // Scale the children
			vProps = vProps.concat(['marginTop','marginBottom']).concat(cProps); // Add margins/font-size
			hProps = hProps.concat(['marginLeft','marginRight']); // Add margins
			props2 = props.concat(vProps).concat(hProps); // Concat
			el.find("*[width]").each(function(){
				child = $(this);
				if (restore) $.effects.save(child, props2);
				var c_original = {height: child.height(), width: child.width()}; // Save original
				child.from = {height: c_original.height * factor.from.y, width: c_original.width * factor.from.x};
				child.to = {height: c_original.height * factor.to.y, width: c_original.width * factor.to.x};
				if (factor.from.y != factor.to.y) { // Vertical props scaling
					child.from = $.effects.setTransition(child, vProps, factor.from.y, child.from);
					child.to = $.effects.setTransition(child, vProps, factor.to.y, child.to);
				};
				if (factor.from.x != factor.to.x) { // Horizontal props scaling
					child.from = $.effects.setTransition(child, hProps, factor.from.x, child.from);
					child.to = $.effects.setTransition(child, hProps, factor.to.x, child.to);
				};
				child.css(child.from); // Shift children
				child.animate(child.to, o.duration, o.options.easing, function(){
					if (restore) $.effects.restore(child, props2); // Restore children
				}); // Animate children
			});
		};

		// Animate
		el.animate(el.to, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
			if (el.to.opacity === 0) {
				el.css('opacity', el.from.opacity);
			}
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, restore ? props : props1); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(this, arguments); // Callback
			el.dequeue();
		}});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Shake 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Shake
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.shake = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
		var direction = o.options.direction || 'left'; // Default direction
		var distance = o.options.distance || 20; // Default distance
		var times = o.options.times || 3; // Default # of times
		var speed = o.duration || o.options.duration || 140; // Default speed per shake

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		$.effects.createWrapper(el); // Create Wrapper
		var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
		var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';

		// Animation
		var animation = {}, animation1 = {}, animation2 = {};
		animation[ref] = (motion == 'pos' ? '-=' : '+=')  + distance;
		animation1[ref] = (motion == 'pos' ? '+=' : '-=')  + distance * 2;
		animation2[ref] = (motion == 'pos' ? '-=' : '+=')  + distance * 2;

		// Animate
		el.animate(animation, speed, o.options.easing);
		for (var i = 1; i < times; i++) { // Shakes
			el.animate(animation1, speed, o.options.easing).animate(animation2, speed, o.options.easing);
		};
		el.animate(animation1, speed, o.options.easing).
		animate(animation, speed / 2, o.options.easing, function(){ // Last shake
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(this, arguments); // Callback
		});
		el.queue('fx', function() { el.dequeue(); });
		el.dequeue();
	});

};

})(jQuery);
/*
 * jQuery UI Effects Slide 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Slide
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.slide = function(o) {

	return this.queue(function() {

		// Create element
		var el = $(this), props = ['position','top','bottom','left','right'];

		// Set options
		var mode = $.effects.setMode(el, o.options.mode || 'show'); // Set Mode
		var direction = o.options.direction || 'left'; // Default Direction

		// Adjust
		$.effects.save(el, props); el.show(); // Save & Show
		$.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
		var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
		var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
		var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) : el.outerWidth({margin:true}));
		if (mode == 'show') el.css(ref, motion == 'pos' ? (isNaN(distance) ? "-" + distance : -distance) : distance); // Shift

		// Animation
		var animation = {};
		animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;

		// Animate
		el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
			if(mode == 'hide') el.hide(); // Hide
			$.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
			if(o.callback) o.callback.apply(this, arguments); // Callback
			el.dequeue();
		}});

	});

};

})(jQuery);
/*
 * jQuery UI Effects Transfer 1.8.11
 *
 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/Transfer
 *
 * Depends:
 *	jquery.effects.core.js
 */
(function( $, undefined ) {

$.effects.transfer = function(o) {
	return this.queue(function() {
		var elem = $(this),
			target = $(o.options.to),
			endPosition = target.offset(),
			animation = {
				top: endPosition.top,
				left: endPosition.left,
				height: target.innerHeight(),
				width: target.innerWidth()
			},
			startPosition = elem.offset(),
			transfer = $('<div class="ui-effects-transfer"></div>')
				.appendTo(document.body)
				.addClass(o.options.className)
				.css({
					top: startPosition.top,
					left: startPosition.left,
					height: elem.innerHeight(),
					width: elem.innerWidth(),
					position: 'absolute'
				})
				.animate(animation, o.duration, o.options.easing, function() {
					transfer.remove();
					(o.callback && o.callback.apply(elem[0], arguments));
					elem.dequeue();
				});
	});
};

})(jQuery);
;
/*
 * Original script by Josh Fraser (http://www.onlineaspect.com)
 * Continued and maintained by Jon Nylander at https://bitbucket.org/pellepim/jstimezonedetect
 *
 * Provided under the Do Whatever You Want With This Code License.
 */

/**
 * Namespace to hold all the code for timezone detection.
 */
var jstz = (function () {
    'use strict';
    var HEMISPHERE_SOUTH = 's',

        /**
         * Gets the offset in minutes from UTC for a certain date.
         * @param {Date} date
         * @returns {Number}
         */
        get_date_offset = function (date) {
            var offset = -date.getTimezoneOffset();
            return (offset !== null ? offset : 0);
        },

        get_january_offset = function () {
            return get_date_offset(new Date(2010, 0, 1, 0, 0, 0, 0));
        },

        get_june_offset = function () {
            return get_date_offset(new Date(2010, 5, 1, 0, 0, 0, 0));
        },

        /**
         * Private method.
         * Checks whether a given date is in daylight savings time.
         * If the date supplied is after june, we assume that we're checking
         * for southern hemisphere DST.
         * @param {Date} date
         * @returns {Boolean}
         */
        date_is_dst = function (date) {
            var base_offset = ((date.getMonth() > 5 ? get_june_offset()
                                                : get_january_offset())),
                date_offset = get_date_offset(date);

            return (base_offset - date_offset) !== 0;
        },

        /**
         * This function does some basic calculations to create information about
         * the user's timezone.
         *
         * Returns a key that can be used to do lookups in jstz.olson.timezones.
         *
         * @returns {String}
         */

        lookup_key = function () {
            var january_offset = get_january_offset(),
                june_offset = get_june_offset(),
                diff = get_january_offset() - get_june_offset();

            if (diff < 0) {
                return january_offset + ",1";
            } else if (diff > 0) {
                return june_offset + ",1," + HEMISPHERE_SOUTH;
            }

            return january_offset + ",0";
        },

        /**
         * Uses get_timezone_info() to formulate a key to use in the olson.timezones dictionary.
         *
         * Returns a primitive object on the format:
         * {'timezone': TimeZone, 'key' : 'the key used to find the TimeZone object'}
         *
         * @returns Object
         */
        determine_timezone = function () {
            var key = lookup_key();
            return new jstz.TimeZone(jstz.olson.timezones[key]);
        };

    return {
        determine_timezone : determine_timezone,
        date_is_dst : date_is_dst
    };
}());

/**
 * A simple object containing information of utc_offset, which olson timezone key to use,
 * and if the timezone cares about daylight savings or not.
 *
 * @constructor
 * @param {string} offset - for example '-11:00'
 * @param {string} olson_tz - the olson Identifier, such as "America/Denver"
 * @param {boolean} uses_dst - flag for whether the time zone somehow cares about daylight savings.
 */
jstz.TimeZone = (function () {
    'use strict';
    var timezone_name = null,
        uses_dst = null,
        utc_offset = null,

        name = function () {
            return timezone_name;
        },

        dst = function () {
            return uses_dst;
        },

        offset = function () {
            return utc_offset;
        },

        /**
         * Checks if a timezone has possible ambiguities. I.e timezones that are similar.
         *
         * If the preliminary scan determines that we're in America/Denver. We double check
         * here that we're really there and not in America/Mazatlan.
         *
         * This is done by checking known dates for when daylight savings start for different
         * timezones.
         */
        ambiguity_check = function () {
            var ambiguity_list = jstz.olson.ambiguity_list[timezone_name],
                length = ambiguity_list.length,
                i = 0,
                tz = ambiguity_list[0];

            for (; i < length; i += 1) {
                tz = ambiguity_list[i];

                if (jstz.date_is_dst(jstz.olson.dst_start_dates[tz])) {
                    timezone_name = tz;
                    return;
                }
            }
        },

        /**
         * Checks if it is possible that the timezone is ambiguous.
         */
        is_ambiguous = function () {
            return typeof (jstz.olson.ambiguity_list[timezone_name]) !== 'undefined';
        },

        /**
        * Constructor for jstz.TimeZone
        */
        Constr = function (tz_info) {
            utc_offset = tz_info[0];
            timezone_name = tz_info[1];
            uses_dst = tz_info[2];
            if (is_ambiguous()) {
                ambiguity_check();
            }
        };

    /**
     * Public API for jstz.TimeZone
     */
    Constr.prototype = {
        constructor : jstz.TimeZone,
        name : name,
        dst : dst,
        offset : offset
    };

    return Constr;
}());

jstz.olson = {};

/*
 * The keys in this dictionary are comma separated as such:
 *
 * First the offset compared to UTC time in minutes.
 *
 * Then a flag which is 0 if the timezone does not take daylight savings into account and 1 if it
 * does.
 *
 * Thirdly an optional 's' signifies that the timezone is in the southern hemisphere,
 * only interesting for timezones with DST.
 *
 * The mapped arrays is used for constructing the jstz.TimeZone object from within
 * jstz.determine_timezone();
 */
jstz.olson.timezones = (function () {
    "use strict";
    return {
        '-720,0'   : ['-12:00', 'Etc/GMT+12', false],
        '-660,0'   : ['-11:00', 'Pacific/Pago_Pago', false],
        '-600,1'   : ['-11:00', 'America/Adak', true],
        '-660,1,s' : ['-11:00', 'Pacific/Apia', true],
        '-600,0'   : ['-10:00', 'Pacific/Honolulu', false],
        '-570,0'   : ['-09:30', 'Pacific/Marquesas', false],
        '-540,0'   : ['-09:00', 'Pacific/Gambier', false],
        '-540,1'   : ['-09:00', 'America/Anchorage', true],
        '-480,1'   : ['-08:00', 'America/Los_Angeles', true],
        '-480,0'   : ['-08:00', 'Pacific/Pitcairn', false],
        '-420,0'   : ['-07:00', 'America/Phoenix', false],
        '-420,1'   : ['-07:00', 'America/Denver', true],
        '-360,0'   : ['-06:00', 'America/Guatemala', false],
        '-360,1'   : ['-06:00', 'America/Chicago', true],
        '-360,1,s' : ['-06:00', 'Pacific/Easter', true],
        '-300,0'   : ['-05:00', 'America/Bogota', false],
        '-300,1'   : ['-05:00', 'America/New_York', true],
        '-270,0'   : ['-04:30', 'America/Caracas', false],
        '-240,1'   : ['-04:00', 'America/Halifax', true],
        '-240,0'   : ['-04:00', 'America/Santo_Domingo', false],
        '-240,1,s' : ['-04:00', 'America/Asuncion', true],
        '-210,1'   : ['-03:30', 'America/St_Johns', true],
        '-180,1'   : ['-03:00', 'America/Godthab', true],
        '-180,0'   : ['-03:00', 'America/Argentina/Buenos_Aires', false],
        '-180,1,s' : ['-03:00', 'America/Montevideo', true],
        '-120,0'   : ['-02:00', 'America/Noronha', false],
        '-120,1'   : ['-02:00', 'Etc/GMT+2', true],
        '-60,1'    : ['-01:00', 'Atlantic/Azores', true],
        '-60,0'    : ['-01:00', 'Atlantic/Cape_Verde', false],
        '0,0'      : ['00:00', 'Etc/UTC', false],
        '0,1'      : ['00:00', 'Europe/London', true],
        '60,1'     : ['+01:00', 'Europe/Berlin', true],
        '60,0'     : ['+01:00', 'Africa/Lagos', false],
        '60,1,s'   : ['+01:00', 'Africa/Windhoek', true],
        '120,1'    : ['+02:00', 'Asia/Beirut', true],
        '120,0'    : ['+02:00', 'Africa/Johannesburg', false],
        '180,1'    : ['+03:00', 'Europe/Moscow', true],
        '180,0'    : ['+03:00', 'Asia/Baghdad', false],
        '210,1'    : ['+03:30', 'Asia/Tehran', true],
        '240,0'    : ['+04:00', 'Asia/Dubai', false],
        '240,1'    : ['+04:00', 'Asia/Yerevan', true],
        '270,0'    : ['+04:30', 'Asia/Kabul', false],
        '300,1'    : ['+05:00', 'Asia/Yekaterinburg', true],
        '300,0'    : ['+05:00', 'Asia/Karachi', false],
        '330,0'    : ['+05:30', 'Asia/Kolkata', false],
        '345,0'    : ['+05:45', 'Asia/Kathmandu', false],
        '360,0'    : ['+06:00', 'Asia/Dhaka', false],
        '360,1'    : ['+06:00', 'Asia/Omsk', true],
        '390,0'    : ['+06:30', 'Asia/Rangoon', false],
        '420,1'    : ['+07:00', 'Asia/Krasnoyarsk', true],
        '420,0'    : ['+07:00', 'Asia/Jakarta', false],
        '480,0'    : ['+08:00', 'Asia/Shanghai', false],
        '480,1'    : ['+08:00', 'Asia/Irkutsk', true],
        '525,0'    : ['+08:45', 'Australia/Eucla', true],
        '525,1,s'  : ['+08:45', 'Australia/Eucla', true],
        '540,1'    : ['+09:00', 'Asia/Yakutsk', true],
        '540,0'    : ['+09:00', 'Asia/Tokyo', false],
        '570,0'    : ['+09:30', 'Australia/Darwin', false],
        '570,1,s'  : ['+09:30', 'Australia/Adelaide', true],
        '600,0'    : ['+10:00', 'Australia/Brisbane', false],
        '600,1'    : ['+10:00', 'Asia/Vladivostok', true],
        '600,1,s'  : ['+10:00', 'Australia/Sydney', true],
        '630,1,s'  : ['+10:30', 'Australia/Lord_Howe', true],
        '660,1'    : ['+11:00', 'Asia/Kamchatka', true],
        '660,0'    : ['+11:00', 'Pacific/Noumea', false],
        '690,0'    : ['+11:30', 'Pacific/Norfolk', false],
        '720,1,s'  : ['+12:00', 'Pacific/Auckland', true],
        '720,0'    : ['+12:00', 'Pacific/Tarawa', false],
        '765,1,s'  : ['+12:45', 'Pacific/Chatham', true],
        '780,0'    : ['+13:00', 'Pacific/Tongatapu', false],
        '840,0'    : ['+14:00', 'Pacific/Kiritimati', false]
    };
}());

/**
 * This object contains information on when daylight savings starts for
 * different timezones.
 *
 * The list is short for a reason. Often we do not have to be very specific
 * to single out the correct timezone. But when we do, this list comes in
 * handy.
 *
 * Each value is a date denoting when daylight savings starts for that timezone.
 */
jstz.olson.dst_start_dates = (function () {
    "use strict";
    return {
        'America/Denver' : new Date(2011, 2, 13, 3, 0, 0, 0),
        'America/Mazatlan' : new Date(2011, 3, 3, 3, 0, 0, 0),
        'America/Chicago' : new Date(2011, 2, 13, 3, 0, 0, 0),
        'America/Mexico_City' : new Date(2011, 3, 3, 3, 0, 0, 0),
        'Atlantic/Stanley' : new Date(2011, 8, 4, 7, 0, 0, 0),
        'America/Asuncion' : new Date(2011, 9, 2, 3, 0, 0, 0),
        'America/Santiago' : new Date(2011, 9, 9, 3, 0, 0, 0),
        'America/Campo_Grande' : new Date(2011, 9, 16, 5, 0, 0, 0),
        'America/Montevideo' : new Date(2011, 9, 2, 3, 0, 0, 0),
        'America/Sao_Paulo' : new Date(2011, 9, 16, 5, 0, 0, 0),
        'America/Los_Angeles' : new Date(2011, 2, 13, 8, 0, 0, 0),
        'America/Santa_Isabel' : new Date(2011, 3, 5, 8, 0, 0, 0),
        'America/Havana' : new Date(2011, 2, 13, 2, 0, 0, 0),
        'America/New_York' : new Date(2011, 2, 13, 7, 0, 0, 0),
        'Asia/Gaza' : new Date(2011, 2, 26, 23, 0, 0, 0),
        'Asia/Beirut' : new Date(2011, 2, 27, 1, 0, 0, 0),
        'Europe/Minsk' : new Date(2011, 2, 27, 2, 0, 0, 0),
        'Europe/Helsinki' : new Date(2011, 2, 27, 4, 0, 0, 0),
        'Europe/Istanbul' : new Date(2011, 2, 28, 5, 0, 0, 0),
        'Asia/Damascus' : new Date(2011, 3, 1, 2, 0, 0, 0),
        'Asia/Jerusalem' : new Date(2011, 3, 1, 6, 0, 0, 0),
        'Africa/Cairo' : new Date(2010, 3, 30, 4, 0, 0, 0),
        'Asia/Yerevan' : new Date(2011, 2, 27, 4, 0, 0, 0),
        'Asia/Baku'    : new Date(2011, 2, 27, 8, 0, 0, 0),
        'Pacific/Auckland' : new Date(2011, 8, 26, 7, 0, 0, 0),
        'Pacific/Fiji' : new Date(2010, 11, 29, 23, 0, 0, 0),
        'America/Halifax' : new Date(2011, 2, 13, 6, 0, 0, 0),
        'America/Goose_Bay' : new Date(2011, 2, 13, 2, 1, 0, 0),
        'America/Miquelon' : new Date(2011, 2, 13, 5, 0, 0, 0),
        'America/Godthab' : new Date(2011, 2, 27, 1, 0, 0, 0)
    };
}());

/**
 * The keys in this object are timezones that we know may be ambiguous after
 * a preliminary scan through the olson_tz object.
 *
 * The array of timezones to compare must be in the order that daylight savings
 * starts for the regions.
 */
jstz.olson.ambiguity_list = {
    'America/Denver' : ['America/Denver', 'America/Mazatlan'],
    'America/Chicago' : ['America/Chicago', 'America/Mexico_City'],
    'America/Asuncion' : ['Atlantic/Stanley', 'America/Asuncion', 'America/Santiago', 'America/Campo_Grande'],
    'America/Montevideo' : ['America/Montevideo', 'America/Sao_Paulo'],
    'Asia/Beirut' : ['Asia/Gaza', 'Asia/Beirut', 'Europe/Minsk', 'Europe/Helsinki', 'Europe/Istanbul', 'Asia/Damascus', 'Asia/Jerusalem', 'Africa/Cairo'],
    'Asia/Yerevan' : ['Asia/Yerevan', 'Asia/Baku'],
    'Pacific/Auckland' : ['Pacific/Auckland', 'Pacific/Fiji'],
    'America/Los_Angeles' : ['America/Los_Angeles', 'America/Santa_Isabel'],
    'America/New_York' : ['America/Havana', 'America/New_York'],
    'America/Halifax' : ['America/Goose_Bay', 'America/Halifax'],
    'America/Godthab' : ['America/Miquelon', 'America/Godthab']
};
;
_coveoJQuery = $.noConflict(true);;
//! Script# Browser Compat Layer
//!


function __loadCompatLayer(w) {
    var opera = (window.navigator.userAgent.indexOf('Opera') >= 0);
    var firefox = (window.navigator.userAgent.indexOf('Gecko') >= 0);

    w.__getNonTextNode = function(node) {
        try {
            while (node && (node.nodeType != 1)) {
                node = node.parentNode;
            }
        }
        catch (ex) {
            node = null;
        }
        return node;
    };
    
    w.__getLocation = function(e) {
        var loc = {x : 0, y : 0};
        while (e) {
            loc.x += e.offsetLeft;
            loc.y += e.offsetTop;
            e = e.offsetParent;
        }
        return loc;
    };
    
    function addFunction(object, name, callback) {
        if (!object[name]) {
            object[name] = callback;
        }
    }
    
    function addGetter(proto, name, callback) {
        if (!proto.__lookupGetter__ || (proto.__lookupGetter__(name) === undefined)) {
            proto.__defineGetter__(name, callback);
        }    
    }
    
    function addSetter(proto, name, callback) {
        if (!proto.__lookupSetter__ || (proto.__lookupSetter__(name) === undefined)) {
            proto.__defineSetter__(name, callback);
        }    
    }

    addFunction(w, 'navigate', function(url) {
        window.setTimeout('window.location = "' + url + '";', 0);
    });
    
    function saveEvent(e) {
        window.event = e;
    }

    var attachEventProxy = function(eventName, eventHandler) {
        var eventName = eventName.slice(2);

        if ((eventName == 'mousewheel') && (opera || firefox)) {
            eventName = 'DOMMouseScroll';
        }
        
        this.addEventListener(eventName, saveEvent, true);
        this.addEventListener(eventName, eventHandler, false);
        return true;
    };

    var detachEventProxy = function (eventName, eventHandler) {
        var eventName = eventName.slice(2);

        if ((eventName == 'mousewheel') && (opera || firefox)) {
            eventName = 'DOMMouseScroll';
        }
        
        this.removeEventListener(eventName, saveEvent, true);
        this.removeEventListener(eventName, eventHandler, false);
    };

    addFunction(w, 'attachEvent', attachEventProxy);
    addFunction(w, 'detachEvent', detachEventProxy);
    addFunction(w.HTMLDocument.prototype, 'attachEvent', attachEventProxy);
    addFunction(w.HTMLDocument.prototype, 'detachEvent', detachEventProxy);
    addFunction(w.HTMLElement.prototype, 'attachEvent', attachEventProxy);
    addFunction(w.HTMLElement.prototype, 'detachEvent', detachEventProxy);
    
    var eventPrototype = w.Event.prototype;
    
    addGetter(eventPrototype, 'srcElement', function() {
        // __getNonTextNode(this.target) is the expected implementation.
        // However script.load has target set to the Document object... so we
        // need to throw in currentTarget as well.
        return __getNonTextNode(this.target) || this.currentTarget;
    });
    addGetter(eventPrototype, 'cancelBubble', function() {
        return this._bubblingCanceled || false;
    });
    addSetter(eventPrototype, 'cancelBubble', function(v) {
        if (v) {
            this._bubblingCanceled = true;
            this.stopPropagation();
        }
    });
    addGetter(eventPrototype, 'returnValue', function() {
        return this._cancelDefault;
    });
    addSetter(eventPrototype, 'returnValue', function(v) {
        if (!v) {
            this.preventDefault();
        }
        this._cancelDefault = v;
        return v;
    });
    addGetter(eventPrototype, 'fromElement', function () {
        var n;
        if (this.type == 'mouseover') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseout') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    addGetter(eventPrototype, 'toElement', function () {
        var n;
        if (this.type == 'mouseout') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseover') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    addGetter(eventPrototype, 'button', function() {
        return (this.which == 1) ? 1 : (this.which == 3) ? 2 : 0
    });
    addGetter(eventPrototype, 'offsetX', function() {
        return window.pageXOffset + this.clientX - __getLocation(this.srcElement).x;
    });
    addGetter(eventPrototype, 'offsetY', function() {
        return window.pageYOffset + this.clientY - __getLocation(this.srcElement).y;
    });
    
    var elementPrototype = w.HTMLElement.prototype;

    addGetter(elementPrototype, 'parentElement', function() {
        return this.parentNode;
    });
    addGetter(elementPrototype, 'children', function() {
        var children = [];
        var childCount = this.childNodes.length;
        for (var i = 0; i < childCount; i++) {
            var childNode = this.childNodes[i];
            if (childNode.nodeType == 1) {
                children.push(childNode);
            }
        }
        return children;
    });
    addGetter(elementPrototype, 'innerText', function() {    
        try {
            return this.textContent
        } 
        catch (ex) {
            var text = '';
            for (var i=0; i < this.childNodes.length; i++) {
                if (this.childNodes[i].nodeType == 3) {
                    text += this.childNodes[i].textContent;
                }
            }
            return str;
        }
    });
    addSetter(elementPrototype, 'innerText', function(v) {
        var textNode = document.createTextNode(v);
        this.innerHTML = '';
        this.appendChild(textNode);
    });
    addGetter(elementPrototype, 'currentStyle', function() {
        return window.getComputedStyle(this, null);
    });
    addGetter(elementPrototype, 'runtimeStyle', function() {
        return window.getOverrideStyle(this, null);
    });
    addFunction(elementPrototype, 'removeNode', function(b) {
        return this.parentNode ? this.parentNode.removeChild(this) : this;
    });
    addFunction(elementPrototype, 'contains', function(el) {
        while (el != null && el != this) {
            el = el.parentElement;
        }
        return (el != null);
    });

    addGetter(w.HTMLStyleElement.prototype, 'styleSheet', function() {
        return this.sheet;
    });
    
    var cssSheetPrototype = w.CSSStyleSheet.prototype;
    
    addGetter(cssSheetPrototype, 'rules', function() {
        return this.cssRules;
    });
    addFunction(cssSheetPrototype, 'addRule', function(selector, style, index) {
        this.insertRule(selector + '{' + style + '}', index);
    });
    addFunction(cssSheetPrototype, 'removeRule', function(index) {
        this.deleteRule(index);
    });
    
    var cssDecPrototype = w.CSSStyleDeclaration.prototype;
    
    addGetter(cssDecPrototype, 'styleFloat', function() {
        return this.cssFloat;
    });
    addSetter(cssDecPrototype, 'styleFloat', function(v) {
        this.cssFloat = v;
    });
    
    var docFragPrototype = DocumentFragment.prototype;
    
    addFunction(docFragPrototype, 'getElementById', function(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) {
                nodeQueue.push(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) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return null;
    });

    addFunction(docFragPrototype, 'getElementsByTagName', function(tagName) {
        var elements = [];
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;

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

        while (nodeQueue.length) {
            node = ArrayPrototype_dequeue(nodeQueue);
            if (tagName == '*' || node.tagName == tagName) {
                ArrayPrototype_add(elements, node);
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return elements;
    });

    addFunction(docFragPrototype, 'createElement', function(tagName) {
        return document.createElement(tagName);
    });

    var selectNodes = function(doc, path, contextNode) {
        if (!doc.documentElement) {
            return [];
        }

        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;
    };

    var selectSingleNode = function(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;
    };
    
    var xmlDocPrototype = w.XMLDocument.prototype;

    addFunction(xmlDocPrototype, 'selectNodes', function(path, contextNode) {
        return selectNodes(this, path, contextNode);
    });

    addFunction(xmlDocPrototype, 'selectSingleNode', function(path, contextNode) {
        return selectSingleNode(this, path, contextNode);
    });

    addFunction(xmlDocPrototype, 'transformNode', function(xsl) {
        var xslProcessor = new XSLTProcessor();
        xslProcessor.importStylesheet(xsl);

        var ownerDocument = document.implementation.createDocument("", "", null);
        var transformedDoc = xslProcessor.transformToDocument(this);
        
        return transformedDoc.xml;
    });
    
    var nodePrototype = Node.prototype;

    addFunction(nodePrototype, 'selectNodes', function(path) {
        var doc = this.ownerDocument;
        return doc.selectNodes(path, this);
    });
    addFunction(nodePrototype, 'selectSingleNode', function(path) {
        var doc = this.ownerDocument;
        return doc.selectSingleNode(path, this);
    });
    addGetter(nodePrototype, 'baseName', function() {
        return this.localName;
    });
    addGetter(nodePrototype, 'text', function() {
        return this.textContent;
    });
    addSetter(nodePrototype, 'text', function(value) {
        this.textContent = value;
    });
    addGetter(nodePrototype, 'xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });
}
function __supportsCompatLayer(ua) {
    // Supported browsers:
    //  - Firefox 1.5+
    //  - WebKit 500+
    //  - Opera 9.5+
    return (ua.indexOf('Gecko') >= 0) || (ua.indexOf('AppleWebKit') >= 0) || (ua.indexOf('Opera') >= 0);
}

if (__supportsCompatLayer(window.navigator.userAgent)) {
    try {
        __loadCompatLayer(window);
    }
    catch (e) {
    }
}
;
//! Script# Core Runtime
//! More information at http://projects.nikhilk.net/ScriptSharp
//!

///////////////////////////////////////////////////////////////////////////////
// Globals

window.ss = {
    version: '0.6.3.0',

    isUndefined: function(o) {
        return (o === undefined);
    },

    isNull: function(o) {
        return (o === null);
    },

    isNullOrUndefined: function(o) {
        return (o === null) || (o === undefined);
    }
};

(function() {
    function merge(target) {
        target = target || {};
        foreach(arguments, function(o) {
            if (o) {
                forIn(o, function(v, n) {
                    target[n] = v;
                });
            }
        }, 1);
        return target;
    }
    function forIn(obj, callback) {
        for (var x in obj) {
            callback(obj[x], x);
        }
    }
    function foreach(arr, callback, start) {
        var cancelled;
        if (arr) {
            if (!(arr instanceof Array ||
                  (typeof (arr.length) === 'number' &&
                   (typeof (arr.callee) === "function" || (arr.item && typeof (arr.nodeType) === "undefined") && !arr.addEventListener && !arr.attachEvent)))) {
                arr = [arr];
            }
            for (var i = start || 0, l = arr.length; i < l; i++) {
                if (callback(arr[i], i)) {
                    cancelled = true;
                    break;
                }
            }
        }
        return !cancelled;
    }

    var notLoading = 0, // not loading itself or any dependencies
        loading = 1,    // currently loading itself (dependencies have already loaded, executionDependencies may or may not be done)
        loadingCo = 2,  // loaded but waiting for executionDependencies
        loaded = 3,     // loaded self and all deps/codeps and execution callback executed
        attachEvent = !!document.attachEvent;

    function foreachScriptInfo(arr, callback) {
        var cancelled;
        if (arr) {
            for (var i = 0, l = arr.length; i < l; i++) {
                if (callback(getScriptInfo(arr[i]))) {
                    cancelled = true;
                    break;
                }
            }
        }
        return !cancelled;
    }
    function toIndex(arr) {
        // converts an array of strings into an object/index
        var obj = {};
        foreach(arr, function(name) {
            obj[name] = true;
        });
        return obj;
    }
    function getDependencies(scriptInfo, executionDependencies) {
        return lazyget(scriptInfo, executionDependencies ? "executionDependencies" : "dependencies");
    }
    function requireParents(scriptInfo) {
        forIn(scriptInfo["_parents"], function(parentInfo) {
            requireScript(parentInfo, null, null, true);
        });
    }
    function getScriptInfo(name) {
        return resolveScriptInfo(name) || (ss.scripts[name] = { name: name });
    }
    function requireScript(scriptInfo, callback, session, readOnly) {
        return ss.loader._requireScript(scriptInfo, callback, session, readOnly);
    }
    function requireAll(scriptInfos, callback, session, readOnly) {
        var waiting;
        foreach(scriptInfos, function(dependency) {
            dependency = resolveScriptInfo(dependency);
            waiting |= requireScript(dependency, callback, session, readOnly);
        });
        return waiting;
    }
    function resolveScriptInfo(nameOrScriptInfo) {
        var info = typeof (nameOrScriptInfo) === "string" ?
                          ss.scripts[nameOrScriptInfo] :
                       (nameOrScriptInfo ? (nameOrScriptInfo.script || nameOrScriptInfo) : null);
        if (info && !info._isScript) {
            info = null;
        }
        return info;
    }
    function state(scriptInfo, newState) {
        return (scriptInfo._state = newState || scriptInfo._state) || 0;
    }
    function isLoaded(scriptInfo) {
        return !scriptInfo || (state(scriptInfo) > loadingCo);
    }
    function getAndDelete(obj, field) {
        var r = obj[field];
        delete obj[field];
        return r;
    }
    function foreachCall(obj, field, args) {
        // calls all the functions in an array of functions and deletes
        // the array from the containing object.
        foreach(getAndDelete(obj, field), function(callback) {
            callback.apply(null, args || []);
        });
    }
    function lazyget(obj, name, value) {
        // aids in lazily adding to an array or object that may not exist yet
        // also makes it simple to get a field from an object that may or may not be defined
        // e.g. lazyget(null, "foo") // undefined
        return obj ? (obj[name] = obj[name] || value) : value;
    }
    function lazypush(obj, name, value) {
        lazyget(obj, name, []).push(value);
    }
    function lazyset(obj, name, key, value) {
        lazyget(obj, name, {})[key] = value;
    }
    function listenOnce(target, name, ieName, callback, isReadyState, isScript) {
        function onEvent() {
            // this closure causes a circular reference with the dom element (target)
            // because it is added as a handler to the target, so target->onEvent,
            // and onEvent references the target through the parameter, onEvent->target.
            // However both sides are removed when the event fires -- the handler is removed
            // and the target is set to null.
            if (!attachEvent || !isReadyState || /loaded|complete/.test(target.readyState)) {
                if (attachEvent) {
                    target.detachEvent(ieName || ("on" + name), onEvent);
                }
                else {
                    target.removeEventListener(name, onEvent, false);
                    if (isScript) {
                        target.removeEventListener("error", onEvent, false);
                    }
                }
                callback.apply(target);
                target = null;
            }
        }
        if (attachEvent) {
            target.attachEvent(ieName || ("on" + name), onEvent);
        }
        else {
            target.addEventListener(name, onEvent, false);
            if (isScript) {
                target.addEventListener("error", onEvent, false);
            }
        }
    }
    function raiseDomReady() {
        if (ss._domReady) {
            var cb = getAndDelete(ss, "_domReadyQueue");
            foreach(cb, function(c) { c(); });
        }
    }
    function raiseOnReady() {
        var ready = ss._ready;
        if (!ready && ss._domReady && !(ss.loader && ss.loader._loading)) {
            ss._ready = ready = true;
        }
        if (ready) {
            var cb = getAndDelete(ss, "_readyQueue");
            foreach(cb, function(c) { c(); });
        }
    }
    var ssAPI = {
        debug: true,
        scripts: {},
        _domLoaded: function() {
            function domReady() {
                if (!ss._domReady) {
                    ss._domReady = true;
                    raiseDomReady();
                    raiseOnReady();
                }
            }
            listenOnce(window, "load", null, domReady);

            var check;
            if (attachEvent) {
                if ((window == window.top) && document.documentElement.doScroll) {
                    // timer/doscroll trick works only when not in a frame
                    var timeout, er, el = document.createElement("div");
                    check = function() {
                        try {
                            el.doScroll("left");
                        }
                        catch (er) {
                            timeout = window.setTimeout(check, 0);
                            return;
                        }
                        el = null;
                        domReady();
                    };
                    check();
                }
                else {
                    // in a frame this is the only reliable way to fire before onload, however
                    // testing has shown it is not much better than onload if at all better.
                    // using a <script> element with defer="true" is much better, but you have to
                    // document.write it for the 'defer' to work, and that wouldnt work if this
                    // script is being loaded dynamically, a reasonable possibility.
                    // There is no known way of detecting whether the script is loaded dynamically or not.
                    listenOnce(document, null, "onreadystatechange", domReady, true);
                }
            }
            else if (document.addEventListener) {
                listenOnce(document, "DOMContentLoaded", null, domReady);
            }
        },
        onDomReady: function(callback) {
            lazypush(this, "_domReadyQueue", callback);
            raiseDomReady();
        },
        onReady: function(callback) {
            lazypush(this, "_readyQueue", callback);
            raiseOnReady();
        },
        require: function(features, completedCallback, userContext) {
            // create a unique ID for this require session, used to ensure we are listening to
            // each script on each iteration only once.
            var session = ss.loader._session++,
                iterating,
                loaded;
            function raiseCallback() {
                // call the callback but not if the dom isn't ready
                if (completedCallback) {
                    ss.onDomReady(function() { completedCallback(features, userContext) });
                }
            }
            function allLoaded() {
                // called each time any script from the scripts list or their descendants are loaded.
                // Each time we re-play the requires operation, which allows us to recalculate the dependency
                // tree in case a loaded script has added to it. It also makes it possible for the parent
                // scripts of any given types to change.

                // Note that when scripts are loading simultaniously, the browser will sometimes execute 
                // more than one script before raising the scriptElement.load/readyStateChange event, which means
                // two or more script-loader aware scripts might all call registerScript() before the 'getHandler'
                // method for the first fires. In that scenario, once the handler does get called for the executed
                // scripts, they will all call this 'allLoaded' handler, and all might find that all the required
                // scripts have been loaded. To simply protect against calling the callback multiple times, we 
                // just ensure it is called once.
                if (!loaded && !iterating && !iteration()) {
                    loaded = true;
                    raiseCallback();
                }
                // when the loader is finished after the domready event, it should
                // raise the ready event.
                raiseOnReady();
            }
            function iteration() {
                iterating = true;
                var resolvedScripts = [];
                foreach(features, function(feature) {
                    feature = resolveScriptInfo(feature);
                    if (feature) {
                        var contains = feature.contains;
                        if (contains) {
                            foreachScriptInfo(contains, function(scriptInfo) {
                                resolvedScripts.push(scriptInfo);
                            });
                        }
                        else {
                            resolvedScripts.push(feature);
                        }
                    }
                });
                var waiting = requireAll(resolvedScripts, allLoaded, session);
                iterating = false;
                return waiting;
            }
            allLoaded();
        },
        loadScripts: function(scriptUrls, completedCallback, userContext) {
            this.loader._loadScripts(scriptUrls, completedCallback, userContext);
        },
        loader: {
            basePath: null,
            _loading: 0,
            _session: 0,
            _init: function() {
                var scripts = document.getElementsByTagName("script"),
                selfUrl = scripts.length ? scripts[scripts.length - 1].src : null;
                this.basePath = selfUrl ? (selfUrl.slice(0, selfUrl.lastIndexOf("/"))) : "";
            },
            _loadSrc: function(src, callback) {
                var script = merge(document.createElement('script'), { type: 'text/javascript', src: src }),
                    loaded = lazyget(this, "_loadedScripts", {});
                // First take inventory of all the script elements on the page so we can quickly detect whether a particular script has already
                // loaded or not. This is done frequently in case a script element is added by any other means separate from the loader.
                // For example, a script that loads could create a script element when it executes.
                // Urls found are stored in _loadedScripts so even script elements that have been removed will be remembered.
                foreach(document.getElementsByTagName("script"), function(script) {
                    var src = script.src;
                    if (src) loaded[src] = true;
                });
                if (loaded[script.src]) {
                    if (callback) callback();
                }
                else {
                    listenOnce(script, "load", "onreadystatechange", callback, true, true);
                    this._loading++;
                    loaded[script.src] = true;
                    document.getElementsByTagName("head")[0].appendChild(script);
                }
            },
            _load: function(scriptInfo, callback, session) {
                var waiting;
                if (isLoaded(scriptInfo)) {
                    callback();
                }
                else {
                    waiting = true;
                    var notifyList = lazyget(scriptInfo, "_notify", []),
                        key = "session" + session;
                    if (!notifyList[key]) {
                        notifyList[key] = true;
                        notifyList.push(callback);
                    }
                    if (state(scriptInfo) < loading) {
                        state(scriptInfo, loading);
                        this._loadSrc(this._getUrl(scriptInfo), this._getHandler(scriptInfo));
                    }
                }
                return waiting;
            },
            _getUrl: function(scriptInfo) {
                var debug = ss.debug,
                    name = scriptInfo.name,
                    path = (debug ? (scriptInfo.debugUrl || scriptInfo.releaseUrl) : scriptInfo.releaseUrl).replace(/\{0\}/, name) || "";
                if (path.substr(0, 2) === "%/") {
                    var basePath = this.basePath,
                        hasSlash = (basePath.charAt(basePath.length - 1) === "/");
                    path = basePath + (hasSlash ? "" : "/") + path.substr(2);
                }
                return path;
            },
            _getHandler: function(scriptInfo) {
                return function() {
                    // this === <script> element
                    ss.loader._loading--;
                    if (state(scriptInfo) < loadingCo) {
                        // dont do this if its already marked as 'loaded',
                        // which may happen if the script contains a registerScript() call.
                        state(scriptInfo, loadingCo);
                    }
                    foreachCall(scriptInfo, "_notify");
                }
            },
            _loadScripts: function(scriptUrls, completedCallback, userContext) {
                var index = -1, loaded = lazyget(this, "_loadedScripts", {});
                // clone the array so outside changes to it do not affect this asynchronous enumeration of it
                scriptUrls = scriptUrls instanceof Array ? Array.apply(null, scriptUrls) : [scriptUrls];
                function scriptLoaded(first) {
                    if (!first) ss.loader._loading--;
                    if (++index < scriptUrls.length) {
                        ss.loader._loadSrc(scriptUrls[index], scriptLoaded);
                    }
                    else {
                        if (completedCallback) {
                            completedCallback(scriptUrls, userContext);
                        }
                        raiseOnReady();
                    }
                }
                scriptLoaded(true);
            },
            _requireScript: function(scriptInfo, callback, session, readOnly) {
                // readonly: caller is only interested in knowing if this script is ready for it's execution callback,
                // it should not cause any dependencies to start loading. If it is, it is executed.
                var waiting;
                if (!isLoaded(scriptInfo)) {
                    var waitForDeps = requireAll(getDependencies(scriptInfo), callback, session, readOnly),
                        waitForDepsCo = requireAll(getDependencies(scriptInfo, true), callback, session, readOnly);
                    if (!waitForDeps && !waitForDepsCo && state(scriptInfo) === loadingCo) {
                        // the script has no more dependencies, executionDependencies, itself has already loaded,
                        // but has not yet been confirmed to have been loaded. This is it.
                        // A script that supports executionDependencies might also support an 'execution callback',
                        // a wrapper function that allows us to load the script without executing it.
                        // We then call the callback once its executionDependencies have loaded.
                        state(scriptInfo, loaded);
                        // there can be only one, but this is a dirty trick to call this field if it exists
                        // and delete it in a consise way.
                        foreachCall(scriptInfo, "_callback");
                        // Now that this script has loaded, see if any of its parent scripts are waiting for it
                        // We only need to do this in readOnly mode since otherwise, a require() call is coming
                        // again anyway.
                        if (readOnly) {
                            var contains = scriptInfo.contains;
                            if (contains) {
                                foreachScriptInfo(contains, function(scriptInfo) {
                                    requireParents(scriptInfo);
                                });
                            }
                            else {
                                requireParents(getScriptInfo(scriptInfo));
                            }
                        }
                    }
                    else if (!readOnly && !waitForDeps) {
                        // if all dependencies are loaded & executed, now load this script,
                        // or the dependency it was selected for. Some executionDependencies may still be loading
                        this._load(scriptInfo, callback, session);
                    }
                    waiting |= (waitForDeps || waitForDepsCo);
                }
                return waiting || !isLoaded(scriptInfo);
            },
            _registerParents: function(scriptInfo) {
                // tell each script it depends on that this script depends on it
                function register(dependency) {
                    var depInfo = getScriptInfo(dependency);
                    lazyset(depInfo, "_parents", scriptInfo.name, scriptInfo);
                }
                foreach(scriptInfo["dependencies"], register);
                foreach(scriptInfo["executionDependencies"], register);
            },
            defineScript: function(scriptInfo) {
                var scripts = ss.scripts,
                    name = scriptInfo.name;
                    scriptInfo = scripts[name] = merge(scripts[name], scriptInfo);
                    this._registerParents(scriptInfo);
                if (scriptInfo.isLoaded) {
                    scriptInfo._state = loaded;
                }
                scriptInfo._isScript = true;
            },
            defineScripts: function(defaultScriptInfo, scriptInfos) {
                foreach(scriptInfos, function(scriptInfo) {
                    ss.loader.defineScript(merge(null, defaultScriptInfo, scriptInfo));
                });
            },
            registerScript: function(name, executionDependencies, executionCallback) {
                var scriptInfo = getScriptInfo(name);
                scriptInfo._callback = executionCallback;
                var existingList = lazyget(scriptInfo, "executionDependencies", []),
                    existing = toIndex(existingList);
                // add only the items that don't already exist
                foreach(executionDependencies, function(executionDependency) {
                    if (!existing[executionDependency]) {
                        existingList.push(executionDependency);
                    }
                });
                this._registerParents(scriptInfo);

                // the getHandler() script element event listener also sets the next state and calls
                // the execution callback. But we do it here also since this might occur when a script
                // loader script is referenced statically without an explicit call to load it, in which
                // case there is no script element listener.
                state(scriptInfo, loadingCo);
                requireScript(scriptInfo, null, null, true);
            }
        } // loader
    };
    merge(ss, ssAPI);

    ss.loader._init();
    ss._domLoaded();
})();

///////////////////////////////////////////////////////////////////////////////
// Object Extensions

Object.__typeName = 'Object';
Object.__baseType = null;

Object.getKeyCount = function Object$getKeyCount(d) {
    var count = 0;
    for (var n in d) {
        count++;
    }
    return count;
}

Object.clearKeys = function Object$clearKeys(d) {
    for (var n in d) {
        delete d[n];
    }
}

Object.keyExists = function Object$keyExists(d, key) {
    return d[key] !== undefined;
}

///////////////////////////////////////////////////////////////////////////////
// Function Extensions

Function.prototype.invoke = function Function$invoke() {
    return this.apply(null, arguments);
}

///////////////////////////////////////////////////////////////////////////////
// Boolean Extensions

Boolean.__typeName = 'Boolean';

Boolean.parse = function Boolean$parse(s) {
    return (s.toLowerCase() == 'true');
}

///////////////////////////////////////////////////////////////////////////////
// Number Extensions

Number.__typeName = 'Number';

Number.parse = function Number$parse(s) {
    if (!s || !s.length) {
        return 0;
    }
    if ((s.indexOf('.') >= 0) || (s.indexOf('e') >= 0) ||
        s.endsWith('f') || s.endsWith('F')) {
        return parseFloat(s);
    }
    return parseInt(s, 10);
}

Number.prototype.format = function Number$format(format) {
    if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
        return this.toString();
    }
    return this._netFormat(format, false);
}

Number.prototype.localeFormat = function Number$format(format) {
    if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
        return this.toLocaleString();
    }
    return this._netFormat(format, true);
}

Number._commaFormat = function Number$_commaFormat(number, groups, decimal, comma) {
    var decimalPart = null;
    var decimalIndex = number.indexOf(decimal);
    if (decimalIndex > 0) {
        decimalPart = number.substr(decimalIndex);
        number = number.substr(0, decimalIndex);
    }

    var negative = number.startsWith('-');
    if (negative) {
        number = number.substr(1);
    }

    var groupIndex = 0;
    var groupSize = groups[groupIndex];
    if (number.length < groupSize) {
        return decimalPart ? number + decimalPart : number;
    }

    var index = number.length;
    var s = '';
    var done = false;
    while (!done) {
        var length = groupSize;
        var startIndex = index - length;
        if (startIndex < 0) {
            groupSize += startIndex;
            length += startIndex;
            startIndex = 0;
            done = true;
        }
        if (!length) {
            break;
        }
        
        var part = number.substr(startIndex, length);
        if (s.length) {
            s = part + comma + s;
        }
        else {
            s = part;
        }
        index -= length;

        if (groupIndex < groups.length - 1) {
            groupIndex++;
            groupSize = groups[groupIndex];
        }
    }

    if (negative) {
        s = '-' + s;
    }    
    return decimalPart ? s + decimalPart : s;
}

Number.prototype._netFormat = function Number$_netFormat(format, useLocale) {
    var nf = useLocale ? ss.CultureInfo.CurrentCulture.numberFormat : ss.CultureInfo.InvariantCulture.numberFormat;

    var s = '';    
    var precision = -1;
    
    if (format.length > 1) {
        precision = parseInt(format.substr(1));
    }

    var fs = format.charAt(0);
    switch (fs) {
        case 'd': case 'D':
            s = parseInt(Math.abs(this)).toString();
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            if (this < 0) {
                s = '-' + s;
            }
            break;
        case 'x': case 'X':
            s = parseInt(Math.abs(this)).toString(16);
            if (fs == 'X') {
                s = s.toUpperCase();
            }
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            break;
        case 'e': case 'E':
            if (precision == -1) {
                s = this.toExponential();
            }
            else {
                s = this.toExponential(precision);
            }
            if (fs == 'E') {
                s = s.toUpperCase();
            }
            break;
        case 'f': case 'F':
        case 'n': case 'N':
            if (precision == -1) {
                precision = nf.numberDecimalDigits;
            }
            s = this.toFixed(precision).toString();
            if (precision && (nf.numberDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.numberDecimalSeparator + s.substr(index + 1);
            }
            if ((fs == 'n') || (fs == 'N')) {
                s = Number._commaFormat(s, nf.numberGroupSizes, nf.numberDecimalSeparator, nf.numberGroupSeparator);
            }
            break;
        case 'c': case 'C':
            if (precision == -1) {
                precision = nf.currencyDecimalDigits;
            }
            s = Math.abs(this).toFixed(precision).toString();
            if (precision && (nf.currencyDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.currencyDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.currencyGroupSizes, nf.currencyDecimalSeparator, nf.currencyGroupSeparator);
            if (this < 0) {
                s = String.format(nf.currencyNegativePattern, s);
            }
            else {
                s = String.format(nf.currencyPositivePattern, s);
            }
            break;
        case 'p': case 'P':
            if (precision == -1) {
                precision = nf.percentDecimalDigits;
            }
            s = (Math.abs(this) * 100.0).toFixed(precision).toString();
            if (precision && (nf.percentDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.percentDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.percentGroupSizes, nf.percentDecimalSeparator, nf.percentGroupSeparator);
            if (this < 0) {
                s = String.format(nf.percentNegativePattern, s);
            }
            else {
                s = String.format(nf.percentPositivePattern, s);
            }
            break;
    }

    return s;
}

///////////////////////////////////////////////////////////////////////////////
// String Extensions

String.__typeName = 'String';
String.Empty = '';

String.compare = function String$compare(s1, s2, ignoreCase) {
    if (ignoreCase) {
        if (s1) {
            s1 = s1.toUpperCase();
        }
        if (s2) {
            s2 = s2.toUpperCase();
        }
    }
    s1 = s1 || '';
    s2 = s2 || '';

    if (s1 == s2) {
        return 0;
    }
    if (s1 < s2) {
        return -1;
    }
    return 1;
}

String.prototype.compareTo = function String$compareTo(s, ignoreCase) {
    return String.compare(this, s, ignoreCase);
}

String.concat = function String$concat() {
    if (arguments.length === 2) {
        return arguments[0] + arguments[1];
    }
    return Array.prototype.join.call(arguments, '');
}

String.prototype.endsWith = function String$endsWith(suffix) {
    if (!suffix.length) {
        return true;
    }
    if (suffix.length > this.length) {
        return false;
    }
    return (this.substr(this.length - suffix.length) == suffix);
}

String.equals = function String$equals1(s1, s2, ignoreCase) {
    return String.compare(s1, s2, ignoreCase) == 0;
}

String._format = function String$_format(format, values, useLocale) {
    if (!String._formatRE) {
        String._formatRE = /(\{[^\}^\{]+\})/g;
    }

    return format.replace(String._formatRE,
                          function(str, m) {
                              var index = parseInt(m.substr(1));
                              var value = values[index + 1];
                              if (ss.isNullOrUndefined(value)) {
                                  return '';
                              }
                              if (value.format) {
                                  var formatSpec = null;
                                  var formatIndex = m.indexOf(':');
                                  if (formatIndex > 0) {
                                      formatSpec = m.substring(formatIndex + 1, m.length - 1);
                                  }
                                  return useLocale ? value.localeFormat(formatSpec) : value.format(formatSpec);
                              }
                              else {
                                  return useLocale ? value.toLocaleString() : value.toString();
                              }
                          });
}

String.format = function String$format(format) {
    return String._format(format, arguments, /* useLocale */ false);
}

String.fromChar = function String$fromChar(ch, count) {
    var s = ch;
    for (var i = 1; i < count; i++) {
        s += ch;
    }
    return s;
}

String.prototype.htmlDecode = function String$htmlDecode() {
    var div = document.createElement('div');
    div.innerHTML = this;
    return div.textContent || div.innerText;
}

String.prototype.htmlEncode = function String$htmlEncode() {
    var div = document.createElement('div');
    div.appendChild(document.createTextNode(this));
    return div.innerHTML.replace(/\"/g, '&quot;');
}

String.prototype.indexOfAny = function String$indexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || 0;
    count = count || length;

    var endIndex = startIndex + count - 1;
    if (endIndex >= length) {
        endIndex = length - 1;
    }

    for (var i = startIndex; i <= endIndex; i++) {
        if (ArrayPrototype_indexOf(chars, this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.prototype.insert = function String$insert(index, value) {
    if (!value) {
        return this;
    }
    if (!index) {
        return value + this;
    }
    var s1 = this.substr(0, index);
    var s2 = this.substr(index);
    return s1 + value + s2;
}

String.isNullOrEmpty = function String$isNullOrEmpty(s) {
    return !s || !s.length;
}

String.prototype.lastIndexOfAny = function String$lastIndexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || length - 1;
    count = count || length;

    var endIndex = startIndex - count + 1;
    if (endIndex < 0) {
        endIndex = 0;
    }

    for (var i = startIndex; i >= endIndex; i--) {
        if (ArrayPrototype_indexOf(chars, this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.localeFormat = function String$localeFormat(format) {
    return String._format(format, arguments, /* useLocale */ true);
}

String.prototype.padLeft = function String$padLeft(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return String.fromChar(ch, totalWidth - this.length) + this;
    }
    return this;
}

String.prototype.padRight = function String$padRight(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return this + String.fromChar(ch, totalWidth - this.length);
    }
    return this;
}

String.prototype.remove = function String$remove(index, count) {
    if (!count || ((index + count) > this.length)) {
        return this.substr(0, index);
    }
    return this.substr(0, index) + this.substr(index + count);
}

String.prototype.replaceAll = function String$replaceAll(oldValue, newValue) {
    newValue = newValue || '';
    return this.split(oldValue).join(newValue);
}

String.prototype.startsWith = function String$startsWith(prefix) {
    if (!prefix.length) {
        return true;
    }
    if (prefix.length > this.length) {
        return false;
    }
    return (this.substr(0, prefix.length) == prefix);
}

if (!String.prototype.trim) {
String.prototype.trim = function String$trim() {
    return this.trimEnd().trimStart();
}

String.prototype.trimEnd = function String$trimEnd() {
    return this.replace(/\s*$/, '');
}

String.prototype.trimStart = function String$trimStart() {
    return this.replace(/^\s*/, '');
}
}

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__typeName = 'Array';
Array.__interfaces = [ ss.IEnumerable ];

ArrayPrototype_add = function Array$add(_array, item) {
    _array[_array.length] = item;
}

ArrayPrototype_addRange = function Array$addRange(_array, items) {
    _array.push.apply(_array, items);
}

ArrayPrototype_aggregate = function Array$aggregate(_array, seed, callback, instance) {
    var length = _array.length;
    for (var i = 0; i < length; i++) {
        if (i in _array) {
            seed = callback.call(instance, seed, _array[i], i, _array);
        }
    }
    return seed;
}

ArrayPrototype_clear = function Array$clear(_array) {
    _array.length = 0;
}

ArrayPrototype_clone = function Array$clone(_array) {
    if (_array.length === 1) {
        return [_array[0]];
    }
    else {
        return Array.apply(null, _array);
    }
}

ArrayPrototype_contains = function Array$contains(_array, item) {
    var index = ArrayPrototype_indexOf(_array, item);
    return (index >= 0);
}

ArrayPrototype_dequeue = function Array$dequeue(_array) {
    return _array.shift();
}

ArrayPrototype_enqueue = function Array$enqueue(_array, item) {
    // We record that this array instance is a queue, so we
    // can implement the right behavior in the peek method.
    _array._queue = true;
    _array.push(item);
}

ArrayPrototype_peek = function Array$peek(_array) {
    if (_array.length) {
        var index = _array._queue ? 0 : _array.length - 1;
        return _array[index];
    }
    return null;
}

ArrayPrototype_every = function Array$every(_array, callback, instance) {
    var length = _array.length;
        for (var i = 0; i < length; i++) {
        if (i in _array && !callback.call(instance, _array[i], i, _array)) {
                return false;
            }
        }
        return true;
    }

ArrayPrototype_extract = function Array$extract(_array, index, count) {
    if (!count) {
        return _array.slice(index);
    }
    return _array.slice(index, index + count);
}

ArrayPrototype_filter = function Array$filter(_array, callback, instance) {
    var length = _array.length;    
        var filtered = [];
        for (var i = 0; i < length; i++) {
        if (i in _array) {
            var val = _array[i];
            if (callback.call(instance, val, i, _array)) {
                    filtered.push(val);
                }
            }
        }
        return filtered;
    }

ArrayPrototype_forEach = function Array$forEach(_array, callback, instance) {
    var length = _array.length;
        for (var i = 0; i < length; i++) {
        if (i in _array) {
            callback.call(instance, _array[i], i, _array);
        }
    }
}

ArrayPrototype_getEnumerator = function Array$getEnumerator(_array) {
    return new ss.ArrayEnumerator(_array);
}

ArrayPrototype_groupBy = function Array$groupBy(_array, callback, instance) {
    var length = _array.length;
    var groups = [];
    var keys = {};
    for (var i = 0; i < length; i++) {
        if (i in _array) {
            var key = callback.call(instance, _array[i], i);
            if (String.isNullOrEmpty(key)) {
                continue;
            }
            var items = keys[key];
            if (!items) {
                items = [];
                items.key = key;

                keys[key] = items;
                ArrayPrototype_add(groups, items);
            }
            ArrayPrototype_add(items, _array[i]);
        }
    }
    return groups;
}

ArrayPrototype_index = function Array$index(_array, callback, instance) {
    var length = _array.length;
    var items = {};
    for (var i = 0; i < length; i++) {
        if (i in _array) {
            var key = callback.call(instance, _array[i], i);
            if (String.isNullOrEmpty(key)) {
                continue;
            }
            items[key] = _array[i];
        }
    }
    return items;
}

ArrayPrototype_indexOf = function Array$indexOf(_array, item, startIndex) {
        startIndex = startIndex || 0;
    var length = _array.length;
        if (length) {
            for (var index = startIndex; index < length; index++) {
            if (_array[index] === item) {
                    return index;
                }
            }
        }
        return -1;
    }

ArrayPrototype_insert = function Array$insert(_array, index, item) {
    _array.splice(index, 0, item);
}

ArrayPrototype_insertRange = function Array$insertRange(_array, index, items) {
    if (index === 0) {
        _array.unshift.apply(_array, items);
    }
    else {
        for (var i = 0; i < items.length; i++) {
            _array.splice(index + i, 0, items[i]);
        }
    }
}

ArrayPrototype_map = function Array$map(_array, callback, instance) {
    var length = _array.length;
        var mapped = new Array(length);
        for (var i = 0; i < length; i++) {
        if (i in _array) {
            mapped[i] = callback.call(instance, _array[i], i, _array);
            }
        }
        return mapped;
    }

Array.parse = function Array$parse(s) {
    return eval('(' + s + ')');
}

ArrayPrototype_remove = function Array$remove(_array, item) {
    var index = ArrayPrototype_indexOf(_array, item);
    if (index >= 0) {
        _array.splice(index, 1);
        return true;
    }
    return false;
}

ArrayPrototype_removeAt = function Array$removeAt(_array, index) {
    _array.splice(index, 1);
}

ArrayPrototype_removeRange = function Array$removeRange(_array, index, count) {
    return _array.splice(index, count);
}

ArrayPrototype_some = function Array$some(_array, callback, instance) {
    var length = _array.length;
        for (var i = 0; i < length; i++) {
        if (i in _array && callback.call(instance, _array[i], i, _array)) {
                return true;
            }
        }
        return false;
    }

Array.toArray = function Array$toArray(obj) {
    return Array.prototype.slice.call(obj);
}

///////////////////////////////////////////////////////////////////////////////
// RegExp Extensions

RegExp.__typeName = 'RegExp';

RegExp.parse = function RegExp$parse(s) {
    if (s.startsWith('/')) {
        var endSlashIndex = s.lastIndexOf('/');
        if (endSlashIndex > 1) {
            var expression = s.substring(1, endSlashIndex);
            var flags = s.substr(endSlashIndex + 1);
            return new RegExp(expression, flags);
        }
    }

    return null;    
}

///////////////////////////////////////////////////////////////////////////////
// Date Extensions

Date.__typeName = 'Date';

Date.empty = null;

Date.get_now = function Date$get_now() {
    return new Date();
}

Date.get_today = function Date$get_today() {
    var d = new Date();
    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
}

Date.isEmpty = function Date$isEmpty(d) {
    return (d === null) || (d.valueOf() === 0);
}

Date.prototype.format = function Date$format(format) {
    if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
        return this.toString();
    }
    if (format == 'id') {
        return this.toDateString();
    }
    if (format == 'it') {
        return this.toTimeString();
    }

    return this._netFormat(format, false);
}

Date.prototype.localFormat = function Date$localeFormat(format) {
    if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
        return this.toLocaleString();
    }
    if (format == 'id') {
        return this.toLocaleDateString();
    }
    if (format == 'it') {
        return this.toLocaleTimeString();
    }

    return this._netFormat(format, true);
}

Date.prototype._netFormat = function Date$_netFormat(format, useLocale) {
    var dtf = useLocale ? ss.CultureInfo.CurrentCulture.dateFormat : ss.CultureInfo.InvariantCulture.dateFormat;
    var useUTC = false;

    if (format.length == 1) {
        switch (format) {
            case 'f': format = dtf.longDatePattern + ' ' + dtf.shortTimePattern;
            case 'F': format = dtf.dateTimePattern; break;

            case 'd': format = dtf.shortDatePattern; break;
            case 'D': format = dtf.longDatePattern; break;

            case 't': format = dtf.shortTimePattern; break;
            case 'T': format = dtf.longTimePattern; break;

            case 'g': format = dtf.shortDatePattern + ' ' + dtf.shortTimePattern; break;
            case 'G': format = dtf.shortDatePattern + ' ' + dtf.longTimePattern; break;

            case 'R': case 'r': format = dtf.gmtDateTimePattern; useUTC = true; break;
            case 'u': format = dtf.universalDateTimePattern; useUTC = true; break;
            case 'U': format = dtf.dateTimePattern; useUTC = true; break;

            case 's': format = dtf.sortableDateTimePattern; break;
        }
    }

    if (format.charAt(0) == '%') {
        format = format.substr(1);
    }

    if (!Date._formatRE) {
        Date._formatRE = /dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z/g;
    }

    var re = Date._formatRE;    
    var sb = new ss.StringBuilder();
    var dt = this;
    if (useUTC) {
        dt = new Date(Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(),
                               dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds()));
    }

    re.lastIndex = 0;
    while (true) {
        var index = re.lastIndex;
        var match = re.exec(format);

        sb.append(format.slice(index, match ? match.index : format.length));
        if (!match) {
            break;
        }

        var fs = match[0];
        var part = fs;
        switch (fs) {
            case 'dddd':
                part = dtf.dayNames[dt.getDay()];
                break;
            case 'ddd':
                part = dtf.shortDayNames[dt.getDay()];
                break;
            case 'dd':
                part = dt.getDate().toString().padLeft(2, '0');
                break;
            case 'd':
                part = dt.getDate();
                break;
            case 'MMMM':
                part = dtf.monthNames[dt.getMonth()];
                break;
            case 'MMM':
                part = dtf.shortMonthNames[dt.getMonth()];
                break;
            case 'MM':
                part = (dt.getMonth() + 1).toString().padLeft(2, '0');
                break;
            case 'M':
                part = (dt.getMonth() + 1);
                break;
            case 'yyyy':
                part = dt.getFullYear();
                break;
            case 'yy':
                part = (dt.getFullYear() % 100).toString().padLeft(2, '0');
                break;
            case 'y':
                part = (dt.getFullYear() % 100);
                break;
            case 'h': case 'hh':
                part = dt.getHours() % 12;
                if (!part) {
                    part = '12';
                }
                else if (fs == 'hh') {
                    part = part.toString().padLeft(2, '0');
                }
                break;
            case 'HH':
                part = dt.getHours().toString().padLeft(2, '0');
                break;
            case 'H':
                part = dt.getHours();
                break;
            case 'mm':
                part = dt.getMinutes().toString().padLeft(2, '0');
                break;
            case 'm':
                part = dt.getMinutes();
                break;
            case 'ss':
                part = dt.getSeconds().toString().padLeft(2, '0');
                break;
            case 's':
                part = dt.getSeconds();
                break;
            case 't': case 'tt':
                part = (dt.getHours() < 12) ? dtf.amDesignator : dtf.pmDesignator;
                if (fs == 't') {
                    part = part.charAt(0);
                }
                break;
            case 'fff':
                part = dt.getMilliseconds().toString().padLeft(3, '0');
                break;
            case 'ff':
                part = dt.getMilliseconds().toString().padLeft(3).substr(0, 2);
                break;
            case 'f':
                part = dt.getMilliseconds().toString().padLeft(3).charAt(0);
                break;
            case 'z':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part));
                break;
            case 'zz': case 'zzz':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part)).toString().padLeft(2, '0');
                if (fs == 'zzz') {
                    part += dtf.timeSeparator + Math.abs(dt.getTimezoneOffset() % 60).toString().padLeft(2, '0');
                }
                break;
        }
        sb.append(part);
    }

    return sb.toString();
}

Date.parseDate = function Date$parse(s) {
    // Date.parse returns the number of milliseconds
    // so we use that to create an actual Date instance
    return new Date(Date.parse(s));
}

///////////////////////////////////////////////////////////////////////////////
// Error Extensions

Error.__typeName = 'Error';

Error.prototype.popStackFrame = function Error$popStackFrame() {
    if (ss.isNullOrUndefined(this.stack) ||
        ss.isNullOrUndefined(this.fileName) ||
        ss.isNullOrUndefined(this.lineNumber)) {
        return;
    }

    var stackFrames = this.stack.split('\n');
    var currentFrame = stackFrames[0];
    var pattern = this.fileName + ':' + this.lineNumber;
    while (!ss.isNullOrUndefined(currentFrame) &&
           ArrayPrototype_indexOf(currentFrame, pattern) === -1) {
        stackFrames.shift();
        currentFrame = stackFrames[0];
    }

    var nextFrame = stackFrames[1];
    if (ss.isNullOrUndefined(nextFrame)) {
        return;
    }

    var nextFrameParts = nextFrame.match(/@(.*):(\d+)$/);
    if (ss.isNullOrUndefined(nextFrameParts)) {
        return;
    }

    stackFrames.shift();
    this.stack = stackFrames.join("\n");
    this.fileName = nextFrameParts[1];
    this.lineNumber = parseInt(nextFrameParts[2]);
}

Error.createError = function Error$createError(message, errorInfo, innerException) {
    var e = new Error(message);
    if (errorInfo) {
        for (var v in errorInfo) {
            e[v] = errorInfo[v];
        }
    }
    if (innerException) {
        e.innerException = innerException;
    }

    e.popStackFrame();
    return e;
}

///////////////////////////////////////////////////////////////////////////////
// Debug Extensions

ss.Debug = window.Debug || function() {};
ss.Debug.__typeName = 'Debug';

if (!ss.Debug.writeln) {
    ss.Debug.writeln = function Debug$writeln(text) {
        if (window.console) {
            if (window.console.debug) {
                window.console.debug(text);
                return;
            }
            else if (window.console.log) {
                window.console.log(text);
                return;
            }
        }
        else if (window.opera &&
            window.opera.postError) {
            window.opera.postError(text);
            return;
        }
    }
}

ss.Debug._fail = function Debug$_fail(message) {
    ss.Debug.writeln(message);
    eval('debugger;');
}

ss.Debug.assert = function Debug$assert(condition, message) {
    if (!condition) {
        message = 'Assert failed: ' + message;
        if (confirm(message + '\r\n\r\nBreak into debugger?')) {
            ss.Debug._fail(message);
        }
    }
}

ss.Debug.fail = function Debug$fail(message) {
    ss.Debug._fail(message);
}

///////////////////////////////////////////////////////////////////////////////
// Type System Implementation

window.Type = Function;
Type.__typeName = 'Type';

window.__Namespace = function(name) {
    this.__typeName = name;
}
__Namespace.prototype = {
    __namespace: true,
    getName: function() {
        return this.__typeName;
    }
}

Type.registerNamespace = function Type$registerNamespace(name) {
    if (!window.__namespaces) {
        window.__namespaces = {};
    }
    if (!window.__rootNamespaces) {
        window.__rootNamespaces = [];
    }

    if (window.__namespaces[name]) {
        return;
    }

    var ns = window;
    var nameParts = name.split('.');

    for (var i = 0; i < nameParts.length; i++) {
        var part = nameParts[i];
        var nso = ns[part];
        if (!nso) {
            ns[part] = nso = new __Namespace(nameParts.slice(0, i + 1).join('.'));
            if (i == 0) {
                ArrayPrototype_add(window.__rootNamespaces, nso);
            }
        }
        ns = nso;
    }

    window.__namespaces[name] = ns;
}

Type.prototype.registerClass = function Type$registerClass(name, baseType, interfaceType) {
    this.prototype.constructor = this;
    this.__typeName = name;
    this.__class = true;
    this.__baseType = baseType || Object;
    if (baseType) {
        this.__basePrototypePending = true;
    }

    if (interfaceType) {
        this.__interfaces = [];
        for (var i = 2; i < arguments.length; i++) {
            interfaceType = arguments[i];
            ArrayPrototype_add(this.__interfaces, interfaceType);
        }
    }
}

Type.prototype.registerInterface = function Type$createInterface(name) {
    this.__typeName = name;
    this.__interface = true;
}

Type.prototype.registerEnum = function Type$createEnum(name, flags) {
    for (var field in this.prototype) {
         this[field] = this.prototype[field];
    }

    this.__typeName = name;
    this.__enum = true;
    if (flags) {
        this.__flags = true;
    }
    
    this.toString = ss.Enum._enumToString;
}

Type.prototype.setupBase = function Type$setupBase() {
    if (this.__basePrototypePending) {
        var baseType = this.__baseType;
        if (baseType.__basePrototypePending) {
            baseType.setupBase();
        }

        for (var memberName in baseType.prototype) {
            var memberValue = baseType.prototype[memberName];
            if (!this.prototype[memberName]) {
                this.prototype[memberName] = memberValue;
            }
        }

        delete this.__basePrototypePending;
    }
}

if (!Type.prototype.resolveInheritance) {
    // This function is not used by Script#; Visual Studio relies on it
    // for JavaScript IntelliSense support of derived types.
    Type.prototype.resolveInheritance = Type.prototype.setupBase;
}

Type.prototype.initializeBase = function Type$initializeBase(instance, args) {
    if (this.__basePrototypePending) {
        this.setupBase();
    }

    if (!args) {
        this.__baseType.apply(instance);
    }
    else {
        this.__baseType.apply(instance, args);
    }
}

Type.prototype.callBaseMethod = function Type$callBaseMethod(instance, name, args) {
    var baseMethod = this.__baseType.prototype[name];
    if (!args) {
        return baseMethod.apply(instance);
    }
    else {
        return baseMethod.apply(instance, args);
    }
}

Type.prototype.get_baseType = function Type$get_baseType() {
    return this.__baseType || null;
}

Type.prototype.get_fullName = function Type$get_fullName() {
    return this.__typeName;
}

Type.prototype.get_name = function Type$get_name() {
    var fullName = this.__typeName;
    var nsIndex = fullName.lastIndexOf('.');
    if (nsIndex > 0) {
        return fullName.substr(nsIndex + 1);
    }
    return fullName;
}

Type.prototype.getInterfaces = function Type$getInterfaces() {
    return this.__interfaces;
}

Type.prototype.isInstanceOfType = function Type$isInstanceOfType(instance) {
    if (ss.isNullOrUndefined(instance)) {
        return false;
    }
    if ((this == Object) || (instance instanceof this)) {
        return true;
    }

    var type = Type.getInstanceType(instance);
    return this.isAssignableFrom(type);
}

Type.prototype.isAssignableFrom = function Type$isAssignableFrom(type) {
    if ((this == Object) || (this == type)) {
        return true;
    }
    if (this.__class) {
        var baseType = type.__baseType;
        while (baseType) {
            if (this == baseType) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    else if (this.__interface) {
        var interfaces = type.__interfaces;
        if (interfaces && ArrayPrototype_contains(interfaces, this)) {
            return true;
        }

        var baseType = type.__baseType;
        while (baseType) {
            interfaces = baseType.__interfaces;
            if (interfaces && ArrayPrototype_contains(interfaces, this)) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    return false;
}

Type.isClass = function Type$isClass(type) {
    return (type.__class == true);
}

Type.isEnum = function Type$isEnum(type) {
    return (type.__enum == true);
}

Type.isFlags = function Type$isFlags(type) {
    return ((type.__enum == true) && (type.__flags == true));
}

Type.isInterface = function Type$isInterface(type) {
    return (type.__interface == true);
}

Type.isNamespace = function Type$isNamespace(object) {
    return (object.__namespace == true);
}

Type.canCast = function Type$canCast(instance, type) {
    return type.isInstanceOfType(instance);
}

Type.safeCast = function Type$safeCast(instance, type) {
    if (type.isInstanceOfType(instance)) {
        return instance;
    }
    return null;
}

Type.getInstanceType = function Type$getInstanceType(instance) {
    var ctor = null;

    // NOTE: We have to catch exceptions because the constructor
    //       cannot be looked up on native COM objects
    try {
        ctor = instance.constructor;
    }
    catch (ex) {
    }
    if (!ctor || !ctor.__typeName) {
        ctor = Object;
    }
    return ctor;
}

Type.getType = function Type$getType(typeName) {
    if (!typeName) {
        return null;
    }

    if (!Type.__typeCache) {
        Type.__typeCache = {};
    }

    var type = Type.__typeCache[typeName];
    if (!type) {
        type = eval(typeName);
        Type.__typeCache[typeName] = type;
    }
    return type;
}

Type.parse = function Type$parse(typeName) {
    return Type.getType(typeName);
}

///////////////////////////////////////////////////////////////////////////////
// Enum

ss.Enum = function Enum$() {
}
ss.Enum.registerClass('Enum');

ss.Enum.parse = function Enum$parse(enumType, s) {
    var values = enumType.prototype;
    if (!enumType.__flags) {
        for (var f in values) {
            if (f === s) {
                return values[f];
            }
        }
    }
    else {
        var parts = s.split('|');
        var value = 0;
        var parsed = true;

        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i].trim();
            var found = false;

            for (var f in values) {
                if (f === part) {
                    value |= values[f];
                    found = true;
                    break;
                }
            }
            if (!found) {
                parsed = false;
                break;
            }
        }

        if (parsed) {
            return value;
        }
    }
    throw 'Invalid Enumeration Value';
}

ss.Enum._enumToString = function Enum$toString(value) {
    var values = this.prototype;
    if (!this.__flags || (value === 0)) {
        for (var i in values) {
            if (values[i] === value) {
                return i;
            }
        }
        throw 'Invalid Enumeration Value';
    }
    else {
        var parts = [];
        for (var i in values) {
            if (values[i] & value) {
                if (parts.length) {
                    ArrayPrototype_add(parts, ' | ');
                }
                ArrayPrototype_add(parts, i);
            }
        }
        if (!parts.length) {
            throw 'Invalid Enumeration Value';
        }
        return parts.join('');
    }
}

///////////////////////////////////////////////////////////////////////////////
// Delegate

ss.Delegate = function Delegate$() {
}
ss.Delegate.registerClass('Delegate');

ss.Delegate.Null = function() { }

ss.Delegate._contains = function Delegate$_contains(targets, object, method) {
    for (var i = 0; i < targets.length; i += 2) {
        if (targets[i] === object && targets[i + 1] === method) {
            return true;
        }
    }
    return false;
}

ss.Delegate._create = function Delegate$_create(targets) {
    var delegate = function() {
        if (targets.length == 2) {
            return targets[1].apply(targets[0], arguments);
        }
        else {
            var clone = ArrayPrototype_clone(targets);
            for (var i = 0; i < clone.length; i += 2) {
                if (ss.Delegate._contains(targets, clone[i], clone[i + 1])) {
                    clone[i + 1].apply(clone[i], arguments);
                }
            }
            return null;
        }
    };
    delegate.invoke = delegate;
    delegate._targets = targets;

    return delegate;
}

ss.Delegate.create = function Delegate$create(object, method) {
    if (!object) {
        method.invoke = method;
        return method;
    }
    return ss.Delegate._create([object, method]);
}

ss.Delegate.combine = function Delegate$combine(delegate1, delegate2) {
    if (!delegate1) {
        if (!delegate2._targets) {
            return ss.Delegate.create(null, delegate2);
        }
        return delegate2;
    }
    if (!delegate2) {
        if (!delegate1._targets) {
            return ss.Delegate.create(null, delegate1);
        }
        return delegate1;
    }

    var targets1 = delegate1._targets ? delegate1._targets : [null, delegate1];
    var targets2 = delegate2._targets ? delegate2._targets : [null, delegate2];

    return ss.Delegate._create(targets1.concat(targets2));
}

ss.Delegate.remove = function Delegate$remove(delegate1, delegate2) {
    if (!delegate1 || (delegate1 === delegate2)) {
        return null;
    }
    if (!delegate2) {
        return delegate1;
    }

    var targets = delegate1._targets;
    var object = null;
    var method;
    if (delegate2._targets) {
        object = delegate2._targets[0];
        method = delegate2._targets[1];
    }
    else {
        method = delegate2;
    }

    for (var i = 0; i < targets.length; i += 2) {
        if ((targets[i] === object) && (targets[i + 1] === method)) {
            if (targets.length == 2) {
                return null;
            }
            targets.splice(i, 2);
            return ss.Delegate._create(targets);
        }
    }

    return delegate1;
}

ss.Delegate.createExport = function Delegate$createExport(delegate, multiUse) {
    var name = '__' + (new Date()).valueOf();
    ss.Delegate[name] = function() {
        if (!multiUse) {
            ss.Delegate.deleteExport(name);
        }
        delegate.apply(null, arguments);
    };

    return name;
}

ss.Delegate.deleteExport = function Delegate$deleteExport(name) {
    if (ss.Delegate[name]) {
        delete ss.Delegate[name];
    }
}

ss.Delegate.clearExport = function Delegate$clearExport(name) {
    if (ss.Delegate[name]) {
        ss.Delegate[name] = Delegate.Null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// CultureInfo

ss.CultureInfo = function CultureInfo$(name, numberFormat, dateFormat) {
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateFormat = dateFormat;
}
ss.CultureInfo.registerClass('CultureInfo');

ss.CultureInfo.InvariantCulture = new ss.CultureInfo('en-US',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',
        
        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol:'$',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, MMMM dd, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, MMMM dd, yyyy',
        shortDatePattern: 'M/d/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
        shortDayNames: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
        minimizedDayNames: ['Su','Mo','Tu','We','Th','Fr','Sa'],

        monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December',''],
        shortMonthNames: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','']
    });
ss.CultureInfo.CurrentCulture = ss.CultureInfo.InvariantCulture;

///////////////////////////////////////////////////////////////////////////////
// IEnumerator

ss.IEnumerator = function IEnumerator$() { };
ss.IEnumerator.prototype = {
    get_current: null,
    moveNext: null,
    reset: null
}

ss.IEnumerator.getEnumerator = function ss_IEnumerator$getEnumerator(enumerable) {
    if (enumerable) {
        return enumerable.getEnumerator ? enumerable.getEnumerator() : new ss.ArrayEnumerator(enumerable);
    }
    return null;
}

ss.IEnumerator.registerInterface('IEnumerator');

///////////////////////////////////////////////////////////////////////////////
// IEnumerable

ss.IEnumerable = function IEnumerable$() { };
ss.IEnumerable.prototype = {
    getEnumerator: null
}
ss.IEnumerable.registerInterface('IEnumerable');

///////////////////////////////////////////////////////////////////////////////
// ArrayEnumerator

ss.ArrayEnumerator = function ArrayEnumerator$(array) {
    this._array = array;
    this._index = -1;
}
ss.ArrayEnumerator.prototype = {
    get_current: function ArrayEnumerator$get_current() {
        return this._array[this._index];
    },
    moveNext: function ArrayEnumerator$moveNext() {
        this._index++;
        return (this._index < this._array.length);
    },
    reset: function ArrayEnumerator$reset() {
        this._index = -1;
    }
}

ss.ArrayEnumerator.registerClass('ArrayEnumerator', null, ss.IEnumerator);

///////////////////////////////////////////////////////////////////////////////
// IDisposable

ss.IDisposable = function IDisposable$() { };
ss.IDisposable.prototype = {
    dispose: null
}
ss.IDisposable.registerInterface('IDisposable');

///////////////////////////////////////////////////////////////////////////////
// StringBuilder

ss.StringBuilder = function StringBuilder$(s) {
    this._parts = !ss.isNullOrUndefined(s) ? [s] : [];
    this.isEmpty = this._parts.length == 0;
}
ss.StringBuilder.prototype = {
    append: function StringBuilder$append(s) {
        if (!ss.isNullOrUndefined(s)) {
            ArrayPrototype_add(this._parts, s);
            this.isEmpty = false;
        }
        return this;
    },

    appendLine: function StringBuilder$appendLine(s) {
        this.append(s);
        this.append('\r\n');
        this.isEmpty = false;
        return this;
    },

    clear: function StringBuilder$clear() {
        ArrayPrototype_clear(this._parts);
        this.isEmpty = true;
    },

    toString: function StringBuilder$toString(s) {
        return this._parts.join(s || '');
    }
};

ss.StringBuilder.registerClass('StringBuilder');

///////////////////////////////////////////////////////////////////////////////
// EventArgs

ss.EventArgs = function EventArgs$() {
}
ss.EventArgs.registerClass('EventArgs');

ss.EventArgs.Empty = new ss.EventArgs();

///////////////////////////////////////////////////////////////////////////////
// XMLHttpRequest

if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function() {
        var progIDs = [ 'Msxml2.XMLHTTP', 'Microsoft.XMLHTTP' ];

        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlHttp = new ActiveXObject(progIDs[i]);
                return xmlHttp;
            }
            catch (ex) {
            }
        }

        return null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// XmlDocumentParser

ss.XmlDocumentParser = function XmlDocumentParser$() {
}
ss.XmlDocumentParser.registerClass('XmlDocumentParser');

ss.XmlDocumentParser.parse = function XmlDocumentParser$parse(markup) {
    try {
        if (DOMParser) {
            var domParser = new DOMParser();
            return domParser.parseFromString(markup, 'text/xml');
        }
        else {
        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
        
        for (var i = 0; i < progIDs.length; i++) {
                var xmlDOM = new ActiveXObject(progIDs[i]);
                xmlDOM.async = false;
                xmlDOM.loadXML(markup);
                xmlDOM.setProperty('SelectionLanguage', 'XPath');
                
                return xmlDOM;
            }
    }
        }
        catch (ex) {
        }

    return null;
}

///////////////////////////////////////////////////////////////////////////////
// CancelEventArgs

ss.CancelEventArgs = function CancelEventArgs$() {
    ss.CancelEventArgs.initializeBase(this);
    this.cancel = false;
}
ss.CancelEventArgs.registerClass('CancelEventArgs', ss.EventArgs);
;
_coveoDefineJQuery = function() { var $ = _coveoJQuery;
Type.registerNamespace('Coveo.CNL.Web.Scripts.BetterControls');

////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem

Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem = function Coveo_CNL_Web_Scripts_BetterControls_AutoCompleteItem() {
    /// <summary>
    /// Class that hold information about an item in the AutoComplete menu.
    /// </summary>
    /// <field name="m_Index" type="Number" integer="true">
    /// The index of the item in the menu.
    /// </field>
    /// <field name="m_IsCorrection" type="Boolean">
    /// Whether the item is a correction or not.
    /// </field>
    /// <field name="m_WasShortened" type="Boolean">
    /// Whether the correction was shortened or not.
    /// </field>
    /// <field name="m_IsCompletion" type="Boolean">
    /// Whether the item is a completion or not.
    /// </field>
    /// <field name="m_IsSampleQuery" type="Boolean">
    /// Whether the item is a sample query or not.
    /// </field>
    /// <field name="m_Text" type="String">
    /// The display value of the item.
    /// </field>
    /// <field name="m_Query" type="String">
    /// The query for this item.
    /// </field>
    /// <field name="m_ToolTip" type="Object" domElement="true">
    /// The element that contains the tooltip.
    /// </field>
    Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem.initializeBase(this);
}
Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem.prototype = {
    m_Index: 0,
    m_IsCorrection: false,
    m_WasShortened: false,
    m_IsCompletion: false,
    m_IsSampleQuery: false,
    m_Text: null,
    m_Query: null,
    m_ToolTip: null
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript

Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript = function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript() {
    /// <summary>
    /// Client side code for the BetterTextBox control.
    /// </summary>
    /// <field name="_m_DebugMode$1" type="Boolean" static="true">
    /// </field>
    /// <field name="_jS_BACKSPACE$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_TAB$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_ENTER$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_ESCAPE$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_UP$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_RIGHT$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_jS_DOWN$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_NonPrintables$1" type="Array" elementType="Number" elementInteger="true">
    /// </field>
    /// <field name="_m_MouseHasMoved$1" type="Boolean">
    /// </field>
    /// <field name="_m_SelectionConfirmed$1" type="Boolean">
    /// </field>
    /// <field name="_m_IsClearButtonClicked$1" type="Boolean">
    /// </field>
    /// <field name="_m_OnKeyDownEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnKeyPressEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnKeyUpEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnBlurEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnClearEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="m_Timer" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="m_TooltipTimer" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="m_DropDown" type="Object" domElement="true">
    /// </field>
    /// <field name="m_InnerDropDown" type="Object" domElement="true">
    /// </field>
    /// <field name="m_Items" type="Array" elementType="Object" elementDomElement="true">
    /// </field>
    /// <field name="m_Selected" type="Number" integer="true">
    /// </field>
    /// <field name="m_OuterBox" type="Object" domElement="true">
    /// </field>
    /// <field name="m_TextBox" type="Object" domElement="true">
    /// </field>
    /// <field name="m_ClearButton" type="Object" domElement="true">
    /// </field>
    /// <field name="m_TypingDelay" type="Number" integer="true">
    /// </field>
    /// <field name="m_DidYouMeanString" type="String">
    /// </field>
    /// <field name="m_OriginalPrefix" type="String">
    /// </field>
    /// <field name="m_SaveNewPrefix" type="Boolean">
    /// </field>
    /// <field name="m_IsTypingEventEnabled" type="Boolean">
    /// </field>
    /// <field name="m_IsAutoCompletionEnabled" type="Boolean">
    /// </field>
    this._m_NonPrintables$1 = [ 8, 9, 13, 16, 17, 18, 19, 20, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45, 46, 91, 92, 93, 144, 145 ];
    this.m_Selected = -1;
    Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript.prototype = {
    _m_MouseHasMoved$1: false,
    _m_SelectionConfirmed$1: false,
    _m_IsClearButtonClicked$1: false,
    _m_OnKeyDownEventHandler$1: null,
    _m_OnKeyPressEventHandler$1: null,
    _m_OnKeyUpEventHandler$1: null,
    _m_OnBlurEventHandler$1: null,
    _m_OnClearEventHandler$1: null,
    
    get__isClearButtonVisible$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$get__isClearButtonVisible$1() {
        /// <summary>
        /// Gets or sets the visibility of the clear button
        /// </summary>
        /// <value type="Boolean"></value>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_ClearButton);
        return this.m_ClearButton.style.visibility === 'visible' || this.m_ClearButton.style.visibility !== 'hidden';
    },
    set__isClearButtonVisible$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$set__isClearButtonVisible$1(value) {
        /// <summary>
        /// Gets or sets the visibility of the clear button
        /// </summary>
        /// <value type="Boolean"></value>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_ClearButton);
        if (value) {
            this.m_ClearButton.style.visibility = 'visible';
        }
        else {
            this.m_ClearButton.style.visibility = 'hidden';
        }
        return value;
    },
    
    m_Timer: null,
    m_TooltipTimer: null,
    m_DropDown: null,
    m_InnerDropDown: null,
    m_Items: null,
    m_OuterBox: null,
    m_TextBox: null,
    m_ClearButton: null,
    m_TypingDelay: 0,
    m_DidYouMeanString: null,
    m_OriginalPrefix: null,
    m_SaveNewPrefix: false,
    m_IsTypingEventEnabled: false,
    m_IsAutoCompletionEnabled: false,
    
    initialize: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_TextBox);
        this._m_OnKeyDownEventHandler$1 = ss.Delegate.create(this, this._onKeyDown$1);
        this.m_TextBox.attachEvent('onkeydown', this._m_OnKeyDownEventHandler$1);
        this._m_OnKeyPressEventHandler$1 = ss.Delegate.create(this, this._onKeyPress$1);
        this.m_TextBox.attachEvent('onkeypress', this._m_OnKeyPressEventHandler$1);
        this._m_OnKeyUpEventHandler$1 = ss.Delegate.create(this, this._onKeyUp$1);
        this.m_TextBox.attachEvent('onkeyup', this._m_OnKeyUpEventHandler$1);
        this._m_OnBlurEventHandler$1 = ss.Delegate.create(this, this._onBlur$1);
        this.m_TextBox.attachEvent('onblur', this._m_OnBlurEventHandler$1);
        if (this.m_ClearButton != null) {
            this._m_OnClearEventHandler$1 = ss.Delegate.create(this, this._onClearText$1);
            this.m_ClearButton.attachEvent('onclick', this._m_OnClearEventHandler$1);
            this._updateClearButtonVisibility$1();
        }
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$tearDown() {
        if (this._m_OnKeyDownEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onkeydown', this._m_OnKeyDownEventHandler$1);
        }
        if (this._m_OnKeyPressEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onkeypress', this._m_OnKeyPressEventHandler$1);
        }
        if (this._m_OnKeyUpEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onkeyup', this._m_OnKeyUpEventHandler$1);
        }
        if (this._m_OnBlurEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onblur', this._m_OnBlurEventHandler$1);
        }
        if (this._m_OnClearEventHandler$1 != null) {
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_ClearButton);
            this.m_ClearButton.detachEvent('onclick', this._m_OnClearEventHandler$1);
        }
    },
    
    notifyServer: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$notifyServer(p_Text, p_KeyCode, p_Callback) {
        /// <summary>
        /// Fetches completions for a given string.
        /// </summary>
        /// <param name="p_Text" type="String">
        /// The text of the textbox.
        /// </param>
        /// <param name="p_KeyCode" type="Number" integer="true">
        /// The last key that was typed.
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// The method to callback with results.
        /// </param>
    },
    
    notifyUserSelectedAutoComplete: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$notifyUserSelectedAutoComplete(p_Callback) {
        /// <summary>
        /// Notifies the server that the user selected an auto-complete entry.
        /// </summary>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// </param>
    },
    
    _onKeyUp$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_onKeyUp$1() {
        if (this.m_SaveNewPrefix) {
            this.m_OriginalPrefix = this.m_TextBox.value;
            this.m_SaveNewPrefix = false;
        }
        this._updateClearButtonVisibility$1();
    },
    
    _onKeyDown$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_onKeyDown$1() {
        var code = window.event.keyCode;
        var ctrlPressed = window.event.ctrlKey;
        if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_ENTER$1) {
            if (this.m_IsAutoCompletionEnabled) {
                if (this.m_Selected !== -1) {
                    this._acceptSelected$1();
                }
            }
            this._onBlur$1();
        }
        else if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_BACKSPACE$1) {
            this._cancelUpdate$1();
            if (ctrlPressed) {
                this._eraseLastQueryWord$1();
                window.event.cancelBubble = true;
                window.event.returnValue = false;
            }
            this._removeDropDown$1();
            this._armServerUpdate$1(code);
        }
        else if (this.m_IsAutoCompletionEnabled) {
            if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_UP$1 || code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_DOWN$1) {
                this._cancelUpdate$1();
                if (this.m_Items != null) {
                    if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_UP$1) {
                        this._selectPrevious$1();
                    }
                    else {
                        this._selectNext$1();
                    }
                }
                window.event.cancelBubble = true;
                window.event.returnValue = false;
            }
            else if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_ESCAPE$1) {
                this._cancelUpdate$1();
                this._removeDropDownAndRevert$1(true);
                window.event.cancelBubble = true;
                window.event.returnValue = false;
            }
            else if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_TAB$1) {
                this._cancelUpdate$1();
                this._acceptSelected$1();
                this._removeDropDown$1();
                window.event.cancelBubble = true;
                window.event.returnValue = false;
            }
            else if (code === Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_RIGHT$1) {
                if (this._isCaretOnEnd$1(this.m_TextBox)) {
                    this._cancelUpdate$1();
                    this._acceptSelected$1();
                    this._removeDropDown$1();
                }
            }
        }
    },
    
    _onKeyPress$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_onKeyPress$1() {
        var code = window.event.keyCode;
        if (this._isNonPrintableChar$1(code)) {
            return;
        }
        this._cancelUpdate$1();
        if (this.m_IsAutoCompletionEnabled) {
            if (this.m_Selected > -1) {
                this._acceptSelected$1();
                this._removeDropDown$1();
            }
        }
        this._armServerUpdate$1(code);
        this._updateClearButtonVisibility$1();
    },
    
    _onBlur$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_onBlur$1() {
        this._cancelUpdate$1();
        if (!Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._m_DebugMode$1) {
            new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, function() {
                this._removeDropDownAndRevert$1(true);
            }), 300);
        }
        this._updateClearButtonVisibility$1();
    },
    
    _onClearText$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_onClearText$1() {
        if (!this.m_TextBox.disabled) {
            this._m_IsClearButtonClicked$1 = true;
            this.m_TextBox.value = '';
            this.m_TextBox.focus();
            this._updateClearButtonVisibility$1();
        }
    },
    
    _armServerUpdate$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_armServerUpdate$1(p_KeyCode) {
        /// <summary>
        /// When the Typing event or auto completion is enabled, arms the timer to
        /// send the text box value to the server. When auto completion is enabled,
        /// query completions are returned.
        /// </summary>
        /// <param name="p_KeyCode" type="Number" integer="true">
        /// The last key that was typed.
        /// </param>
        this.m_SaveNewPrefix = true;
        if (this.m_IsTypingEventEnabled || this.m_IsAutoCompletionEnabled) {
            this.m_Timer = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, function() {
                if (this.m_IsAutoCompletionEnabled) {
                    if (String.isNullOrEmpty(this.m_TextBox.value)) {
                        this._removeDropDown$1();
                    }
                    Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Getting query suggests for [' + this.m_TextBox.value + ']...');
                }
                this.notifyServer(this.m_TextBox.value, p_KeyCode, ss.Delegate.create(this, this._serverUpdateCallback$1));
            }), this.m_TypingDelay);
        }
    },
    
    _cancelUpdate$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_cancelUpdate$1() {
        /// <summary>
        /// Cancels any pending update.
        /// </summary>
        if (this.m_Timer != null) {
            this.m_Timer.cancel();
        }
        Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().cancelPendingOperations();
    },
    
    _removeDropDown$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_removeDropDown$1() {
        /// <summary>
        /// Removes the dropdown if it is present. It does not revert the query prefix.
        /// </summary>
        this._removeDropDownAndRevert$1(false);
    },
    
    _removeDropDownAndRevert$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_removeDropDownAndRevert$1(p_RevertPrefix) {
        /// <summary>
        /// Removes the dropdown if it is present.
        /// </summary>
        /// <param name="p_RevertPrefix" type="Boolean">
        /// Indicates if the query must be reverted to original value.
        /// </param>
        if (this.m_DropDown != null) {
            if (p_RevertPrefix && !this._m_SelectionConfirmed$1 && !this._m_IsClearButtonClicked$1) {
                this._selectItem$1(-1);
            }
            this.m_DropDown.parentNode.removeChild(this.m_DropDown);
            this.m_DropDown = null;
        }
        this.m_Items = null;
        this.m_Selected = -1;
    },
    
    _serverUpdateCallback$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_serverUpdateCallback$1(p_Return) {
        /// <summary>
        /// Callback function for server updates.
        /// </summary>
        /// <param name="p_Return" type="Object">
        /// The xml returned by the server.
        /// </param>
        if (!this.m_IsAutoCompletionEnabled) {
            return;
        }
        if (p_Return == null) {
            this._removeDropDown$1();
            return;
        }
        this._m_MouseHasMoved$1 = false;
        var xml = p_Return;
        var corrections = xml.selectNodes('//Correction');
        var completions = xml.selectNodes('//Completion');
        if (corrections.length !== 0 || completions.length !== 0) {
            if (this.m_DropDown == null) {
                this.m_DropDown = document.createElement('div');
                this.m_DropDown.style.position = 'absolute';
                this.m_DropDown.style.zIndex = 999;
                this.m_DropDown.className = (this.m_ClearButton != null) ? 'CnlAutoCompleteDropdownMenuWithClear' : 'CnlAutoCompleteDropdownMenu';
                this.m_TextBox.parentNode.appendChild(this.m_DropDown);
                var totalWidth;
                if (this.m_OuterBox != null) {
                    totalWidth = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this.m_OuterBox).width;
                }
                else {
                    totalWidth = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this.m_TextBox).width;
                }
                this.m_DropDown.style.width = totalWidth + 'px';
                Coveo.CNL.Web.Scripts.DOMUtilities.positionElement(this.m_DropDown, this.m_TextBox, Coveo.CNL.Web.Scripts.PositionEnum.belowLeft);
                this.m_InnerDropDown = document.createElement('div');
                this.m_InnerDropDown.className = 'CnlAutoCompleteDropdownInnerMenu';
                this.m_DropDown.appendChild(this.m_InnerDropDown);
            }
            else {
                this.m_InnerDropDown.innerHTML = '';
            }
            this.m_Items = new Array(corrections.length + completions.length);
            this.m_Selected = -1;
            var index = 0;
            var $enum1 = ss.IEnumerator.getEnumerator(corrections);
            while ($enum1.moveNext()) {
                var node = $enum1.get_current();
                var item = document.createElement('div');
                item.m_Query = node.text;
                item.m_Text = node.text;
                item.m_Index = index++;
                item.m_IsCorrection = true;
                item.innerHTML = '<b>' + this.m_DidYouMeanString + ':</b> ' + item.m_Query;
                item.style.borderBottom = '1px solid silver';
                item.style.backgroundColor = 'whitesmoke';
                this._setupAndAddItem$1(item);
            }
            var $enum2 = ss.IEnumerator.getEnumerator(completions);
            while ($enum2.moveNext()) {
                var node = $enum2.get_current();
                var item = document.createElement('div');
                item.m_Text = (node.attributes.getNamedItem('Text')).value;
                item.m_Query = (node.attributes.getNamedItem('Query')).value;
                item.m_WasShortened = Boolean.parse((node.attributes.getNamedItem('WasShortened')).value);
                item.m_Index = index++;
                item.m_IsCompletion = true;
                item.innerHTML = (node.attributes.getNamedItem('DisplayText')).value;
                if (item.m_WasShortened) {
                    item.m_ToolTip = document.createElement('div');
                    item.m_ToolTip.className = 'CnlAutoCompleteDropdownTooltip';
                    item.m_ToolTip.innerHTML = item.m_Text;
                }
                this._setupAndAddItem$1(item);
            }
            this._m_SelectionConfirmed$1 = false;
        }
        else {
            this._removeDropDown$1();
        }
    },
    
    _setupAndAddItem$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_setupAndAddItem$1(p_Item) {
        /// <summary>
        /// Setup common properties for auto complete menu item.
        /// </summary>
        /// <param name="p_Item" type="Object" domElement="true">
        /// The item to setup.
        /// </param>
        p_Item.style.cursor = 'pointer';
        p_Item.style.padding = '3px';
        p_Item.className = 'CnlAutoCompleteDropdownItem';
        p_Item.attachEvent('onclick', ss.Delegate.create(this, function() {
            if (!this._m_SelectionConfirmed$1) {
                this._autoCompleteItemSelected$1(p_Item);
            }
        }));
        p_Item.attachEvent('onmousemove', ss.Delegate.create(this, function() {
            if (!this._m_SelectionConfirmed$1) {
                this._m_MouseHasMoved$1 = true;
            }
        }));
        p_Item.attachEvent('onmouseover', ss.Delegate.create(this, function() {
            if (!this._m_SelectionConfirmed$1) {
                if (this._m_MouseHasMoved$1) {
                    this._selectItem$1(p_Item.m_Index);
                }
            }
        }));
        p_Item.attachEvent('onmouseout', ss.Delegate.create(this, function() {
            if (!this._m_SelectionConfirmed$1) {
                if (!this._m_SelectionConfirmed$1) {
                    this._selectItem$1(-1);
                }
            }
        }));
        this.m_InnerDropDown.appendChild(p_Item);
        if (p_Item.m_ToolTip != null) {
            this.m_InnerDropDown.appendChild(p_Item.m_ToolTip);
        }
        this.m_Items[p_Item.m_Index] = p_Item;
    },
    
    _autoCompleteItemSelected$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_autoCompleteItemSelected$1(p_Item) {
        /// <summary>
        /// An iten has been selected.
        /// </summary>
        /// <param name="p_Item" type="Object" domElement="true">
        /// The items that is selected.
        /// </param>
        if (!p_Item.m_IsSampleQuery) {
            this._acceptSelected$1();
            this.notifyUserSelectedAutoComplete(null);
        }
    },
    
    _selectNext$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_selectNext$1() {
        /// <summary>
        /// Selects the next item.
        /// </summary>
        if (this.m_Selected < (this.m_Items.length - 1)) {
            this._selectItem$1(this.m_Selected + 1);
        }
        else {
            this._selectItem$1(-1);
        }
    },
    
    _selectPrevious$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_selectPrevious$1() {
        /// <summary>
        /// Selects the previous item.
        /// </summary>
        if (this.m_Selected >= 0) {
            this._selectItem$1(this.m_Selected - 1);
        }
        else {
            this._selectItem$1(this.m_Items.length - 1);
        }
    },
    
    _selectItem$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_selectItem$1(p_Index) {
        /// <summary>
        /// Changes the selected index.
        /// </summary>
        /// <param name="p_Index" type="Number" integer="true">
        /// The index of the item to select.
        /// </param>
        if (this.m_Selected !== -1) {
            var elem = this.m_Items[this.m_Selected];
            elem.className = 'CnlAutoCompleteDropdownItem';
            if (this.m_TooltipTimer != null) {
                this.m_TooltipTimer.cancel();
            }
            if (elem.m_WasShortened && !Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._m_DebugMode$1) {
                var jElem = $(elem.m_ToolTip);
                jElem.hide();
            }
        }
        if (p_Index !== -1) {
            var elem = this.m_Items[p_Index];
            elem.className = 'CnlAutoCompleteDropdownItemSelected';
            this.m_TextBox.value = elem.m_Text;
            if (elem.m_WasShortened) {
                var jElem = $(elem.m_ToolTip);
                this.m_TooltipTimer = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, function() {
                    jElem.show();
                }), 100);
            }
        }
        else {
            if (this.m_DropDown != null) {
                this.m_TextBox.value = this.m_OriginalPrefix;
            }
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.moveCaretAtTheEnd(this.m_TextBox);
        this.m_Selected = p_Index;
    },
    
    _getCompletionDisplay$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_getCompletionDisplay$1(p_CurrentPrefix, p_Item) {
        /// <summary>
        /// Retrieves the display value for a completion.
        /// </summary>
        /// <param name="p_CurrentPrefix" type="String">
        /// The current value.
        /// </param>
        /// <param name="p_Item" type="Object" domElement="true">
        /// The completion for which the display value is needed.
        /// </param>
        /// <returns type="String"></returns>
        var disp = p_Item.m_Text;
        var first = disp.indexOf('$');
        var last = disp.lastIndexOf('$');
        if (first !== -1) {
            if (first === last) {
                disp = disp.replaceAll('$', '');
            }
            else {
                disp = disp.substring(0, first) + '<u>' + disp.substring(first + 1, last) + '</u>' + disp.substring(last + 1, disp.length);
                p_Item.m_IsSampleQuery = true;
            }
        }
        return disp;
    },
    
    _acceptSelected$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_acceptSelected$1() {
        /// <summary>
        /// Accepts the selected item, putting it into the textbox.
        /// </summary>
        this._m_SelectionConfirmed$1 = true;
        var elem = this.m_Items[this.m_Selected];
        if (elem.m_IsCompletion) {
            var first = elem.m_Query.indexOf('$');
            var last = elem.m_Query.lastIndexOf('$');
            if (first !== -1) {
                if (first === last) {
                    this.m_TextBox.value = elem.m_Query.replaceAll('$', '');
                    Coveo.CNL.Web.Scripts.DOMUtilities.setSelectedRange(this.m_TextBox, first, first);
                }
                else {
                    this.m_TextBox.value = elem.m_Query.substring(0, first) + elem.m_Query.substring(first + 1, last) + elem.m_Query.substring(last + 1, elem.m_Query.length);
                    Coveo.CNL.Web.Scripts.DOMUtilities.setSelectedRange(this.m_TextBox, first, last - 1);
                }
            }
            else {
                this.m_TextBox.value = elem.m_Query;
            }
        }
        else {
            this.m_TextBox.value = elem.m_Query;
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.moveCaretAtTheEnd(this.m_TextBox);
    },
    
    _isCaretOnEnd$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_isCaretOnEnd$1(p_Ctrl) {
        /// <summary>
        /// Indicates if the caret is positionned at the end of the text box.
        /// </summary>
        /// <param name="p_Ctrl" type="Object" domElement="true">
        /// The <see cref="T:System.Html.TextElement" />.
        /// </param>
        /// <returns type="Boolean"></returns>
        var pos = 0;
        pos = Coveo.CNL.Web.Scripts.DOMUtilities.getSelectionStart(p_Ctrl);
        return pos === p_Ctrl.value.length;
    },
    
    _eraseLastQueryWord$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_eraseLastQueryWord$1() {
        /// <summary>
        /// Erases the last word from the query box
        /// </summary>
        var value = this.m_TextBox.value;
        if (value.length > 0) {
            while (value.endsWith(' ') || value.endsWith('-')) {
                value = value.substr(0, value.length - 1);
            }
            var idxLastSpace = value.lastIndexOf(' ');
            var idxLastHyphen = value.lastIndexOf('-');
            var idxTrim = Math.max(idxLastSpace, idxLastHyphen);
            if (idxTrim > 0) {
                this.m_TextBox.value = this.m_TextBox.value.substr(0, idxTrim + 1);
            }
            else {
                this.m_TextBox.value = '';
            }
        }
    },
    
    _updateClearButtonVisibility$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_updateClearButtonVisibility$1() {
        /// <summary>
        /// Show or hide the clear button according to the
        /// content of the text box.
        /// </summary>
        if (this.m_ClearButton != null) {
            if (this.m_TextBox.value.length > 0 && !this.get__isClearButtonVisible$1()) {
                this._m_IsClearButtonClicked$1 = false;
                this.set__isClearButtonVisible$1(true);
            }
            else if (this.m_TextBox.value.length === 0) {
                this.set__isClearButtonVisible$1(false);
            }
            if (this.m_TextBox.disabled && this.m_ClearButton.className !== 'CnlClearTextButtonDisabled') {
                this.m_ClearButton.className = 'CnlClearTextButtonDisabled';
            }
            else if (this.m_ClearButton.className !== 'CnlClearTextButton') {
                this.m_ClearButton.className = 'CnlClearTextButton';
            }
        }
    },
    
    _isNonPrintableChar$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterTextBoxScript$_isNonPrintableChar$1(p_KeyCode) {
        /// <summary>
        /// Checks if the key code corresponds to a non-printable character.
        /// </summary>
        /// <param name="p_KeyCode" type="Number" integer="true">
        /// The key code to check
        /// </param>
        /// <returns type="Boolean"></returns>
        var isFound = false;
        var $enum1 = ss.IEnumerator.getEnumerator(this._m_NonPrintables$1);
        while ($enum1.moveNext()) {
            var code = $enum1.get_current();
            if (p_KeyCode === code) {
                isFound = true;
                break;
            }
        }
        return isFound;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BetterControls.TabControlScript

Coveo.CNL.Web.Scripts.BetterControls.TabControlScript = function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript() {
    /// <summary>
    /// Client side code for the TabControl control.
    /// </summary>
    /// <field name="m_Element" type="Object" domElement="true">
    /// The main element for the tab control.
    /// </field>
    /// <field name="m_Header" type="Object" domElement="true">
    /// The element containing the header.
    /// </field>
    /// <field name="m_TabHeaders" type="Object" domElement="true">
    /// The element containing the tab headers.
    /// </field>
    /// <field name="m_Body" type="Object" domElement="true">
    /// The element containing the body.
    /// </field>
    /// <field name="m_AllowSorting" type="Boolean">
    /// Whether to allow sorting tabs.
    /// </field>
    /// <field name="m_SetBodyHeight" type="Boolean">
    /// Whether to set the body height depending on the tab control height.
    /// </field>
    Coveo.CNL.Web.Scripts.BetterControls.TabControlScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.BetterControls.TabControlScript.prototype = {
    m_Element: null,
    m_Header: null,
    m_TabHeaders: null,
    m_Body: null,
    m_AllowSorting: false,
    m_SetBodyHeight: false,
    
    initialize: function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript$initialize() {
        if (this.m_AllowSorting) {
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_TabHeaders);
            var options = {};
            options['axis'] = 'x';
            options['items'] = '.CnlMovableTab';
            options['containment'] = 'parent';
            options['stop'] = ss.Delegate.create(this, this._sortable_Stop$1);
            $(this.m_TabHeaders).sortable(options);
        }
        if (this.m_SetBodyHeight) {
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Element);
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Header);
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Body);
            this._setBodyHeight$1();
        }
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript$tearDown() {
    },
    
    updateTabPositions: function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript$updateTabPositions(p_Tabs) {
        /// <summary>
        /// Updates the position of the tabs on the server side.
        /// </summary>
        /// <param name="p_Tabs" type="Array" elementType="Number" elementInteger="true">
        /// List of tab indexes in the new order.
        /// </param>
    },
    
    _setBodyHeight$1: function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript$_setBodyHeight$1() {
        /// <summary>
        /// Sets the height of the body to the proper value.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.check(this.m_Element.style.height !== '');
        var elem = $(this.m_Element);
        var available = elem.innerHeight();
        available -= $(this.m_Header).outerHeight();
        this.m_Body.style.height = available + 'px';
    },
    
    _sortable_Stop$1: function Coveo_CNL_Web_Scripts_BetterControls_TabControlScript$_sortable_Stop$1(p_Event, p_UI) {
        /// <param name="p_Event" type="jQueryEvent">
        /// </param>
        /// <param name="p_UI" type="Object">
        /// </param>
        var tabs = [];
        for (var i = 0; i < this.m_TabHeaders.children.length; ++i) {
            var id = this.m_TabHeaders.children[i].id;
            var pos = id.lastIndexOf('_');
            Coveo.CNL.Web.Scripts.CNLAssert.check(pos !== -1);
            var index = parseInt(id.substr(pos + 1));
            ArrayPrototype_add(tabs, index);
        }
        this.updateTabPositions(tabs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript

Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript = function Coveo_CNL_Web_Scripts_BetterControls_BetterButtonScript() {
    /// <summary>
    /// Client side code for the BetterButton control.
    /// </summary>
    /// <field name="m_Button" type="Object" domElement="true">
    /// </field>
    /// <field name="m_DisableOnClick" type="Boolean">
    /// </field>
    /// <field name="m_DisableAlso" type="String">
    /// </field>
    /// <field name="_m_ButtonClickDomEventHandler$1" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript.prototype = {
    m_Button: null,
    m_DisableOnClick: false,
    m_DisableAlso: null,
    _m_ButtonClickDomEventHandler$1: null,
    
    initialize: function Coveo_CNL_Web_Scripts_BetterControls_BetterButtonScript$initialize() {
        this._m_ButtonClickDomEventHandler$1 = ss.Delegate.create(this, this._button_OnClick$1);
        this.m_Button.attachEvent('onclick', this._m_ButtonClickDomEventHandler$1);
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_BetterControls_BetterButtonScript$tearDown() {
        if (this._m_ButtonClickDomEventHandler$1 != null) {
            this.m_Button.detachEvent('onclick', this._m_ButtonClickDomEventHandler$1);
            this._m_ButtonClickDomEventHandler$1 = null;
        }
    },
    
    _button_OnClick$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterButtonScript$_button_OnClick$1() {
        if (this.m_DisableOnClick) {
            this.m_Button.disabled = true;
            if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(this.m_DisableAlso)) {
                var deserializer = new Coveo.CNL.Web.Scripts.StringDeserializer(this.m_DisableAlso);
                var names = deserializer.getStringArray();
                for (var i = 0; i < names.length; i++) {
                    var name = names[i];
                    var element = document.getElementById(name);
                    if (element != null) {
                        element.disabled = true;
                    }
                }
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript

Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript = function Coveo_CNL_Web_Scripts_BetterControls_BetterLinkButtonScript() {
    /// <summary>
    /// Client side code for the BetterLinkButton control.
    /// </summary>
    /// <field name="m_Button" type="Object" domElement="true">
    /// </field>
    /// <field name="m_DisableOnClick" type="Boolean">
    /// </field>
    /// <field name="_m_ButtonClickDomEventHandler$1" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript.prototype = {
    m_Button: null,
    m_DisableOnClick: false,
    _m_ButtonClickDomEventHandler$1: null,
    
    initialize: function Coveo_CNL_Web_Scripts_BetterControls_BetterLinkButtonScript$initialize() {
        this._m_ButtonClickDomEventHandler$1 = ss.Delegate.create(this, this._button_OnClick$1);
        this.m_Button.attachEvent('onclick', this._m_ButtonClickDomEventHandler$1);
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_BetterControls_BetterLinkButtonScript$tearDown() {
        if (this._m_ButtonClickDomEventHandler$1 != null) {
            this.m_Button.detachEvent('onclick', this._m_ButtonClickDomEventHandler$1);
            this._m_ButtonClickDomEventHandler$1 = null;
        }
    },
    
    _button_OnClick$1: function Coveo_CNL_Web_Scripts_BetterControls_BetterLinkButtonScript$_button_OnClick$1() {
        if (this.m_DisableOnClick) {
            this.m_Button.disabled = true;
        }
    }
}


Type.registerNamespace('Coveo.CNL.Web.Scripts.Widgets');

////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Widgets.WidgetScript

Coveo.CNL.Web.Scripts.Widgets.WidgetScript = function Coveo_CNL_Web_Scripts_Widgets_WidgetScript() {
    /// <summary>
    /// Client side code for the Widget control.
    /// </summary>
    /// <field name="m_Element" type="Object" domElement="true">
    /// The main element for the widget.
    /// </field>
    /// <field name="m_Header" type="Object" domElement="true">
    /// The element for the header (optional).
    /// </field>
    /// <field name="m_Body" type="Object" domElement="true">
    /// The element for the body.
    /// </field>
    /// <field name="m_SetBodyHeight" type="Boolean">
    /// Whether to set the body height depending on the widget height.
    /// </field>
    /// <field name="m_AllowResizingWidth" type="Boolean">
    /// Whether to the width of the widget is resizable.
    /// </field>
    /// <field name="m_AllowResizingHeight" type="Boolean">
    /// Whether to the height of the widget is resizable.
    /// </field>
    Coveo.CNL.Web.Scripts.Widgets.WidgetScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Widgets.WidgetScript.prototype = {
    m_Element: null,
    m_Header: null,
    m_Body: null,
    m_SetBodyHeight: false,
    m_AllowResizingWidth: false,
    m_AllowResizingHeight: false,
    
    initialize: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Element);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Body);
        var elem = $(this.m_Element);
        if (this.m_SetBodyHeight) {
            this._setBodyHeight$1();
        }
        if (this.m_AllowResizingWidth || this.m_AllowResizingHeight) {
            var options = {};
            if (this.m_AllowResizingWidth && this.m_AllowResizingHeight) {
                options['handles'] = 's, e, se';
            }
            else if (this.m_AllowResizingWidth) {
                options['handles'] = 'e';
            }
            else if (this.m_AllowResizingHeight) {
                options['handles'] = 's';
            }
            options['grid'] = [ 10, 10 ];
            options['resize'] = ss.Delegate.create(this, this._element_Resize$1);
            options['stop'] = ss.Delegate.create(this, this._element_StopResize$1);
            elem.resizable(options);
        }
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$tearDown() {
    },
    
    updateWidgetSize: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$updateWidgetSize(p_Width, p_Height, p_Callback) {
        /// <param name="p_Width" type="Number" integer="true">
        /// </param>
        /// <param name="p_Height" type="Number" integer="true">
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// </param>
    },
    
    _setBodyHeight$1: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$_setBodyHeight$1() {
        /// <summary>
        /// Sets the height of the body according to the widget and header height.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.check(this.m_Element.style.height !== '');
        var elem = $(this.m_Element);
        var available = elem.innerHeight();
        if (this.m_Header != null) {
            available -= $(this.m_Header).outerHeight();
        }
        this.m_Body.style.height = available + 'px';
    },
    
    _element_Resize$1: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$_element_Resize$1(e) {
        /// <param name="e" type="jQueryEvent">
        /// </param>
        if (this.m_SetBodyHeight) {
            this._setBodyHeight$1();
        }
    },
    
    _element_StopResize$1: function Coveo_CNL_Web_Scripts_Widgets_WidgetScript$_element_StopResize$1(e) {
        /// <param name="e" type="jQueryEvent">
        /// </param>
        var elem = $(this.m_Element);
        this.updateWidgetSize(elem.width(), elem.height(), null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript

Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript = function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript() {
    /// <summary>
    /// Client side code for the WidgetZone control.
    /// </summary>
    /// <field name="_accepT_ALL_CLASS$1" type="String" static="true">
    /// </field>
    /// <field name="_s_Zones$1" type="Object" static="true">
    /// </field>
    /// <field name="m_UniqueID" type="String">
    /// The unique ID of the zone.
    /// </field>
    /// <field name="m_Widgets" type="Object" domElement="true">
    /// The element that contains the sortable widgets
    /// </field>
    Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript.prototype = {
    m_UniqueID: null,
    m_Widgets: null,
    
    initialize: function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(this.m_UniqueID);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_Widgets);
        Coveo.CNL.Web.Scripts.CNLAssert.check(!Object.keyExists(Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1, this.m_UniqueID));
        Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1[this.m_UniqueID] = this;
        var elem = $(this.m_Widgets);
        elem.addClass(Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._accepT_ALL_CLASS$1);
        var options = {};
        options['connectWith'] = '.' + Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._accepT_ALL_CLASS$1;
        options['handle'] = '.CnlWidgetHeader';
        options['stop'] = ss.Delegate.create(this, function(ev, ui) {
            this._sendStatusUpdateForAllZones$1();
        });
        elem.sortable(options);
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript$tearDown() {
        Coveo.CNL.Web.Scripts.CNLAssert.check(Object.keyExists(Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1, this.m_UniqueID));
        delete Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1[this.m_UniqueID];
    },
    
    registerWidget: function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript$registerWidget(p_ClientID, p_UniqueID) {
        /// <summary>
        /// Registers a widget.
        /// </summary>
        /// <param name="p_ClientID" type="String">
        /// The client ID of the element for the widget.
        /// </param>
        /// <param name="p_UniqueID" type="String">
        /// The unique ID of the element for the widget.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_ClientID);
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_UniqueID);
        var elem = document.getElementById(p_ClientID);
        elem.m_UniqueID = p_UniqueID;
    },
    
    updateWidgetPositions: function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript$updateWidgetPositions(p_Xml, p_Callback) {
        /// <param name="p_Xml" type="String">
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// </param>
    },
    
    _sendStatusUpdateForAllZones$1: function Coveo_CNL_Web_Scripts_Widgets_WidgetZoneScript$_sendStatusUpdateForAllZones$1() {
        /// <summary>
        /// Sends the status update for all zones.
        /// </summary>
        var builder = new ss.StringBuilder();
        builder.append('<Zones>');
        var $dict1 = Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var zone = entry.value;
            var zoneElement = $(zone.m_Widgets);
            builder.append('<Zone UniqueID=\"' + entry.key + '\">');
            zoneElement.children('.CnlWidget').each(ss.Delegate.create(this, function(index, widget) {
                var uniqueID = widget.m_UniqueID;
                Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(uniqueID);
                builder.append('<Widget>' + uniqueID + '</Widget>');
            }));
            builder.append('</Zone>');
        }
        builder.append('</Zones>');
        this.updateWidgetPositions(builder.toString(), null);
    }
}


Type.registerNamespace('Coveo.CNL.Web.Scripts.Ajax');

////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.EasingFunction

Coveo.CNL.Web.Scripts.Ajax.EasingFunction = function() { 
    /// <summary>
    /// The various easing functions that can be applied to a <see cref="T:Coveo.CNL.Web.Scripts.Ajax.PercentTimer" />.
    /// </summary>
    /// <field name="flat" type="Number" integer="true" static="true">
    /// No easing function.
    /// </field>
    /// <field name="fastSlow" type="Number" integer="true" static="true">
    /// Fast-slow easing function.
    /// </field>
    /// <field name="slowFast" type="Number" integer="true" static="true">
    /// Slow-fast easing function.
    /// </field>
    /// <field name="slowFastSlow" type="Number" integer="true" static="true">
    /// Slow-fast-slow easing function.
    /// </field>
};
Coveo.CNL.Web.Scripts.Ajax.EasingFunction.prototype = {
    flat: 1, 
    fastSlow: 2, 
    slowFast: 3, 
    slowFastSlow: 4
}
Coveo.CNL.Web.Scripts.Ajax.EasingFunction.registerEnum('Coveo.CNL.Web.Scripts.Ajax.EasingFunction', false);


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.IContentFlipper

Coveo.CNL.Web.Scripts.Ajax.IContentFlipper = function() { 
    /// <summary>
    /// Interface for objects that flip content.
    /// </summary>
};
Coveo.CNL.Web.Scripts.Ajax.IContentFlipper.prototype = {
    get_newContent : null,
    flip : null
}
Coveo.CNL.Web.Scripts.Ajax.IContentFlipper.registerInterface('Coveo.CNL.Web.Scripts.Ajax.IContentFlipper');


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess

Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess = function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcess() {
    /// <summary>
    /// Base class for asynchronous processes.
    /// </summary>
    /// <field name="_m_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager">
    /// </field>
}
Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess.prototype = {
    _m_Manager: null,
    
    get_manager: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcess$get_manager() {
        /// <summary>
        /// The AsynchronousProcessManager that manages us.
        /// </summary>
        /// <value type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager"></value>
        return this._m_Manager;
    },
    set_manager: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcess$set_manager(value) {
        /// <summary>
        /// The AsynchronousProcessManager that manages us.
        /// </summary>
        /// <value type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager"></value>
        this._m_Manager = value;
        return value;
    },
    
    start: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcess$start() {
        /// <summary>
        /// Starts the asynchronous process.
        /// </summary>
        this.beginProcess();
    },
    
    terminate: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcess$terminate() {
        /// <summary>
        /// Forces the asynchronous process to terminate.
        /// </summary>
        this.endProcess();
        if (this._m_Manager != null) {
            this._m_Manager.processIsDone(this);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.ControlFlipper

Coveo.CNL.Web.Scripts.Ajax.ControlFlipper = function Coveo_CNL_Web_Scripts_Ajax_ControlFlipper(p_Old, p_Html) {
    /// <summary>
    /// Implementation of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> for flipping the whole
    /// html for a control (including the outer tag).
    /// </summary>
    /// <param name="p_Old" type="Object" domElement="true">
    /// The old element that is being replaced.
    /// </param>
    /// <param name="p_Html" type="String">
    /// The updated html to replace with.
    /// </param>
    /// <field name="_m_Old" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Html" type="String">
    /// </field>
    /// <field name="_m_New" type="Object" domElement="true">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Old);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Html);
    this._m_Old = p_Old;
    this._m_Html = p_Html;
    this._m_New = document.createElement('div');
    this._m_New.style.display = 'none';
    document.body.appendChild(this._m_New);
    this._m_New.innerHTML = this._m_Html;
    Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_New.children.length === 1);
}
Coveo.CNL.Web.Scripts.Ajax.ControlFlipper.prototype = {
    _m_Old: null,
    _m_Html: null,
    _m_New: null,
    
    get_newContent: function Coveo_CNL_Web_Scripts_Ajax_ControlFlipper$get_newContent() {
        /// <value type="Object" domElement="true"></value>
        return this._m_New.firstChild;
    },
    
    flip: function Coveo_CNL_Web_Scripts_Ajax_ControlFlipper$flip() {
        /// <returns type="Object" domElement="true"></returns>
        var child = this._m_New.firstChild;
        this._m_Old.parentNode.insertBefore(child, this._m_Old);
        this._m_Old.parentNode.removeChild(this._m_Old);
        this._m_New.parentNode.removeChild(this._m_New);
        return child;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.CollapseTransition

Coveo.CNL.Web.Scripts.Ajax.CollapseTransition = function Coveo_CNL_Web_Scripts_Ajax_CollapseTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that collapses a tag from it's normal size to nothing.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we collapse.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_InitialHeight$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.CollapseTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.CollapseTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_InitialHeight$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_CollapseTransition$beginTransition() {
        this._m_InitialHeight$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).height;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.height = this._m_InitialHeight$2 + 'px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_CollapseTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Element$2.style.display = 'none';
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Flipper$2.flip(), this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_CollapseTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.height = ((this._m_InitialHeight$2 * Math.cos(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.CollapseTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AdjustTransition

Coveo.CNL.Web.Scripts.Ajax.AdjustTransition = function Coveo_CNL_Web_Scripts_Ajax_AdjustTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that gradually adjusts the size of an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we adjust.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_InitialHeight$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Offset$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.AdjustTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.AdjustTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_InitialHeight$2: 0,
    _m_Offset$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_AdjustTransition$beginTransition() {
        this._m_InitialHeight$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).height;
        this._m_Element$2 = this._m_Flipper$2.flip();
        this._m_Offset$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).height - this._m_InitialHeight$2;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.height = this._m_InitialHeight$2 + 'px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_AdjustTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Element$2, this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_AdjustTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.height = ((this._m_InitialHeight$2 + this._m_Offset$2 * Math.sin(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.AdjustTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.Console

Coveo.CNL.Web.Scripts.Ajax.Console = function Coveo_CNL_Web_Scripts_Ajax_Console() {
    /// <summary>
    /// Implements a console on the client side for debugging purposes.
    /// </summary>
    /// <field name="_s_Console" type="Coveo.CNL.Web.Scripts.Ajax.Console" static="true">
    /// </field>
    /// <field name="_m_Frame" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Content" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Visible" type="Boolean">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.isNull(Coveo.CNL.Web.Scripts.Ajax.Console._s_Console);
    Coveo.CNL.Web.Scripts.Ajax.Console._s_Console = this;
    this._m_Frame = document.createElement('div');
    this._m_Frame.style.position = 'absolute';
    this._m_Frame.style.left = '5%';
    this._m_Frame.style.top = '5%';
    this._m_Frame.style.width = '90%';
    this._m_Frame.style.height = '90%';
    this._m_Frame.style.border = '2px solid silver';
    this._m_Frame.style.backgroundColor = 'whitesmoke';
    document.body.appendChild(this._m_Frame);
    this._m_Content = document.createElement('div');
    this._m_Content.style.fontFamily = 'Consolas';
    this._m_Content.style.fontSize = '10pt';
    this._m_Content.style.padding = '10px';
    this._m_Frame.appendChild(this._m_Content);
    this._m_Frame.style.display = 'none';
    document.body.attachEvent('onkeypress', ss.Delegate.create(this, this._body_KeyPress));
    Coveo.CNL.Web.Scripts.Ajax.Console.writeLine('allo');
    Coveo.CNL.Web.Scripts.Ajax.Console.writeLine('toi');
}
Coveo.CNL.Web.Scripts.Ajax.Console.writeLine = function Coveo_CNL_Web_Scripts_Ajax_Console$writeLine(p_Text) {
    /// <summary>
    /// Writes a line of text to the console.
    /// </summary>
    /// <param name="p_Text" type="String">
    /// The text to write to the console.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Text);
    if (Coveo.CNL.Web.Scripts.Ajax.Console._s_Console != null) {
        Coveo.CNL.Web.Scripts.Ajax.Console._s_Console.outputLineOfText(p_Text);
    }
}
Coveo.CNL.Web.Scripts.Ajax.Console.writeHtmlLine = function Coveo_CNL_Web_Scripts_Ajax_Console$writeHtmlLine(p_Html) {
    /// <summary>
    /// Writes a line of html to the console.
    /// </summary>
    /// <param name="p_Html" type="String">
    /// The html to write to the console.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Html);
    if (Coveo.CNL.Web.Scripts.Ajax.Console._s_Console != null) {
        Coveo.CNL.Web.Scripts.Ajax.Console._s_Console.outputLineOfHtml(p_Html);
    }
}
Coveo.CNL.Web.Scripts.Ajax.Console.prototype = {
    _m_Frame: null,
    _m_Content: null,
    _m_Visible: false,
    
    outputLineOfText: function Coveo_CNL_Web_Scripts_Ajax_Console$outputLineOfText(p_Text) {
        /// <summary>
        /// Writes a line of text to the console.
        /// </summary>
        /// <param name="p_Text" type="String">
        /// The text to write to the console.
        /// </param>
        var line = document.createElement('div');
        line.innerText = p_Text;
        this._m_Content.appendChild(line);
    },
    
    outputLineOfHtml: function Coveo_CNL_Web_Scripts_Ajax_Console$outputLineOfHtml(p_Html) {
        /// <summary>
        /// Writes a line of html to the console.
        /// </summary>
        /// <param name="p_Html" type="String">
        /// The html to write to the console.
        /// </param>
        var line = document.createElement('div');
        line.innerHTML = p_Html;
        this._m_Content.appendChild(line);
    },
    
    _body_KeyPress: function Coveo_CNL_Web_Scripts_Ajax_Console$_body_KeyPress() {
        if (window.event.keyCode === 126) {
            if (!this._m_Visible) {
                this._m_Frame.style.display = 'block';
                this._m_Visible = true;
            }
            else {
                this._m_Frame.style.display = 'none';
                this._m_Visible = false;
            }
            window.event.cancelBubble = true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript

Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript = function Coveo_CNL_Web_Scripts_Ajax_AjaxObjectScript() {
    /// <summary>
    /// Base class for client objects created using the AjaxObject class.
    /// </summary>
    /// <field name="_m_OwnerId" type="String">
    /// </field>
}
Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript.prototype = {
    _m_OwnerId: null,
    
    get_ownerId: function Coveo_CNL_Web_Scripts_Ajax_AjaxObjectScript$get_ownerId() {
        /// <summary>
        /// The id of the control that owns the object.
        /// </summary>
        /// <value type="String"></value>
        return this._m_OwnerId;
    },
    set_ownerId: function Coveo_CNL_Web_Scripts_Ajax_AjaxObjectScript$set_ownerId(value) {
        /// <summary>
        /// The id of the control that owns the object.
        /// </summary>
        /// <value type="String"></value>
        this._m_OwnerId = value;
        return value;
    },
    
    initialize: function Coveo_CNL_Web_Scripts_Ajax_AjaxObjectScript$initialize() {
        /// <summary>
        /// Initializes the object after initialization from the server data is done.
        /// </summary>
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Ajax_AjaxObjectScript$tearDown() {
        /// <summary>
        /// Tears down the object when his associated region of the DOM is removed or replaced.
        /// </summary>
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.BlankFeedback

Coveo.CNL.Web.Scripts.Ajax.BlankFeedback = function Coveo_CNL_Web_Scripts_Ajax_BlankFeedback(p_Element, p_Fullscreen, p_Image) {
    /// <summary>
    /// Feedback that blanks the area to be updated until the postback finishes.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element to which the feedback is associated.
    /// </param>
    /// <param name="p_Fullscreen" type="Boolean">
    /// Whether to display the feedback in fullscreen mode.
    /// </param>
    /// <param name="p_Image" type="String">
    /// The uri of the image to display.
    /// </param>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Overlay$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Fullscreen$2" type="Boolean">
    /// </field>
    /// <field name="_m_Image$2" type="String">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.BlankFeedback.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Image);
    this._m_Element$2 = p_Element;
    this._m_Fullscreen$2 = p_Fullscreen;
    this._m_Image$2 = p_Image;
}
Coveo.CNL.Web.Scripts.Ajax.BlankFeedback.prototype = {
    _m_Element$2: null,
    _m_Overlay$2: null,
    _m_Fullscreen$2: false,
    _m_Image$2: null,
    
    beginFeedback: function Coveo_CNL_Web_Scripts_Ajax_BlankFeedback$beginFeedback() {
        var bounds;
        if (this._m_Fullscreen$2) {
            bounds = Coveo.CNL.Web.Scripts.DOMUtilities.getVisibleRectangle();
        }
        else {
            bounds = Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(this._m_Element$2.parentNode);
            bounds = Coveo.CNL.Web.Scripts.DOMUtilities.getIntersection(bounds, Coveo.CNL.Web.Scripts.DOMUtilities.getVisibleRectangle());
        }
        this._m_Overlay$2 = document.createElement('div');
        this._m_Overlay$2.style.backgroundColor = 'white';
        this._m_Overlay$2.style.position = 'absolute';
        this._m_Overlay$2.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
        Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Overlay$2, 0.75);
        document.body.appendChild(this._m_Overlay$2);
        Coveo.CNL.Web.Scripts.DOMUtilities.setElementBounds(this._m_Overlay$2, bounds);
        this._m_Overlay$2.innerHTML = '<table width=100% height=100%><tr><td align=\"center\"><img src=\"' + this._m_Image$2 + '\"/></tr></td></table>';
    },
    
    endFeedback: function Coveo_CNL_Web_Scripts_Ajax_BlankFeedback$endFeedback() {
        document.body.removeChild(this._m_Overlay$2);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.Bootstrap

Coveo.CNL.Web.Scripts.Ajax.Bootstrap = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap() {
    /// <summary>
    /// Provides methods for inserting an ASP.NET page form into a non-ASP.NET
    /// page.
    /// </summary>
    /// <field name="_forwarD_QUERY_STRING_OPTION" type="String" static="true">
    /// </field>
    /// <field name="_caN_ADD_HTTP_HEADERS_OPTION" type="String" static="true">
    /// </field>
    /// <field name="_displaY_ERRORS_IN_WHOLE_PAGE_OPTION" type="String" static="true">
    /// </field>
    /// <field name="_s_Request" type="XMLHttpRequest" static="true">
    /// </field>
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPage = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$insertAjaxAspNetPage(p_Path, p_Element, p_ForwardQueryString) {
    /// <summary>
    /// Inserts an Ajax ASP.NET page under a specified <see cref="T:System.Html.Element" />.
    /// </summary>
    /// <param name="p_Path" type="String">
    /// The path on the local server from which to load the page.
    /// </param>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element under which to insert the page.
    /// </param>
    /// <param name="p_ForwardQueryString" type="Boolean">
    /// Whether to forward the content of the query string.
    /// </param>
    var options = {};
    options[Coveo.CNL.Web.Scripts.Ajax.Bootstrap._forwarD_QUERY_STRING_OPTION] = p_ForwardQueryString;
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPageWithOptions(p_Path, p_Element, options);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPageWithOptions = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$insertAjaxAspNetPageWithOptions(p_Path, p_Element, p_Options) {
    /// <summary>
    /// Inserts an Ajax ASP.NET page under a specified <see cref="T:System.Html.Element" />.
    /// </summary>
    /// <param name="p_Path" type="String">
    /// The path on the local server from which to load the page.
    /// </param>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element under which to insert the page.
    /// </param>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Path);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    var panels = {};
    panels[''] = p_Element;
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPanelsWithOptions(p_Path, panels, p_Options);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPanels = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$insertAjaxAspNetPanels(p_Path, p_Panels, p_ForwardQueryString) {
    /// <summary>
    /// Inserts panels of an Ajax ASP.NET page under a set of
    /// <see cref="T:System.Html.Element" /> objects.
    /// </summary>
    /// <param name="p_Path" type="String">
    /// The path on the local server from which to load the page.
    /// </param>
    /// <param name="p_Panels" type="Object">
    /// The elements under which to insert the update panels present in the page (referenced by their ClientID).
    /// </param>
    /// <param name="p_ForwardQueryString" type="Boolean">
    /// Whether to forward the content of the query string.
    /// </param>
    var options = {};
    options[Coveo.CNL.Web.Scripts.Ajax.Bootstrap._forwarD_QUERY_STRING_OPTION] = p_ForwardQueryString;
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPanelsWithOptions(p_Path, p_Panels, options);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap.insertAjaxAspNetPanelsWithOptions = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$insertAjaxAspNetPanelsWithOptions(p_Path, p_Panels, p_Options) {
    /// <summary>
    /// Inserts panels of an Ajax ASP.NET page under a set of
    /// <see cref="T:System.Html.Element" /> objects.
    /// </summary>
    /// <param name="p_Path" type="String">
    /// The path on the local server from which to load the page.
    /// </param>
    /// <param name="p_Panels" type="Object">
    /// The elements under which to insert the update panels present in the page (referenced by their ClientID).
    /// </param>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion. Look at the remarks for more information.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Path);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Panels);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap._validateOptions(p_Options);
    if (p_Path.startsWith('http://') || p_Path.startsWith('https://')) {
        alert('The Path argument must not include a server name.');
    }
    var target = p_Path;
    if (target.indexOf('?') === -1) {
        target += '?';
    }
    if (Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getForwardQueryStringOption(p_Options) && !Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(window.location.search)) {
        target += '&' + window.location.search.substr(1);
    }
    if (Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getCanAddHttpHeadersOption(p_Options)) {
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request = new XMLHttpRequest();
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.open('GET', target, true);
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.partiaL_POSTBACK_MARKER, '1');
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.bootstraP_MARKER, '1');
        if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(window.location.hash) && window.location.hash.startsWith('#s=')) {
            Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.historY_STATE_MARKER, window.location.hash.substr(3));
        }
    }
    else {
        target += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.partiaL_POSTBACK_MARKER + '=1';
        target += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.bootstraP_MARKER + '=1';
        if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(window.location.hash) && window.location.hash.startsWith('#s=')) {
            target += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.historY_STATE_MARKER + '=' + window.location.hash.substr(3);
        }
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request = new XMLHttpRequest();
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.open('GET', target, true);
    }
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.onreadystatechange = function() {
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._requestCallback(p_Path, p_Panels, p_Options);
    };
    Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.send('');
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._requestCallback = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_requestCallback(p_Uri, p_Panels, p_Options) {
    /// <summary>
    /// Callback for request events.
    /// </summary>
    /// <param name="p_Uri" type="String">
    /// The uri of the page that is being bootstrapped.
    /// </param>
    /// <param name="p_Panels" type="Object">
    /// The element under which to insert the update panels present in the page (referenced by their ClientID).
    /// </param>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Panels);
    if (Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.readyState === 4) {
        var errorReceived = false;
        if (Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.status === 200) {
            var responseXml = Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.responseXML;
            if (!ss.isNullOrUndefined(responseXml) && responseXml.documentElement != null) {
                Coveo.CNL.Web.Scripts.Ajax.Bootstrap._doBootstrapFromXml(p_Uri, p_Panels, responseXml, p_Options);
            }
            else {
                errorReceived = true;
            }
        }
        else {
            errorReceived = true;
        }
        if (errorReceived) {
            var errorText = Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.responseText;
            if (String.isNullOrEmpty(errorText)) {
                errorText = 'Cannot load the interface: ' + Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request.statusText;
            }
            if (!Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getDisplayErrorsInWholePageOption(p_Options)) {
                Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displayErrorInAllPanels(errorText, p_Panels);
            }
            else {
                Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displayErrorInWholePage(errorText);
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request = null;
    }
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._doBootstrapFromXml = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_doBootstrapFromXml(p_Uri, p_Panels, p_Xml, p_Options) {
    /// <summary>
    /// Performs the bootstraping using the xml returned by the server.
    /// </summary>
    /// <param name="p_Uri" type="String">
    /// The uri of the page that is being bootstrapped.
    /// </param>
    /// <param name="p_Panels" type="Object">
    /// The element under which to insert the update panels present in the page (referenced by their ClientID).
    /// </param>
    /// <param name="p_Xml" type="XmlDocument">
    /// The <see cref="T:System.Xml.XmlDocument" /> from which to bootstrap.
    /// </param>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Panels);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Xml);
    var bootstrap = p_Xml.selectSingleNode('/AjaxManager/Bootstrap');
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(bootstrap);
    var html = bootstrap.text;
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(html);
    var form;
    var additionalForms = [];
    if (p_Panels[''] != null) {
        Coveo.CNL.Web.Scripts.CNLAssert.check(Object.getKeyCount(p_Panels) === 1);
        var elem = p_Panels[''];
        elem.innerHTML = html;
        form = elem.getElementsByTagName('form')[0];
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(form);
    }
    else {
        var tempElement = document.createElement('div');
        tempElement.style.display = 'none';
        tempElement.innerHTML = html;
        document.body.appendChild(tempElement);
        var $dict1 = p_Panels;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var elem = entry.value;
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(elem);
            var subForm = document.createElement('form');
            ArrayPrototype_add(additionalForms, subForm);
            var panel = document.getElementById(entry.key);
            elem.innerHTML = '';
            elem.appendChild(subForm);
            panel.parentNode.removeChild(panel);
            subForm.appendChild(panel);
        }
        form = tempElement.getElementsByTagName('form')[0];
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(form);
        var elements = [];
        ArrayPrototype_addRange(elements, form.elements);
        form.innerHTML = '';
        for (var i = 0; i < elements.length; ++i) {
            form.appendChild(elements[i]);
        }
        form.style.display = 'none';
        document.body.appendChild(form);
        tempElement.parentNode.removeChild(tempElement);
        tempElement = null;
    }
    var protectNodes = p_Xml.selectNodes('/AjaxManager/ProtectAgainstRestore');
    for (var i = 0; i < protectNodes.length; ++i) {
        var protect = protectNodes[i];
        var elemId = (protect.attributes.getNamedItem('Id')).value;
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(elemId);
        var elem = document.getElementById(elemId);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(elem);
        Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.takeBackupOfValue(elem);
    }
    form.action = p_Uri;
    var viewstate = null;
    var inputs = form.getElementsByTagName('input');
    for (var i = 0; i < inputs.length; ++i) {
        var input = inputs[i];
        if (input.name === Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE) {
            viewstate = input.value;
            break;
        }
    }
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(viewstate);
    var additionalFormsArray;
    if (additionalForms.length !== 0) {
        additionalFormsArray = new Array(additionalForms.length);
        for (var i = 0; i < additionalForms.length; ++i) {
            additionalFormsArray[i] = additionalForms[i];
        }
    }
    else {
        additionalFormsArray = null;
    }
    var id = (bootstrap.attributes.getNamedItem('Id')).value;
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(id);
    var mgr = new Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript();
    _aM = mgr;;
    mgr.set_bootstrap(true);
    mgr.set_enableHistory(true);
    mgr.initialize(id, form, additionalFormsArray, Coveo.CNL.Web.Scripts.Ajax.Bootstrap._dummyDoPostBack, p_Xml, true, Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getCanAddHttpHeadersOption(p_Options));
    eval('__doPostBack = function(t, a) { _aM.doPostBack(t, a); };');
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displayErrorInAllPanels = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_displayErrorInAllPanels(p_Error, p_Panels) {
    /// <summary>
    /// Displays an error in all the panels that we should have filled.
    /// </summary>
    /// <param name="p_Error" type="String">
    /// The error to display.
    /// </param>
    /// <param name="p_Panels" type="Object">
    /// The panels that we're supposed to fill.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Error);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Panels);
    var $dict1 = p_Panels;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        var elem = entry.value;
        elem.innerHTML = p_Error;
    }
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displayErrorInWholePage = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_displayErrorInWholePage(p_Error) {
    /// <summary>
    /// Displays an error in the whole page.
    /// </summary>
    /// <param name="p_Error" type="String">
    /// The error to display.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Error);
    var elem = document.body;
    elem.innerHTML = p_Error;
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._dummyDoPostBack = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_dummyDoPostBack(p_Target, p_Argument) {
    /// <summary>
    /// Dummy implementation of the framework's __doPostBack function.
    /// </summary>
    /// <param name="p_Target" type="String">
    /// </param>
    /// <param name="p_Argument" type="String">
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.fail();
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._validateOptions = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_validateOptions(p_Options) {
    /// <summary>
    /// Validates the options passed to an insertion call.
    /// </summary>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    var $dict1 = p_Options;
    for (var $key2 in $dict1) {
        var option = { key: $key2, value: $dict1[$key2] };
        switch (option.key) {
            case Coveo.CNL.Web.Scripts.Ajax.Bootstrap._forwarD_QUERY_STRING_OPTION:
            case Coveo.CNL.Web.Scripts.Ajax.Bootstrap._caN_ADD_HTTP_HEADERS_OPTION:
            case Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displaY_ERRORS_IN_WHOLE_PAGE_OPTION:
                if (ss.isNullOrUndefined(option.value)) {
                    alert('The bootstrap option \'' + option.key + '\' value is null or undefined. The default value will be used.');
                }
                else if (!(Type.canCast(option.value, Boolean))) {
                    alert('The bootstrap option \'' + option.key + '\' value \'' + option.value.toString() + '\' is not a bool. The default value will be used.');
                }
                break;
            default:
                alert('The bootstrap option \'' + option.key + '\' is not recognized.');
                break;
        }
    }
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getForwardQueryStringOption = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_getForwardQueryStringOption(p_Options) {
    /// <summary>
    /// Gets whether to forward the content of the query string or not from
    /// the options passed to an insertion call.
    /// </summary>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    /// <returns type="Boolean"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    return Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getBoolOption(Coveo.CNL.Web.Scripts.Ajax.Bootstrap._forwarD_QUERY_STRING_OPTION, p_Options, true);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getCanAddHttpHeadersOption = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_getCanAddHttpHeadersOption(p_Options) {
    /// <summary>
    /// Gets whether custom entries can be added in the header of HTTP
    /// requests or not from the options passed to an insertion call.
    /// </summary>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    /// <returns type="Boolean"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    return Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getBoolOption(Coveo.CNL.Web.Scripts.Ajax.Bootstrap._caN_ADD_HTTP_HEADERS_OPTION, p_Options, true);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getDisplayErrorsInWholePageOption = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_getDisplayErrorsInWholePageOption(p_Options) {
    /// <summary>
    /// Gets whether to replace the content of the document body with the
    /// error HTML markup or not from the options passed to an insertion call.
    /// </summary>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    /// <returns type="Boolean"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    return Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getBoolOption(Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displaY_ERRORS_IN_WHOLE_PAGE_OPTION, p_Options, false);
}
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._getBoolOption = function Coveo_CNL_Web_Scripts_Ajax_Bootstrap$_getBoolOption(p_OptionName, p_Options, p_DefaultValue) {
    /// <summary>
    /// Gets a <b>bool</b> option from the options passed to an insertion
    /// call.
    /// </summary>
    /// <param name="p_OptionName" type="String">
    /// The name of the option to get.
    /// </param>
    /// <param name="p_Options" type="Object">
    /// The options to use for the insertion.
    /// </param>
    /// <param name="p_DefaultValue" type="Boolean">
    /// The default value to return if the option is not set.
    /// </param>
    /// <returns type="Boolean"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_OptionName);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Options);
    var value = p_DefaultValue;
    var option = p_Options[p_OptionName];
    if (!ss.isNullOrUndefined(option) && Type.canCast(option, Boolean)) {
        value = option;
    }
    return value;
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript

Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript = function Coveo_CNL_Web_Scripts_Ajax_AjaxProgressScript(p_Manager, p_PostBack) {
    /// <summary>
    /// Client side code for the AjaxProgress control.
    /// </summary>
    /// <param name="p_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" /> object.
    /// </param>
    /// <param name="p_PostBack" type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.PartialPostBack" /> object.
    /// </param>
    /// <field name="_initiaL_DELAY$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_polL_DELAY$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Manager$1" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// </field>
    /// <field name="_m_PostBack$1" type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack">
    /// </field>
    /// <field name="_m_Timeout$1" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Request$1" type="XMLHttpRequest">
    /// </field>
    /// <field name="_m_Element$1" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Cancelled$1" type="Boolean">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Manager);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_PostBack);
    this._m_Manager$1 = p_Manager;
    this._m_PostBack$1 = p_PostBack;
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(this._m_Manager$1.get_progressPageUri());
}
Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript.prototype = {
    _m_Manager$1: null,
    _m_PostBack$1: null,
    _m_Timeout$1: null,
    _m_Request$1: null,
    _m_Element$1: null,
    _m_Cancelled$1: false,
    
    beginProcess: function Coveo_CNL_Web_Scripts_Ajax_AjaxProgressScript$beginProcess() {
        this._m_Timeout$1 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._progressCallback$1), Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript._initiaL_DELAY$1);
    },
    
    endProcess: function Coveo_CNL_Web_Scripts_Ajax_AjaxProgressScript$endProcess() {
        if (this._m_Timeout$1 != null) {
            this._m_Timeout$1.cancel();
            this._m_Timeout$1 = null;
        }
        if (this._m_Request$1 != null) {
            this._m_Request$1.abort();
            this._m_Request$1 = null;
        }
        if (this._m_Element$1 != null) {
            this._m_Element$1.parentNode.removeChild(this._m_Element$1);
            this._m_Element$1 = null;
        }
        this._m_Cancelled$1 = true;
    },
    
    _progressCallback$1: function Coveo_CNL_Web_Scripts_Ajax_AjaxProgressScript$_progressCallback$1() {
        /// <summary>
        /// Callback for the progress timeout.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_Request$1);
        this._m_Request$1 = new XMLHttpRequest();
        this._m_Request$1.open('GET', this._m_Manager$1.get_progressPageUri() + '&rqid=' + this._m_PostBack$1.get_uniqueID(), true);
        this._m_Request$1.onreadystatechange = ss.Delegate.create(this, this._requestCallback$1);
        this._m_Request$1.send(null);
    },
    
    _requestCallback$1: function Coveo_CNL_Web_Scripts_Ajax_AjaxProgressScript$_requestCallback$1() {
        /// <summary>
        /// Callback for request events.
        /// </summary>
        if (this._m_Request$1.readyState === 4) {
            if (this._m_Element$1 != null) {
                this._m_Element$1.parentNode.removeChild(this._m_Element$1);
                this._m_Element$1 = null;
            }
            if (this._m_Request$1.status === 200 && this._m_Request$1.responseText !== '') {
                this._m_Element$1 = document.createElement('div');
                this._m_Element$1.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
                Coveo.CNL.Web.Scripts.DOMUtilities.coverAllWindow(this._m_Element$1);
                document.body.appendChild(this._m_Element$1);
                var table = document.createElement('table');
                table.style.width = '100%';
                table.style.height = '100%';
                var row = table.insertRow(0);
                var cell = row.insertCell(0);
                cell.align = 'center';
                cell.valign = 'middle';
                this._m_Element$1.appendChild(table);
                var div = document.createElement('div');
                div.innerHTML = this._m_Request$1.responseText;
                cell.appendChild(div);
            }
            else if (this._m_Request$1.status === 200) {
            }
            else {
                Coveo.CNL.Web.Scripts.CNLAssert.fail();
            }
            this._m_Request$1 = null;
            if (!this._m_Cancelled$1) {
                this._m_Timeout$1 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._progressCallback$1), Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript._polL_DELAY$1);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript

Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript = function Coveo_CNL_Web_Scripts_Ajax_AjaxTabableObjectScript() {
    /// <summary>
    /// Base class for every client tabable AjaxObject.
    /// </summary>
    /// <field name="_m_Element$1" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_OnClickDomEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_KeyDownDomEventHandler$1" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript.prototype = {
    _m_Element$1: null,
    _m_OnClickDomEventHandler$1: null,
    _m_KeyDownDomEventHandler$1: null,
    
    addOnClickAttribute: function Coveo_CNL_Web_Scripts_Ajax_AjaxTabableObjectScript$addOnClickAttribute(p_Element, p_OnClickEventHandler, p_MakeTabable) {
        /// <summary>
        /// Add the OnClick event handler on a control and make sure that the control
        /// also works with the keyboard (TAB+ENTER).
        /// </summary>
        /// <param name="p_Element" type="Object" domElement="true">
        /// Element on which attach OnClick and OnKeyDown event handlers.
        /// </param>
        /// <param name="p_OnClickEventHandler" type="ElementEventHandler">
        /// Event handler.
        /// </param>
        /// <param name="p_MakeTabable" type="Boolean">
        /// Whether to make the control tab-able (usable with the keyboard).
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_OnClickEventHandler);
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_Element$1);
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_OnClickDomEventHandler$1);
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_KeyDownDomEventHandler$1);
        this._m_Element$1 = p_Element;
        this._m_OnClickDomEventHandler$1 = p_OnClickEventHandler;
        this._m_Element$1.attachEvent('onclick', this._m_OnClickDomEventHandler$1);
        if (p_MakeTabable) {
            this._m_KeyDownDomEventHandler$1 = ss.Delegate.create(this, this._element_KeyDown$1);
            this._m_Element$1.attachEvent('onkeydown', this._m_KeyDownDomEventHandler$1);
            this._m_Element$1.setAttribute('tabIndex', '0');
        }
    },
    
    initialize: function Coveo_CNL_Web_Scripts_Ajax_AjaxTabableObjectScript$initialize() {
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Ajax_AjaxTabableObjectScript$tearDown() {
        if (this._m_KeyDownDomEventHandler$1 != null) {
            this._m_Element$1.detachEvent('onkeydown', this._m_KeyDownDomEventHandler$1);
            this._m_Element$1.removeAttribute('tabIndex');
            this._m_KeyDownDomEventHandler$1 = null;
        }
        if (this._m_OnClickDomEventHandler$1 != null) {
            this._m_Element$1.detachEvent('onclick', this._m_OnClickDomEventHandler$1);
            this._m_OnClickDomEventHandler$1 = null;
        }
        this._m_Element$1 = null;
    },
    
    _element_KeyDown$1: function Coveo_CNL_Web_Scripts_Ajax_AjaxTabableObjectScript$_element_KeyDown$1() {
        if (window.event.keyCode === 13) {
            this._m_OnClickDomEventHandler$1.invoke();
            window.event.cancelBubble = true;
            window.event.returnValue = false;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.DropDownContentController

Coveo.CNL.Web.Scripts.Ajax.DropDownContentController = function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController() {
    /// <summary>
    /// Client side code for a drop down content controler control.
    /// </summary>
    /// <field name="_m_OnLeaveManyEvent$1" type="Coveo.CNL.Web.Scripts.OnLeaveManyEvent">
    /// </field>
    /// <field name="m_DropDown" type="Object" domElement="true">
    /// The drop down element.
    /// </field>
    /// <field name="m_HotSpot" type="Object" domElement="true">
    /// The hot spot element.
    /// </field>
    /// <field name="m_DisplayOnHotSpotOver" type="Object" domElement="true">
    /// The element to display on hot spot.
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.DropDownContentController.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.DropDownContentController.prototype = {
    _m_OnLeaveManyEvent$1: null,
    m_DropDown: null,
    m_HotSpot: null,
    m_DisplayOnHotSpotOver: null,
    
    initialize: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_HotSpot);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_DropDown);
        this.m_HotSpot.attachEvent('onclick', ss.Delegate.create(this, this._hotSpot_OnClick$1));
        this.m_DropDown.attachEvent('onclick', ss.Delegate.create(this, this._dropDown_OnClick$1));
        if (this.m_DisplayOnHotSpotOver != null) {
            this.m_HotSpot.attachEvent('onmouseover', ss.Delegate.create(this, this._hotSpot_OnMouseOver$1));
            this.m_HotSpot.attachEvent('onmouseout', ss.Delegate.create(this, this._hotSpot_OnMouseOut$1));
        }
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$tearDown() {
        this.m_HotSpot.detachEvent('onclick', ss.Delegate.create(this, this._hotSpot_OnClick$1));
        this.m_DropDown.detachEvent('onclick', ss.Delegate.create(this, this._dropDown_OnClick$1));
        if (this.m_DisplayOnHotSpotOver != null) {
            this.m_HotSpot.detachEvent('onmouseover', ss.Delegate.create(this, this._hotSpot_OnMouseOver$1));
            this.m_HotSpot.detachEvent('onmouseout', ss.Delegate.create(this, this._hotSpot_OnMouseOut$1));
        }
        this.m_DropDown = null;
        this.m_HotSpot = null;
        this.m_DisplayOnHotSpotOver = null;
    },
    
    _hotSpot_OnMouseOver$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_hotSpot_OnMouseOver$1() {
        /// <summary>
        /// Called when the hot spot has a mouse over.
        /// </summary>
        this.m_DisplayOnHotSpotOver.style.display = 'inline';
        Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().blockTimer();
    },
    
    _hotSpot_OnMouseOut$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_hotSpot_OnMouseOut$1() {
        /// <summary>
        /// Called when the hot spot has a mouse out.
        /// </summary>
        this.m_DisplayOnHotSpotOver.style.display = 'none';
        Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().unblockTimer();
    },
    
    _hotSpot_OnClick$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_hotSpot_OnClick$1() {
        /// <summary>
        /// Called when the hot spot is clicked.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_HotSpot);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_DropDown);
        if (this.m_DropDown.style.display === 'none') {
            if (this._m_OnLeaveManyEvent$1 == null) {
                this._m_OnLeaveManyEvent$1 = new Coveo.CNL.Web.Scripts.OnLeaveManyEvent([ this.m_HotSpot, this.m_DropDown ], 200, ss.Delegate.create(this, this._hide$1));
            }
            else {
                this._m_OnLeaveManyEvent$1.attach([ this.m_HotSpot, this.m_DropDown ], 200, ss.Delegate.create(this, this._hide$1));
            }
            this._display$1();
        }
        else {
            this._hide$1();
        }
    },
    
    _dropDown_OnClick$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_dropDown_OnClick$1() {
        /// <summary>
        /// Called when the drop down is clicked.
        /// </summary>
        if (window.event.srcElement !== this.m_DropDown) {
            this._hide$1();
        }
    },
    
    _display$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_display$1() {
        /// <summary>
        /// Displays the drop down.
        /// </summary>
        this.m_DropDown.style.position = 'absolute';
        this.m_DropDown.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
        this.m_DropDown.style.display = 'block';
        Coveo.CNL.Web.Scripts.DOMUtilities.positionElement(this.m_DropDown, this.m_HotSpot, Coveo.CNL.Web.Scripts.PositionEnum.belowLeft);
        Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().blockTimer();
    },
    
    _hide$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownContentController$_hide$1() {
        /// <summary>
        /// Hides the drop down.
        /// </summary>
        if (this.m_DropDown.style.display === 'block') {
            this.m_DropDown.style.display = 'none';
            this._m_OnLeaveManyEvent$1.dispose();
            Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().unblockTimer();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler

Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler = function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler() {
    /// <summary>
    /// Client side code for a menu controler control.
    /// </summary>
    /// <field name="_m_OnLeaveManyEvent$1" type="Coveo.CNL.Web.Scripts.OnLeaveManyEvent">
    /// </field>
    /// <field name="_m_DropDownsByHotSpotID$1" type="Object">
    /// </field>
    /// <field name="_m_LastMenuDisplayed$1" type="Object" domElement="true">
    /// </field>
    this._m_DropDownsByHotSpotID$1 = {};
    Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler.prototype = {
    _m_OnLeaveManyEvent$1: null,
    _m_LastMenuDisplayed$1: null,
    
    initialize: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_DropDownsByHotSpotID$1);
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$tearDown() {
        this._m_DropDownsByHotSpotID$1 = null;
    },
    
    addMenuDropdown: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$addMenuDropdown(p_HotSpotID, p_DropDownID) {
        /// <param name="p_HotSpotID" type="String">
        /// </param>
        /// <param name="p_DropDownID" type="String">
        /// </param>
        this._m_DropDownsByHotSpotID$1[p_HotSpotID] = p_DropDownID;
        var hotSpot = document.getElementById(p_HotSpotID);
        var dropDown = document.getElementById(p_DropDownID);
        hotSpot.attachEvent('onmouseover', ss.Delegate.create(this, this._hotSpot_MouseOver$1));
    },
    
    _hotSpot_MouseOver$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$_hotSpot_MouseOver$1() {
        var hotSpot = null;
        var dropDown = null;
        var $dict1 = this._m_DropDownsByHotSpotID$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            hotSpot = document.getElementById(entry.key);
            if (hotSpot.contains(window.event.srcElement)) {
                break;
            }
        }
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(hotSpot);
        dropDown = document.getElementById(this._m_DropDownsByHotSpotID$1[hotSpot.id].toString());
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(dropDown);
        if (this._m_LastMenuDisplayed$1 !== dropDown) {
            if (this._m_OnLeaveManyEvent$1 == null) {
                this._m_OnLeaveManyEvent$1 = new Coveo.CNL.Web.Scripts.OnLeaveManyEvent([ hotSpot, dropDown ], 300, ss.Delegate.create(this, this._onTimeout$1));
            }
            else {
                this._m_OnLeaveManyEvent$1.dispose();
                this._m_OnLeaveManyEvent$1.attach([ hotSpot, dropDown ], 300, ss.Delegate.create(this, this._onTimeout$1));
            }
            this._display$1(hotSpot, dropDown);
        }
    },
    
    _onTimeout$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$_onTimeout$1() {
        var $dict1 = this._m_DropDownsByHotSpotID$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var dropDown = document.getElementById(entry.value.toString());
            dropDown.style.display = 'none';
        }
        this._m_LastMenuDisplayed$1 = null;
    },
    
    _display$1: function Coveo_CNL_Web_Scripts_Ajax_DropDownMenuControler$_display$1(p_HotSpot, p_DropDown) {
        /// <param name="p_HotSpot" type="Object" domElement="true">
        /// </param>
        /// <param name="p_DropDown" type="Object" domElement="true">
        /// </param>
        if (this._m_LastMenuDisplayed$1 != null) {
            this._m_LastMenuDisplayed$1.style.display = 'none';
        }
        p_DropDown.style.position = 'absolute';
        p_DropDown.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
        p_DropDown.style.display = 'block';
        Coveo.CNL.Web.Scripts.DOMUtilities.positionElement(p_DropDown, p_HotSpot, Coveo.CNL.Web.Scripts.PositionEnum.belowLeft);
        this._m_LastMenuDisplayed$1 = p_DropDown;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript

Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript = function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript(p_Data) {
    /// <summary>
    /// Allows specifying options on how a partial postback should be performed.
    /// </summary>
    /// <param name="p_Data" type="String">
    /// Postback options serialized by the server.
    /// </param>
    /// <field name="_m_ForcePartialPostback" type="Boolean">
    /// </field>
    /// <field name="_m_SendControlData" type="Boolean">
    /// </field>
    /// <field name="_m_TriggerFeedbacks" type="Boolean">
    /// </field>
    /// <field name="_m_IgnoreResults" type="Boolean">
    /// </field>
    var deserializer = new Coveo.CNL.Web.Scripts.StringDeserializer(p_Data);
    this._m_ForcePartialPostback = deserializer.getBool();
    this._m_SendControlData = deserializer.getBool();
    this._m_TriggerFeedbacks = deserializer.getBool();
    this._m_IgnoreResults = deserializer.getBool();
}
Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript.prototype = {
    _m_ForcePartialPostback: false,
    _m_SendControlData: true,
    _m_TriggerFeedbacks: true,
    _m_IgnoreResults: false,
    
    get_forcePartialPostback: function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript$get_forcePartialPostback() {
        /// <summary>
        /// Whether to force a partial postback.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_ForcePartialPostback;
    },
    
    get_sendControlData: function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript$get_sendControlData() {
        /// <summary>
        /// Whether control data should be sent along with the postback.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_SendControlData;
    },
    
    get_triggerFeedbacks: function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript$get_triggerFeedbacks() {
        /// <summary>
        /// Whether applicable feedbacks should be triggered.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_TriggerFeedbacks;
    },
    
    get_ignoreResults: function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript$get_ignoreResults() {
        /// <summary>
        /// Whether to ignore the results of the request.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_IgnoreResults;
    },
    set_ignoreResults: function Coveo_CNL_Web_Scripts_Ajax_PostbackOptionsScript$set_ignoreResults(value) {
        /// <summary>
        /// Whether to ignore the results of the request.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_IgnoreResults = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack

Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack = function Coveo_CNL_Web_Scripts_Ajax_ProcessingFeedBack(p_Target, p_Text) {
    /// <summary>
    /// Feedback that is triggered when some job is processing.
    /// Used for links, it changes the link text for "Processing ..."
    /// </summary>
    /// <param name="p_Target" type="Object" domElement="true">
    /// The target control of the feedback.
    /// </param>
    /// <param name="p_Text" type="String">
    /// The text to display.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Target$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Text$2" type="String">
    /// </field>
    /// <field name="_m_ProcessingElement$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_state$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_displaySetting$2" type="String">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Target);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Text);
    this._m_Target$2 = p_Target;
    this._m_Text$2 = p_Text;
}
Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack.prototype = {
    _m_Target$2: null,
    _m_Text$2: null,
    _m_ProcessingElement$2: null,
    _m_Timeout$2: null,
    _m_state$2: 0,
    _m_displaySetting$2: null,
    
    beginFeedback: function Coveo_CNL_Web_Scripts_Ajax_ProcessingFeedBack$beginFeedback() {
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
        this._m_displaySetting$2 = this._m_Target$2.style.display;
        this._m_Target$2.style.display = 'none';
        this._m_ProcessingElement$2 = document.createElement('span');
        this._m_ProcessingElement$2.innerText = this._m_Text$2 + ' .  ';
        this._m_Target$2.parentNode.insertBefore(this._m_ProcessingElement$2, this._m_Target$2);
    },
    
    endFeedback: function Coveo_CNL_Web_Scripts_Ajax_ProcessingFeedBack$endFeedback() {
        this._m_Timeout$2.cancel();
        this._m_Target$2.parentNode.removeChild(this._m_ProcessingElement$2);
        this._m_Target$2.style.display = this._m_displaySetting$2;
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_ProcessingFeedBack$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        switch (this._m_state$2) {
            case 0:
                this._m_ProcessingElement$2.innerText = this._m_Text$2 + ' .  ';
                ++this._m_state$2;
                break;
            case 1:
                this._m_ProcessingElement$2.innerText = this._m_Text$2 + ' .. ';
                ++this._m_state$2;
                break;
            case 2:
                this._m_ProcessingElement$2.innerText = this._m_Text$2 + ' ...';
                this._m_state$2 = 0;
                break;
            default:
                Coveo.CNL.Web.Scripts.CNLAssert.fail();
                break;
        }
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack._framE_DELAY$2);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.Profiler

Coveo.CNL.Web.Scripts.Ajax.Profiler = function Coveo_CNL_Web_Scripts_Ajax_Profiler() {
    /// <summary>
    /// Allows profiling client side operations.
    /// </summary>
    /// <field name="_s_Current" type="Coveo.CNL.Web.Scripts.Ajax.Profiler" static="true">
    /// </field>
    /// <field name="_s_Results" type="Object" domElement="true" static="true">
    /// </field>
    /// <field name="_s_CloseLink" type="Object" domElement="true" static="true">
    /// </field>
    /// <field name="_m_Start" type="Date">
    /// </field>
    /// <field name="_m_Messages" type="Array">
    /// </field>
    /// <field name="_m_OnCloseEventHandler" type="ElementEventHandler">
    /// </field>
    this._m_Start = new Date();
    this._m_Messages = [];
    Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Current = this;
}
Coveo.CNL.Web.Scripts.Ajax.Profiler.log = function Coveo_CNL_Web_Scripts_Ajax_Profiler$log(p_Message) {
    /// <summary>
    /// Logs an event to the current instance of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.Profiler" />.
    /// </summary>
    /// <param name="p_Message" type="String">
    /// The message of the event to log.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Message);
    if (Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Current != null) {
        Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Current._logInternal(p_Message);
    }
}
Coveo.CNL.Web.Scripts.Ajax.Profiler.prototype = {
    _m_OnCloseEventHandler: null,
    
    stop: function Coveo_CNL_Web_Scripts_Ajax_Profiler$stop() {
        /// <summary>
        /// Stops the profiling and displays the results.
        /// </summary>
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Profiling stopped.');
        if (Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results != null) {
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(Coveo.CNL.Web.Scripts.Ajax.Profiler._s_CloseLink);
            Coveo.CNL.Web.Scripts.Ajax.Profiler._s_CloseLink.detachEvent('onclick', this._m_OnCloseEventHandler);
            Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results.parentNode.removeChild(Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results);
        }
        var results = document.createElement('div');
        results.style.position = 'absolute';
        results.style.left = '10px';
        results.style.top = '10px';
        results.style.padding = '5px';
        results.style.border = '1px solid black';
        results.style.backgroundColor = 'white';
        results.style.zIndex = 999;
        results.style.fontFamily = 'Tahoma';
        results.style.fontSize = '8pt';
        var closeLink = document.createElement('a');
        closeLink.innerText = 'Close';
        this._m_OnCloseEventHandler = ss.Delegate.create(this, this._onCloseResults);
        closeLink.attachEvent('onclick', this._m_OnCloseEventHandler);
        closeLink.href = 'javascript:void(0);';
        results.appendChild(closeLink);
        for (var i = 0; i < this._m_Messages.length; i++) {
            var msg = this._m_Messages[i];
            var div = document.createElement('div');
            div.innerHTML = msg;
            results.appendChild(div);
        }
        document.body.appendChild(results);
        Coveo.CNL.Web.Scripts.Ajax.Profiler._s_CloseLink = closeLink;
        Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results = results;
        Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Current = null;
    },
    
    _logInternal: function Coveo_CNL_Web_Scripts_Ajax_Profiler$_logInternal(p_Message) {
        /// <summary>
        /// Logs an event.
        /// </summary>
        /// <param name="p_Message" type="String">
        /// The message of the event to log.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Message);
        var delta = new Date().getTime() - this._m_Start.getTime();
        ArrayPrototype_add(this._m_Messages, '+' + delta.toString() + ' - ' + p_Message);
    },
    
    _onCloseResults: function Coveo_CNL_Web_Scripts_Ajax_Profiler$_onCloseResults() {
        /// <summary>
        /// Closes the results panel
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results);
        Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results.style.display = 'none';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.PercentTimer

Coveo.CNL.Web.Scripts.Ajax.PercentTimer = function Coveo_CNL_Web_Scripts_Ajax_PercentTimer(p_Duration, p_EasingFunction) {
    /// <summary>
    /// Allows computing the percentage of a process that must last a specific amount of time.
    /// </summary>
    /// <param name="p_Duration" type="Number" integer="true">
    /// The duration of the process (in milliseconds).
    /// </param>
    /// <param name="p_EasingFunction" type="Coveo.CNL.Web.Scripts.Ajax.EasingFunction">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.EasingFunction" /> to use.
    /// </param>
    /// <field name="_m_Duration" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Start" type="Date">
    /// </field>
    /// <field name="_m_Started" type="Boolean">
    /// </field>
    /// <field name="_m_EasingFunction" type="Coveo.CNL.Web.Scripts.Ajax.EasingFunction">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Duration > 0);
    this._m_Duration = p_Duration;
    this._m_EasingFunction = p_EasingFunction;
}
Coveo.CNL.Web.Scripts.Ajax.PercentTimer.prototype = {
    _m_Duration: 0,
    _m_Start: null,
    _m_Started: false,
    _m_EasingFunction: 0,
    
    ensureStarted: function Coveo_CNL_Web_Scripts_Ajax_PercentTimer$ensureStarted() {
        /// <summary>
        /// Ensures that the timer is started.
        /// </summary>
        if (!this._m_Started) {
            this._m_Start = new Date();
            this._m_Started = true;
        }
    },
    
    getElapsedTime: function Coveo_CNL_Web_Scripts_Ajax_PercentTimer$getElapsedTime() {
        /// <summary>
        /// Retrieves the amount of time that has elapsed.
        /// </summary>
        /// <returns type="Number" integer="true"></returns>
        return new Date().getTime() - this._m_Start.getTime();
    },
    
    getPercentage: function Coveo_CNL_Web_Scripts_Ajax_PercentTimer$getPercentage() {
        /// <summary>
        /// Computes the current percentage.
        /// </summary>
        /// <returns type="Number"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_Started);
        var percent;
        var delta = this.getElapsedTime();
        if (delta <= 0) {
            percent = 0;
        }
        else if (delta < this._m_Duration) {
            percent = delta / this._m_Duration;
            Coveo.CNL.Web.Scripts.CNLAssert.check(percent !== 0);
            switch (this._m_EasingFunction) {
                case Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat:
                    break;
                case Coveo.CNL.Web.Scripts.Ajax.EasingFunction.fastSlow:
                    percent = Math.sin(Math.PI * Math.sin(Math.PI * percent / 2) / 2);
                    break;
                case Coveo.CNL.Web.Scripts.Ajax.EasingFunction.slowFast:
                    percent = Math.cos(Math.PI * Math.cos(Math.PI * percent / 2) / 2);
                    break;
                case Coveo.CNL.Web.Scripts.Ajax.EasingFunction.slowFastSlow:
                    percent = 1 - Math.cos(Math.PI * Math.sin(Math.PI * percent / 2) / 2);
                    break;
                default:
                    Coveo.CNL.Web.Scripts.CNLAssert.fail();
                    break;
            }
        }
        else {
            percent = 1;
        }
        return percent;
    },
    
    isFinished: function Coveo_CNL_Web_Scripts_Ajax_PercentTimer$isFinished() {
        /// <summary>
        /// Checks if the process should be finished.
        /// </summary>
        /// <returns type="Boolean"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_Started);
        return this.getElapsedTime() >= this._m_Duration;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger

Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger = function Coveo_CNL_Web_Scripts_Ajax_UpdateDebugger(p_Flipper, p_Info) {
    /// <summary>
    /// Pseudo transition effect that displays why a control or region is being updated.
    /// </summary>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <param name="p_Info" type="String">
    /// The information to display on the content.
    /// </param>
    /// <field name="_displaY_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Info$2" type="String">
    /// </field>
    /// <field name="_m_Overlay$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Info);
    this._m_Flipper$2 = p_Flipper;
    this._m_Info$2 = p_Info;
}
Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger.prototype = {
    _m_Flipper$2: null,
    _m_Info$2: null,
    _m_Overlay$2: null,
    _m_Timeout$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_UpdateDebugger$beginTransition() {
        var elem = this._m_Flipper$2.flip();
        this._m_Overlay$2 = document.createElement('div');
        this._m_Overlay$2.style.position = 'absolute';
        this._m_Overlay$2.style.zIndex = 999;
        this._m_Overlay$2.style.border = '2px solid red';
        this._m_Overlay$2.style.padding = '5px';
        document.body.appendChild(this._m_Overlay$2);
        Coveo.CNL.Web.Scripts.DOMUtilities.setElementBounds(this._m_Overlay$2, Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(elem));
        var info = document.createElement('span');
        info.style.fontFamily = 'verdana';
        info.style.fontWeight = 'bold';
        info.style.fontSize = '8pt';
        info.style.color = 'white';
        info.style.backgroundColor = 'black';
        info.innerText = this._m_Info$2;
        this._m_Overlay$2.appendChild(info);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger._displaY_DELAY$2);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_UpdateDebugger$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Overlay$2.parentNode.removeChild(this._m_Overlay$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_UpdateDebugger$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Timeout$2 = null;
        this.terminate();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition

Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition = function Coveo_CNL_Web_Scripts_Ajax_FlipFadeTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that flips in the new content and gradually fades it in.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we flip.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Overlay$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_Overlay$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_FlipFadeTransition$beginTransition() {
        if (!Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Flipper$2.get_newContent(), 0);
        }
        this._m_Element$2 = this._m_Flipper$2.flip();
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            this._m_Overlay$2 = document.createElement('div');
            this._m_Overlay$2.style.backgroundColor = 'white';
            this._m_Overlay$2.style.position = 'absolute';
            this._m_Overlay$2.style.zIndex = 999;
            document.body.appendChild(this._m_Overlay$2);
            Coveo.CNL.Web.Scripts.DOMUtilities.setElementBounds(this._m_Overlay$2, Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(this._m_Element$2));
        }
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(100, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_FlipFadeTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            document.body.removeChild(this._m_Overlay$2);
        }
        else {
            this._m_Element$2.style.opacity = '';
        }
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_FlipFadeTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Overlay$2, 1 - this._m_Percent$2.getPercentage());
        }
        else {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, this._m_Percent$2.getPercentage());
        }
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.IdMappings

Coveo.CNL.Web.Scripts.Ajax.IdMappings = function Coveo_CNL_Web_Scripts_Ajax_IdMappings() {
    /// <summary>
    /// Implements a dictionary of mappings from a control id (and it's childs) to an object.
    /// </summary>
    /// <field name="_m_Mappings" type="Object">
    /// </field>
    this._m_Mappings = {};
}
Coveo.CNL.Web.Scripts.Ajax.IdMappings.prototype = {
    
    add: function Coveo_CNL_Web_Scripts_Ajax_IdMappings$add(p_Id, p_Value) {
        /// <summary>
        /// Adds a mapping to the list.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id for the mapping.
        /// </param>
        /// <param name="p_Value" type="Object">
        /// The object to which it is mapped.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
        this._m_Mappings[p_Id] = p_Value;
    },
    
    remove: function Coveo_CNL_Web_Scripts_Ajax_IdMappings$remove(p_Id) {
        /// <summary>
        /// Remvoes a mapping from the list.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id for the mapping.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
        delete this._m_Mappings[p_Id];
    },
    
    get: function Coveo_CNL_Web_Scripts_Ajax_IdMappings$get(p_Id) {
        /// <summary>
        /// Gets the mapped value for an id.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id for which to retrieve the mapped value.
        /// </param>
        /// <returns type="Object"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
        var value = null;
        var matched = null;
        var $dict1 = this._m_Mappings;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if ((matched == null || entry.key.length > matched.length) && p_Id.startsWith(entry.key)) {
                value = entry.value;
            }
        }
        return value;
    },
    
    clear: function Coveo_CNL_Web_Scripts_Ajax_IdMappings$clear() {
        /// <summary>
        /// Clears the mappings.
        /// </summary>
        this._m_Mappings = {};
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.Feedback

Coveo.CNL.Web.Scripts.Ajax.Feedback = function Coveo_CNL_Web_Scripts_Ajax_Feedback() {
    /// <summary>
    /// Base class for all feedbacks.
    /// </summary>
    /// <field name="_initiaL_DELAY$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Timeout$1" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.Feedback.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.Feedback.create = function Coveo_CNL_Web_Scripts_Ajax_Feedback$create(p_Id, p_Type, p_Target, p_Fullscreen, p_Text, p_Image) {
    /// <summary>
    /// Creates a <see cref="T:Coveo.CNL.Web.Scripts.Ajax.Feedback" /> object.
    /// </summary>
    /// <param name="p_Id" type="String">
    /// The id of the element.
    /// </param>
    /// <param name="p_Type" type="String">
    /// The type of the feedback.
    /// </param>
    /// <param name="p_Target" type="String">
    /// The target control of the feedback.
    /// </param>
    /// <param name="p_Fullscreen" type="Boolean">
    /// Whether to display the feedback in fullscreen mode.
    /// </param>
    /// <param name="p_Text" type="String">
    /// The optional text to display.
    /// </param>
    /// <param name="p_Image" type="String">
    /// The optional uri of the image to use.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.Ajax.Feedback"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Type);
    var feedback;
    switch (p_Type) {
        case 'Blank':
            Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Image);
            feedback = new Coveo.CNL.Web.Scripts.Ajax.BlankFeedback(document.getElementById(p_Id), p_Fullscreen, p_Image);
            break;
        case 'Processing':
            Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
            Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Text);
            feedback = new Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack(document.getElementById(p_Target), p_Text);
            break;
        default:
            Coveo.CNL.Web.Scripts.CNLAssert.fail();
            Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Image);
            feedback = new Coveo.CNL.Web.Scripts.Ajax.BlankFeedback(document.getElementById(p_Id), p_Fullscreen, p_Image);
            break;
    }
    return feedback;
}
Coveo.CNL.Web.Scripts.Ajax.Feedback.prototype = {
    _m_Timeout$1: null,
    
    beginProcess: function Coveo_CNL_Web_Scripts_Ajax_Feedback$beginProcess() {
        this._m_Timeout$1 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$1), Coveo.CNL.Web.Scripts.Ajax.Feedback._initiaL_DELAY$1);
    },
    
    endProcess: function Coveo_CNL_Web_Scripts_Ajax_Feedback$endProcess() {
        if (this._m_Timeout$1 != null) {
            this._m_Timeout$1.cancel();
            this._m_Timeout$1 = null;
        }
        else {
            this.endFeedback();
        }
    },
    
    _timerCallback$1: function Coveo_CNL_Web_Scripts_Ajax_Feedback$_timerCallback$1() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Timeout$1 = null;
        this.beginFeedback();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.FadeInTransition

Coveo.CNL.Web.Scripts.Ajax.FadeInTransition = function Coveo_CNL_Web_Scripts_Ajax_FadeInTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that fades in the new content.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we flip.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.FadeInTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.FadeInTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_FadeInTransition$beginTransition() {
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(650, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_FadeInTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, 1);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_FadeInTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        if (!this._m_Percent$2.isFinished()) {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, this._m_Percent$2.getPercentage());
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.FadeInTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.TransitionEffect

Coveo.CNL.Web.Scripts.Ajax.TransitionEffect = function Coveo_CNL_Web_Scripts_Ajax_TransitionEffect() {
    /// <summary>
    /// Base class for all transition effects.
    /// </summary>
    Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.create = function Coveo_CNL_Web_Scripts_Ajax_TransitionEffect$create(p_Content, p_Flipper, p_Effect) {
    /// <summary>
    /// Creates a <see cref="T:Coveo.CNL.Web.Scripts.Ajax.TransitionEffect" /> object.
    /// </summary>
    /// <param name="p_Content" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> object to flip.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> object to that performs the flip.
    /// </param>
    /// <param name="p_Effect" type="String">
    /// The name of the effect to create.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.Ajax.TransitionEffect"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Content);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Effect);
    var effect;
    switch (p_Effect) {
        case 'None':
            effect = new Coveo.CNL.Web.Scripts.Ajax.FlipTransition(p_Flipper);
            break;
        case 'Expand':
            effect = new Coveo.CNL.Web.Scripts.Ajax.ExpandTransition(p_Flipper);
            break;
        case 'HExpand':
            effect = new Coveo.CNL.Web.Scripts.Ajax.HExpandTransition(p_Flipper);
            break;
        case 'Collapse':
            effect = new Coveo.CNL.Web.Scripts.Ajax.CollapseTransition(p_Content, p_Flipper);
            break;
        case 'HCollapse':
            effect = new Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition(p_Content, p_Flipper);
            break;
        case 'Adjust':
            effect = new Coveo.CNL.Web.Scripts.Ajax.AdjustTransition(p_Content, p_Flipper);
            break;
        case 'HAdjust':
            effect = new Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition(p_Content, p_Flipper);
            break;
        case 'FadeIn':
            effect = new Coveo.CNL.Web.Scripts.Ajax.FadeInTransition(p_Content, p_Flipper);
            break;
        case 'FadeFlip':
            effect = new Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition(p_Content, p_Flipper);
            break;
        case 'FlipFade':
            effect = new Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition(p_Content, p_Flipper);
            break;
        default:
            Coveo.CNL.Web.Scripts.CNLAssert.fail();
            effect = new Coveo.CNL.Web.Scripts.Ajax.FlipTransition(p_Flipper);
            break;
    }
    return effect;
}
Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.prototype = {
    
    beginProcess: function Coveo_CNL_Web_Scripts_Ajax_TransitionEffect$beginProcess() {
        this.beginTransition();
    },
    
    endProcess: function Coveo_CNL_Web_Scripts_Ajax_TransitionEffect$endProcess() {
        this.endTransition();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect

Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect = function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect(p_Element) {
    /// <summary>
    /// Effect that gradually fades in an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we fade in.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Duration$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_TargetOpacity$2" type="Number">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    this._m_Element$2 = p_Element;
}
Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect.prototype = {
    _m_Element$2: null,
    _m_Duration$2: 200,
    _m_TargetOpacity$2: 1,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    get_duration: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$get_duration() {
        /// <summary>
        /// The duration of the effect in milliseconds.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return this._m_Duration$2;
    },
    set_duration: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$set_duration(value) {
        /// <summary>
        /// The duration of the effect in milliseconds.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        this._m_Duration$2 = value;
        return value;
    },
    
    get_targetOpacity: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$get_targetOpacity() {
        /// <summary>
        /// The target opacity of the element.
        /// </summary>
        /// <value type="Number"></value>
        return this._m_TargetOpacity$2;
    },
    set_targetOpacity: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$set_targetOpacity(value) {
        /// <summary>
        /// The target opacity of the element.
        /// </summary>
        /// <value type="Number"></value>
        this._m_TargetOpacity$2 = value;
        return value;
    },
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$beginTransition() {
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(this._m_Duration$2, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, this._m_TargetOpacity$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_GradualFadeInEffect$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, this._m_Percent$2.getPercentage() * this._m_TargetOpacity$2);
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper

Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper = function Coveo_CNL_Web_Scripts_Ajax_ScriptLoaderWrapper() {
    /// <summary>
    /// Wraps a <see cref="T:Coveo.CNL.Web.Scripts.ScriptLoader" /> object to make it an <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess" />.
    /// </summary>
    /// <field name="_m_Uris$1" type="Array">
    /// </field>
    /// <field name="_m_Loader$1" type="Coveo.CNL.Web.Scripts.ScriptLoader">
    /// </field>
    this._m_Uris$1 = [];
    Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper.prototype = {
    _m_Loader$1: null,
    
    add: function Coveo_CNL_Web_Scripts_Ajax_ScriptLoaderWrapper$add(p_Uri) {
        /// <summary>
        /// Adds the uri of a script to load.
        /// </summary>
        /// <param name="p_Uri" type="String">
        /// The uri of the script to load.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
        ArrayPrototype_add(this._m_Uris$1, p_Uri);
    },
    
    beginProcess: function Coveo_CNL_Web_Scripts_Ajax_ScriptLoaderWrapper$beginProcess() {
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_Loader$1);
        var uris = new Array(this._m_Uris$1.length);
        for (var i = 0; i < this._m_Uris$1.length; ++i) {
            uris[i] = this._m_Uris$1[i];
        }
        this._m_Loader$1 = new Coveo.CNL.Web.Scripts.ScriptLoader(uris);
        this._m_Loader$1.load(false, 0, ss.Delegate.create(this, this._scriptsLoadedCallback$1), ss.Delegate.create(this, this._scriptsLoadedCallback$1));
    },
    
    endProcess: function Coveo_CNL_Web_Scripts_Ajax_ScriptLoaderWrapper$endProcess() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_Loader$1);
        this._m_Loader$1.dispose();
        this._m_Loader$1 = null;
    },
    
    _scriptsLoadedCallback$1: function Coveo_CNL_Web_Scripts_Ajax_ScriptLoaderWrapper$_scriptsLoadedCallback$1() {
        /// <summary>
        /// Callback for when all scripts are loaded.
        /// </summary>
        this.terminate();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.ModalBox

Coveo.CNL.Web.Scripts.Ajax.ModalBox = function Coveo_CNL_Web_Scripts_Ajax_ModalBox(p_Manager, p_Id, p_Content, p_Width, p_Height, p_HorizontalMargin, p_VerticalMargin, p_EnableOutsideClick) {
    /// <summary>
    /// Encapsulates modal dialog box displayed on the page.
    /// </summary>
    /// <param name="p_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" /> object.
    /// </param>
    /// <param name="p_Id" type="String">
    /// The unique identifier of the modal box.
    /// </param>
    /// <param name="p_Content" type="String">
    /// The html content of the box.
    /// </param>
    /// <param name="p_Width" type="Number" integer="true">
    /// The width of the box.
    /// </param>
    /// <param name="p_Height" type="Number" integer="true">
    /// The height of the box.
    /// </param>
    /// <param name="p_HorizontalMargin" type="Number" integer="true">
    /// The horizontal margin from the border of the window.
    /// </param>
    /// <param name="p_VerticalMargin" type="Number" integer="true">
    /// The vertical margin from the border of the window.
    /// </param>
    /// <param name="p_EnableOutsideClick" type="Boolean">
    /// Whether the OutsideClick event should be fiered.
    /// </param>
    /// <field name="_m_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// </field>
    /// <field name="_m_Id" type="String">
    /// </field>
    /// <field name="_m_Content" type="String">
    /// </field>
    /// <field name="_m_Width" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Height" type="Number" integer="true">
    /// </field>
    /// <field name="_m_HorizontalMargin" type="Number" integer="true">
    /// </field>
    /// <field name="_m_VerticalMargin" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Dimmer" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Container" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Frame" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_InitialOverflow" type="String">
    /// </field>
    /// <field name="_m_EnableOutsideClick" type="Boolean">
    /// </field>
    /// <field name="_m_IFrame" type="Object" domElement="true">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Manager);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Content);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Width !== 0 || (p_HorizontalMargin + p_VerticalMargin) !== 0);
    Coveo.CNL.Web.Scripts.CNLAssert.check(!(p_Height !== 0 && (p_HorizontalMargin + p_VerticalMargin) !== 0));
    this._m_Manager = p_Manager;
    this._m_Id = p_Id;
    this._m_Content = p_Content;
    this._m_Width = p_Width;
    this._m_Height = p_Height;
    this._m_HorizontalMargin = p_HorizontalMargin;
    this._m_VerticalMargin = p_VerticalMargin;
    this._m_EnableOutsideClick = p_EnableOutsideClick;
}
Coveo.CNL.Web.Scripts.Ajax.ModalBox.prototype = {
    _m_Manager: null,
    _m_Id: null,
    _m_Content: null,
    _m_Width: 0,
    _m_Height: 0,
    _m_HorizontalMargin: 0,
    _m_VerticalMargin: 0,
    _m_Dimmer: null,
    _m_Container: null,
    _m_Frame: null,
    _m_InitialOverflow: null,
    _m_EnableOutsideClick: false,
    _m_IFrame: null,
    
    get_id: function Coveo_CNL_Web_Scripts_Ajax_ModalBox$get_id() {
        /// <summary>
        /// The unique identifier for the modal box.
        /// </summary>
        /// <value type="String"></value>
        return this._m_Id;
    },
    
    get_visible: function Coveo_CNL_Web_Scripts_Ajax_ModalBox$get_visible() {
        /// <summary>
        /// This property is true when the box is visible.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_Frame != null;
    },
    
    show: function Coveo_CNL_Web_Scripts_Ajax_ModalBox$show() {
        /// <summary>
        /// Shows the modal box.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.check(!this.get_visible());
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) {
            var scroll = Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount();
            this._m_InitialOverflow = document.documentElement.style.overflow;
            document.documentElement.style.overflow = 'hidden';
            document.documentElement.scrollLeft = scroll.width;
            document.documentElement.scrollTop = scroll.height;
        }
        else {
            var scroll = Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount();
            this._m_InitialOverflow = document.body.style.overflow;
            document.body.style.overflow = 'hidden';
            document.body.scrollLeft = scroll.width;
            document.body.scrollTop = scroll.height;
        }
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE6()) {
            this._m_IFrame = document.createElement('iframe');
            this._m_IFrame.getAttributeNode('src').value = 'javascript:false;';
            this._m_IFrame.getAttributeNode('scrolling').value = 'no';
            this._m_IFrame.style.position = 'absolute';
            this._m_IFrame.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
            this._m_IFrame.style.display = 'none';
            this._m_IFrame.style.border = '0';
            this._m_IFrame.style.display = 'block';
            this._m_IFrame.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';
            Coveo.CNL.Web.Scripts.DOMUtilities.coverAllWindow(this._m_IFrame);
            document.body.appendChild(this._m_IFrame);
        }
        this._m_Dimmer = document.createElement('div');
        Coveo.CNL.Web.Scripts.DOMUtilities.coverAllWindow(this._m_Dimmer);
        this._m_Dimmer.style.backgroundColor = 'silver';
        this._m_Dimmer.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
        Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Dimmer, 0.5);
        document.body.appendChild(this._m_Dimmer);
        this._m_Container = document.createElement('div');
        Coveo.CNL.Web.Scripts.DOMUtilities.coverAllWindow(this._m_Container);
        this._m_Container.style.zIndex = (Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex() + 1);
        this._m_Manager.get_form().appendChild(this._m_Container);
        var table = document.createElement('table');
        table.style.width = '100%';
        table.style.height = '100%';
        var row = table.insertRow(0);
        var cell = row.insertCell(0);
        cell.align = 'center';
        this._m_Container.appendChild(table);
        if (this._m_EnableOutsideClick) {
            this._m_Container.attachEvent('onclick', ss.Delegate.create(this, this._container_Click));
            this._m_Container.style.cursor = 'pointer';
        }
        this._m_Frame = document.createElement('div');
        if (this._m_Width !== 0) {
            this._m_Frame.style.width = this._m_Width + 'px';
            if (this._m_Height !== 0) {
                this._m_Frame.style.height = this._m_Height + 'px';
            }
        }
        else {
            var size = Coveo.CNL.Web.Scripts.DOMUtilities.getWindowSize();
            this._m_Frame.style.width = (size.width - this._m_HorizontalMargin * 2) + 'px';
            this._m_Frame.style.height = (size.height - this._m_VerticalMargin * 2) + 'px';
        }
        this._m_Frame.style.textAlign = 'left';
        this._m_Frame.style.cursor = 'auto';
        cell.appendChild(this._m_Frame);
        this._m_Frame.innerHTML = this._m_Content;
    },
    
    close: function Coveo_CNL_Web_Scripts_Ajax_ModalBox$close() {
        /// <summary>
        /// Closes the modal box.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.check(this.get_visible());
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_Dimmer);
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE6()) {
            Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_IFrame);
            this._m_IFrame.parentNode.removeChild(this._m_IFrame);
            this._m_IFrame = null;
        }
        $(this._m_Dimmer).fadeOut(300, ss.Delegate.create(this, function() {
            this._m_Dimmer.parentNode.removeChild(this._m_Dimmer);
            this._m_Dimmer = null;
        }));
        if (this._m_Container != null) {
            this._m_Container.parentNode.removeChild(this._m_Container);
            this._m_Container = null;
            this._m_Frame = null;
        }
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) {
            document.documentElement.style.overflow = this._m_InitialOverflow;
        }
        else {
            document.body.style.overflow = this._m_InitialOverflow;
        }
        Coveo.CNL.Web.Scripts.CNLAssert.check(!this.get_visible());
    },
    
    _container_Click: function Coveo_CNL_Web_Scripts_Ajax_ModalBox$_container_Click() {
        if (!this._m_Frame.contains(window.event.srcElement)) {
            this._m_Manager.DPB(this._m_Id, '', false, false);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.FlipTransition

Coveo.CNL.Web.Scripts.Ajax.FlipTransition = function Coveo_CNL_Web_Scripts_Ajax_FlipTransition(p_Flipper) {
    /// <summary>
    /// Transition effect that only flips the content.
    /// </summary>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.FlipTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.FlipTransition.prototype = {
    _m_Flipper$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_FlipTransition$beginTransition() {
        this._m_Flipper$2.flip();
        this.terminate();
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_FlipTransition$endTransition() {
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager

Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager = function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcessManager() {
    /// <summary>
    /// Runs a list of asynchronous processes, and provides a notification when they are done.
    /// </summary>
    /// <field name="_m_Processes" type="Array">
    /// </field>
    /// <field name="_m_Callback" type="EventHandler">
    /// </field>
    this._m_Processes = [];
}
Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager.prototype = {
    _m_Callback: null,
    
    add: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcessManager$add(p_Process) {
        /// <summary>
        /// Adds a process to the list.
        /// </summary>
        /// <param name="p_Process" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess">
        /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess" /> to add.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Process);
        p_Process.set_manager(this);
        ArrayPrototype_add(this._m_Processes, p_Process);
    },
    
    startAll: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcessManager$startAll(p_Callback) {
        /// <summary>
        /// Starts running the asynchronous processes.
        /// </summary>
        /// <param name="p_Callback" type="EventHandler">
        /// Callback function to call when done.
        /// </param>
        this._m_Callback = p_Callback;
        if (this._m_Processes.length > 0) {
            var processes = ArrayPrototype_clone(this._m_Processes);
            for (var i = 0; i < processes.length; i++) {
                var process = processes[i];
                process.start();
            }
        }
        else {
            if (this._m_Callback != null) {
                this._m_Callback.invoke(this, new ss.EventArgs());
            }
        }
    },
    
    terminateAll: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcessManager$terminateAll() {
        /// <summary>
        /// Stops all the processes.
        /// </summary>
        var processes = ArrayPrototype_clone(this._m_Processes);
        for (var i = 0; i < processes.length; i++) {
            var process = processes[i];
            process.terminate();
        }
        Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_Processes.length === 0);
    },
    
    processIsDone: function Coveo_CNL_Web_Scripts_Ajax_AsynchronousProcessManager$processIsDone(p_Process) {
        /// <summary>
        /// Called whenever a process finishes.
        /// </summary>
        /// <param name="p_Process" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess">
        /// The process that signals it is done.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Process);
        Coveo.CNL.Web.Scripts.CNLAssert.check(ArrayPrototype_contains(this._m_Processes, p_Process));
        ArrayPrototype_remove(this._m_Processes, p_Process);
        if (this._m_Processes.length === 0 && this._m_Callback != null) {
            this._m_Callback.invoke(this, new ss.EventArgs());
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition

Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition = function Coveo_CNL_Web_Scripts_Ajax_FadeFlipTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that fades out the old content and then flips in the new one.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we flip.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Overlay$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_Overlay$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_FadeFlipTransition$beginTransition() {
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            this._m_Overlay$2 = document.createElement('div');
            this._m_Overlay$2.style.backgroundColor = 'white';
            this._m_Overlay$2.style.position = 'absolute';
            this._m_Overlay$2.style.zIndex = 999;
            document.body.appendChild(this._m_Overlay$2);
            Coveo.CNL.Web.Scripts.DOMUtilities.setElementBounds(this._m_Overlay$2, Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(this._m_Element$2));
        }
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(150, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_FadeFlipTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            this._m_Element$2 = this._m_Flipper$2.flip();
            document.body.removeChild(this._m_Overlay$2);
        }
        else {
            this._m_Element$2 = this._m_Flipper$2.flip();
            this._m_Element$2.style.opacity = '';
        }
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_FadeFlipTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Overlay$2, this._m_Percent$2.getPercentage());
        }
        else {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Element$2, 1 - this._m_Percent$2.getPercentage());
        }
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition

Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition = function Coveo_CNL_Web_Scripts_Ajax_HAdjustTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that gradually adjusts the size of an element horizontally.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we adjust.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_InitialWidth$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Offset$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_InitialWidth$2: 0,
    _m_Offset$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_HAdjustTransition$beginTransition() {
        this._m_InitialWidth$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).width;
        this._m_Element$2 = this._m_Flipper$2.flip();
        this._m_Offset$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).width - this._m_InitialWidth$2;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.width = this._m_InitialWidth$2 + 'px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_HAdjustTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Element$2, this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_HAdjustTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.width = ((this._m_InitialWidth$2 + this._m_Offset$2 * Math.sin(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition

Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition = function Coveo_CNL_Web_Scripts_Ajax_HCollapseTransition(p_Element, p_Flipper) {
    /// <summary>
    /// Transition effect that collapses a tag horizontally from it's normal size to nothing.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> that we collapse.
    /// </param>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_InitialWidth$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Element$2 = p_Element;
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_InitialWidth$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_HCollapseTransition$beginTransition() {
        this._m_InitialWidth$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).width;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.width = this._m_InitialWidth$2 + 'px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_HCollapseTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Flipper$2.flip(), this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_HCollapseTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.width = ((this._m_InitialWidth$2 * Math.cos(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.HExpandTransition

Coveo.CNL.Web.Scripts.Ajax.HExpandTransition = function Coveo_CNL_Web_Scripts_Ajax_HExpandTransition(p_Flipper) {
    /// <summary>
    /// Transition effect that expands a tag horizontally from nothing to it's normal size.
    /// </summary>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_TargetWidth$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.HExpandTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.HExpandTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_TargetWidth$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_HExpandTransition$beginTransition() {
        this._m_Element$2 = this._m_Flipper$2.flip();
        this._m_TargetWidth$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).width;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.width = '0px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_HExpandTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Element$2, this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_HExpandTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.width = ((this._m_TargetWidth$2 * Math.sin(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.HExpandTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.ExpandTransition

Coveo.CNL.Web.Scripts.Ajax.ExpandTransition = function Coveo_CNL_Web_Scripts_Ajax_ExpandTransition(p_Flipper) {
    /// <summary>
    /// Transition effect that expands a tag from nothing to it's normal size.
    /// </summary>
    /// <param name="p_Flipper" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> that flips the content.
    /// </param>
    /// <field name="_framE_DELAY$2" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_Flipper$2" type="Coveo.CNL.Web.Scripts.Ajax.IContentFlipper">
    /// </field>
    /// <field name="_m_Element$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_TargetHeight$2" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Margins$2" type="Coveo.CNL.Web.Scripts.TransferMargin">
    /// </field>
    /// <field name="_m_Container$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Timeout$2" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_Percent$2" type="Coveo.CNL.Web.Scripts.Ajax.PercentTimer">
    /// </field>
    Coveo.CNL.Web.Scripts.Ajax.ExpandTransition.initializeBase(this);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Flipper);
    this._m_Flipper$2 = p_Flipper;
}
Coveo.CNL.Web.Scripts.Ajax.ExpandTransition.prototype = {
    _m_Flipper$2: null,
    _m_Element$2: null,
    _m_TargetHeight$2: 0,
    _m_Margins$2: null,
    _m_Container$2: null,
    _m_Timeout$2: null,
    _m_Percent$2: null,
    
    beginTransition: function Coveo_CNL_Web_Scripts_Ajax_ExpandTransition$beginTransition() {
        this._m_Element$2 = this._m_Flipper$2.flip();
        this._m_Element$2.style.display = 'block';
        this._m_TargetHeight$2 = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Element$2).height;
        this._m_Container$2 = document.createElement('div');
        this._m_Container$2.style.overflow = 'hidden';
        this._m_Container$2.style.height = '0px';
        this._m_Margins$2 = new Coveo.CNL.Web.Scripts.TransferMargin(this._m_Element$2, this._m_Container$2);
        this._m_Element$2.parentNode.replaceChild(this._m_Container$2, this._m_Element$2);
        this._m_Container$2.appendChild(this._m_Element$2);
        this._m_Percent$2 = new Coveo.CNL.Web.Scripts.Ajax.PercentTimer(300, Coveo.CNL.Web.Scripts.Ajax.EasingFunction.flat);
        this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), 0);
    },
    
    endTransition: function Coveo_CNL_Web_Scripts_Ajax_ExpandTransition$endTransition() {
        if (this._m_Timeout$2 != null) {
            this._m_Timeout$2.cancel();
            this._m_Timeout$2 = null;
        }
        this._m_Margins$2.restore();
        this._m_Container$2.parentNode.replaceChild(this._m_Element$2, this._m_Container$2);
    },
    
    _timerCallback$2: function Coveo_CNL_Web_Scripts_Ajax_ExpandTransition$_timerCallback$2() {
        /// <summary>
        /// Callback for the timer we use.
        /// </summary>
        this._m_Percent$2.ensureStarted();
        this._m_Container$2.style.height = ((this._m_TargetHeight$2 * Math.sin(Math.PI * this._m_Percent$2.getPercentage() / 2))).toString() + 'px';
        if (!this._m_Percent$2.isFinished()) {
            this._m_Timeout$2 = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._timerCallback$2), Coveo.CNL.Web.Scripts.Ajax.ExpandTransition._framE_DELAY$2);
        }
        else {
            this.terminate();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.RegionFlipper

Coveo.CNL.Web.Scripts.Ajax.RegionFlipper = function Coveo_CNL_Web_Scripts_Ajax_RegionFlipper(p_Region, p_Content) {
    /// <summary>
    /// Implementation of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.IContentFlipper" /> for flipping regions.
    /// </summary>
    /// <param name="p_Region" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> of the region to flip.
    /// </param>
    /// <param name="p_Content" type="String">
    /// The new content of the region.
    /// </param>
    /// <field name="_m_Region" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Content" type="String">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Region);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Content);
    this._m_Region = p_Region;
    this._m_Content = p_Content;
}
Coveo.CNL.Web.Scripts.Ajax.RegionFlipper.prototype = {
    _m_Region: null,
    _m_Content: null,
    
    get_newContent: function Coveo_CNL_Web_Scripts_Ajax_RegionFlipper$get_newContent() {
        /// <value type="Object" domElement="true"></value>
        return this._m_Region;
    },
    
    flip: function Coveo_CNL_Web_Scripts_Ajax_RegionFlipper$flip() {
        /// <returns type="Object" domElement="true"></returns>
        this._m_Region.innerHTML = this._m_Content;
        return this._m_Region;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.PartialPostBack

Coveo.CNL.Web.Scripts.Ajax.PartialPostBack = function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack(p_Manager, p_Target, p_Argument, p_Feedbacks, p_Timer, p_Preemptive, p_NonCancelable) {
    /// <summary>
    /// Encapsulates a partial postback to the server.
    /// </summary>
    /// <param name="p_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" /> object.
    /// </param>
    /// <param name="p_Target" type="String">
    /// The id of the target control.
    /// </param>
    /// <param name="p_Argument" type="String">
    /// The postback arguments.
    /// </param>
    /// <param name="p_Feedbacks" type="Array">
    /// The feedbacks to display.
    /// </param>
    /// <param name="p_Timer" type="Boolean">
    /// Whether this is a timer postback.
    /// </param>
    /// <param name="p_Preemptive" type="Boolean">
    /// Whether this is a preemptive postback.
    /// </param>
    /// <param name="p_NonCancelable" type="Boolean">
    /// Whether this postback is non cancelable.
    /// </param>
    /// <field name="_m_Manager" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript">
    /// </field>
    /// <field name="_m_Target" type="String">
    /// </field>
    /// <field name="_m_Argument" type="String">
    /// </field>
    /// <field name="_m_Feedbacks" type="Array">
    /// </field>
    /// <field name="_m_Timer" type="Boolean">
    /// </field>
    /// <field name="_m_Preemptive" type="Boolean">
    /// </field>
    /// <field name="_m_NonCancelable" type="Boolean">
    /// </field>
    /// <field name="_m_SendControlData" type="Boolean">
    /// </field>
    /// <field name="_m_KeepQueryStringArguments" type="Boolean">
    /// </field>
    /// <field name="_m_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
    /// </field>
    /// <field name="_m_IgnoreResults" type="Boolean">
    /// </field>
    /// <field name="_m_EnableProgress" type="Boolean">
    /// </field>
    /// <field name="_m_UniqueID" type="String">
    /// </field>
    /// <field name="_m_Request" type="XMLHttpRequest">
    /// </field>
    /// <field name="_m_Response" type="XmlDocument">
    /// </field>
    /// <field name="_m_ReturnValue" type="Object">
    /// </field>
    /// <field name="_m_RequestCompleted" type="Boolean">
    /// </field>
    /// <field name="_m_Cancelling" type="Boolean">
    /// </field>
    /// <field name="_m_PreRequestProcesses" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager">
    /// </field>
    /// <field name="_m_PostRequestProcesses" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager">
    /// </field>
    /// <field name="_m_Profiler" type="Coveo.CNL.Web.Scripts.Ajax.Profiler">
    /// </field>
    /// <field name="partiaL_POSTBACK_MARKER" type="String" static="true">
    /// The name of the http header (or POST/GET value) sent to identify partial postbacks.
    /// </field>
    /// <field name="bootstraP_MARKER" type="String" static="true">
    /// The name of the http header (or POST/GET value) sent to identify postbacks made from a bootstraped interface.
    /// </field>
    /// <field name="historY_STATE_MARKER" type="String" static="true">
    /// The name of the http header (or POST/GET value) sent to identify history state value.
    /// </field>
    /// <field name="nO_CONTROL_DATA_MARKER" type="String" static="true">
    /// The name of the http header (or POST/GET value) sent to signal that the page control data hasn't been sent.
    /// </field>
    /// <field name="forM_EVENT_TARGET" type="String" static="true">
    /// The name of the hidden input holding the event target.
    /// </field>
    /// <field name="forM_EVENT_ARGUMENT" type="String" static="true">
    /// The name of the hidden input holding the event argument.
    /// </field>
    /// <field name="forM_VIEW_STATE" type="String" static="true">
    /// The name of the hidden input holding the viewstate.
    /// </field>
    /// <field name="forM_VIEW_STATE_ENCRYPTED" type="String" static="true">
    /// The name of the hidden input indicating that the viewstate is encrypted.
    /// </field>
    /// <field name="forM_REQUEST_DIGEST" type="String" static="true">
    /// The name of the hidden input holding the form request digest.
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Manager);
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Argument);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Feedbacks);
    this._m_Manager = p_Manager;
    this._m_Target = p_Target;
    this._m_Argument = p_Argument;
    this._m_Feedbacks = p_Feedbacks;
    this._m_Timer = p_Timer;
    this._m_Preemptive = p_Preemptive;
    this._m_NonCancelable = p_NonCancelable;
    this._m_UniqueID = (Math.random() * 1000000000).toString(16);
    if (this._m_Manager.get_enableProfiling()) {
        this._m_Profiler = new Coveo.CNL.Web.Scripts.Ajax.Profiler();
    }
}
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.prototype = {
    _m_Manager: null,
    _m_Target: null,
    _m_Argument: null,
    _m_Feedbacks: null,
    _m_Timer: false,
    _m_Preemptive: false,
    _m_NonCancelable: false,
    _m_SendControlData: true,
    _m_KeepQueryStringArguments: false,
    _m_Callback: null,
    _m_IgnoreResults: false,
    _m_EnableProgress: true,
    _m_UniqueID: null,
    _m_Request: null,
    _m_Response: null,
    _m_ReturnValue: null,
    _m_RequestCompleted: false,
    _m_Cancelling: false,
    _m_PreRequestProcesses: null,
    _m_PostRequestProcesses: null,
    _m_Profiler: null,
    
    get_sendControlData: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_sendControlData() {
        /// <summary>
        /// Whether to send the form's control data.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_SendControlData;
    },
    set_sendControlData: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$set_sendControlData(value) {
        /// <summary>
        /// Whether to send the form's control data.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_SendControlData = value;
        return value;
    },
    
    get_keepQueryStringArguments: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_keepQueryStringArguments() {
        /// <summary>
        /// Whether to keep query string arguments.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_KeepQueryStringArguments;
    },
    set_keepQueryStringArguments: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$set_keepQueryStringArguments(value) {
        /// <summary>
        /// Whether to keep query string arguments.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_KeepQueryStringArguments = value;
        return value;
    },
    
    get_callback: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_callback() {
        /// <summary>
        /// The callback for the postback.
        /// </summary>
        /// <value type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback"></value>
        return this._m_Callback;
    },
    set_callback: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$set_callback(value) {
        /// <summary>
        /// The callback for the postback.
        /// </summary>
        /// <value type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback"></value>
        this._m_Callback = value;
        return value;
    },
    
    get_ignoreResults: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_ignoreResults() {
        /// <summary>
        /// Whether to ignore the results of the postback.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_IgnoreResults;
    },
    set_ignoreResults: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$set_ignoreResults(value) {
        /// <summary>
        /// Whether to ignore the results of the postback.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_IgnoreResults = value;
        return value;
    },
    
    get_enableProgress: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_enableProgress() {
        /// <summary>
        /// Whether postback progress tracking is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_EnableProgress;
    },
    set_enableProgress: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$set_enableProgress(value) {
        /// <summary>
        /// Whether postback progress tracking is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_EnableProgress = value;
        return value;
    },
    
    get_uniqueID: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$get_uniqueID() {
        /// <summary>
        /// Gets the generated unique ID for the request.
        /// </summary>
        /// <value type="String"></value>
        return this._m_UniqueID;
    },
    
    execute: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$execute() {
        /// <summary>
        /// Starts the partial postback.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_Request);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Preparing request...');
        (this._m_Manager.get_form()[Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_TARGET]).value = this._m_Target;
        (this._m_Manager.get_form()[Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_ARGUMENT]).value = this._m_Argument;
        var postBackUrl = this._m_Manager.get_form().action;
        var hashPos = postBackUrl.indexOf('#');
        if (hashPos !== -1) {
            postBackUrl = postBackUrl.substring(0, hashPos);
        }
        if (this._m_KeepQueryStringArguments && !Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(window.location.search)) {
            if (postBackUrl.indexOf('?') === -1) {
                postBackUrl += '?';
            }
            else {
                postBackUrl += '&';
            }
            postBackUrl += window.location.search.substr(1);
        }
        this._m_Request = new XMLHttpRequest();
        this._m_Request.open('POST', postBackUrl, true);
        this._m_Request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        if (this._m_Manager.get_canAddHttpHeaders()) {
            this._m_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.partiaL_POSTBACK_MARKER, this._m_UniqueID);
            if (this._m_Manager.get_bootstrap()) {
                this._m_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.bootstraP_MARKER, '1');
            }
            if (!this._m_SendControlData) {
                this._m_Request.setRequestHeader(Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.nO_CONTROL_DATA_MARKER, '1');
            }
        }
        this._m_Request.onreadystatechange = ss.Delegate.create(this, this._requestCallback);
        this._m_Request.send(this._buildPostData());
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Request is sent.');
        this._m_PreRequestProcesses = new Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager();
        for (var i = 0; i < this._m_Feedbacks.length; i++) {
            var feedback = this._m_Feedbacks[i];
            this._m_PreRequestProcesses.add(feedback);
        }
        if (this._m_EnableProgress && this._m_Manager.get_enableProgress()) {
            this._m_PreRequestProcesses.add(new Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript(this._m_Manager, this));
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.setOperationPendingCursor();
        if (!this._m_IgnoreResults) {
            Coveo.CNL.Web.Scripts.DOMUtilities.incrementBusyCounter();
        }
        this._m_PreRequestProcesses.startAll(null);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Pre-request processes started.');
    },
    
    cancel: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$cancel() {
        /// <summary>
        /// Cancels the partial postback.
        /// </summary>
        /// <returns type="Boolean"></returns>
        var cancelled = true;
        if (!this._m_NonCancelable) {
            if (!this._m_RequestCompleted) {
                this._m_Cancelling = true;
                this._m_PreRequestProcesses.terminateAll();
                this._m_Request.abort();
                this._m_Request = null;
                Coveo.CNL.Web.Scripts.DOMUtilities.removeOperationPendingCursor();
                if (!this._m_IgnoreResults) {
                    Coveo.CNL.Web.Scripts.DOMUtilities.decrementBusyCounter();
                }
            }
            else {
                if (this._m_PostRequestProcesses != null) {
                    this._m_PostRequestProcesses.terminateAll();
                    this._m_PostRequestProcesses = null;
                }
            }
        }
        else {
            cancelled = false;
        }
        return cancelled;
    },
    
    applyPreemptivePostback: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$applyPreemptivePostback() {
        /// <summary>
        /// Causes a preemptive postback to apply it's result if the response has
        /// already been obtained, or to apply them right away when they are received.
        /// </summary>
        if (this._m_Response != null) {
            this._applyResults();
        }
        else {
            this._m_Preemptive = false;
        }
    },
    
    _buildPostData: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_buildPostData() {
        /// <summary>
        /// Builds the form data for the postback.
        /// </summary>
        /// <returns type="String"></returns>
        var data = '';
        var elements = this._m_Manager.getAllFormElements();
        for (var i = 0; i < elements.length; ++i) {
            var elem = elements[i];
            var name = elem.getAttribute('name');
            if (Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(name)) {
                continue;
            }
            if (!this._m_SendControlData && name !== Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_TARGET && name !== Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_ARGUMENT && name !== Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE && name !== Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE_ENCRYPTED && name !== Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_REQUEST_DIGEST && !this._m_Manager.shouldAlwaysBeSent(name)) {
                continue;
            }
            if (Coveo.CNL.Web.Scripts.Utilities.equals(elem.tagName, 'input', true)) {
                var value = null;
                var type = elem.getAttribute('type');
                if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(type)) {
                    switch (type) {
                        case 'checkbox':
                            if (elem.checked) {
                                value = 'on';
                            }
                            break;
                        case 'radio':
                            if (elem.checked) {
                                value = elem.getAttribute('value');
                            }
                            break;
                        case 'submit':
                        case 'button':
                            break;
                        default:
                            value = Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.getBackupValueIfAny(elem);
                            if (value == null) {
                                value = elem.value;
                            }
                            break;
                    }
                }
                if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(value)) {
                    data += '&' + name + '=' + encodeURIComponent(value);
                }
            }
            else if (Coveo.CNL.Web.Scripts.Utilities.equals(elem.tagName, 'select', true)) {
                var select = elem;
                for (var j = 0; j < select.options.length; ++j) {
                    var option = select.options[j];
                    if (option.selected) {
                        var value = (option.value != null) ? option.value : option.innerText;
                        data += '&' + name + '=' + encodeURIComponent(option.value);
                    }
                }
            }
            else if (Coveo.CNL.Web.Scripts.Utilities.equals(elem.tagName, 'textarea', true)) {
                var textArea = elem;
                data += '&' + name + '=' + encodeURIComponent(textArea.value);
            }
        }
        if (!this._m_Manager.get_canAddHttpHeaders() || this._m_Manager.get_newBootstrap()) {
            data += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.partiaL_POSTBACK_MARKER + '=' + encodeURIComponent(this._m_UniqueID);
        }
        if (!this._m_Manager.get_canAddHttpHeaders()) {
            if (this._m_Manager.get_bootstrap()) {
                data += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.bootstraP_MARKER + '=1';
            }
            if (!this._m_SendControlData) {
                data += '&' + Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.nO_CONTROL_DATA_MARKER + '=1';
            }
        }
        return data;
    },
    
    _requestCallback: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_requestCallback() {
        /// <summary>
        /// Callback for request events.
        /// </summary>
        if (!this._m_Cancelling && this._m_Request.readyState === 4) {
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Response has been received.');
            if (!this._m_IgnoreResults) {
                if (this._m_Request.status === 200) {
                    this._m_Response = this._m_Request.responseXML;
                    if (!this._m_Preemptive) {
                        this._applyResults();
                    }
                }
                else if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE() || this._m_Request.status !== 0) {
                    this._displayAjaxError();
                }
            }
            this._m_PreRequestProcesses.terminateAll();
            this._m_PreRequestProcesses = null;
            Coveo.CNL.Web.Scripts.DOMUtilities.removeOperationPendingCursor();
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Pre-request processes terminated.');
            this._m_Request = null;
            this._m_RequestCompleted = true;
        }
    },
    
    _displayAjaxError: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_displayAjaxError() {
        /// <summary>
        /// Displays an error returned by the server and disables the page completely.
        /// </summary>
        var display;
        var wellKnownError = '';
        var unknownError = '';
        var errorDetails = '';
        if (this._m_Request.status === 500) {
            unknownError = 'An unexpected error occurred';
            display = true;
            if (this._m_Request.responseText !== '') {
                errorDetails = this._m_Request.responseText;
            }
            else if (this._m_Request.statusText !== '') {
                errorDetails = 'HTTP ' + this._m_Request.status.toString() + ' ' + this._m_Request.statusText;
            }
            else {
                errorDetails = 'HTTP ' + this._m_Request.status.toString() + ' Unspecified error.';
            }
        }
        else {
            wellKnownError = 'The server is unavailable at the moment.<br/><br/>Reload the page for more information.';
            display = !this._m_Timer;
        }
        if (display) {
            var wellKnown = wellKnownError !== '';
            Coveo.CNL.Web.Scripts.DOMUtilities.scrollAllTheWayUp(null);
            document.body.style.overflow = 'hidden';
            document.documentElement.style.overflow = 'hidden';
            var fader = document.createElement('div');
            fader.style.backgroundColor = 'silver';
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(fader, 0.5);
            fader.style.position = 'absolute';
            fader.style.left = '0px';
            fader.style.top = '0px';
            fader.style.width = '100%';
            fader.style.height = '100%';
            fader.style.zIndex = 9999;
            document.body.appendChild(fader);
            var panel = document.createElement('div');
            panel.id = 'CoveoErrorMarker';
            panel.style.fontFamily = 'Arial';
            panel.style.fontSize = '12pt';
            panel.style.padding = '15px';
            panel.style.position = 'absolute';
            if (wellKnown) {
                panel.style.border = '3px solid gray';
                panel.style.backgroundColor = 'whitesmoke';
                panel.style.left = '25%';
                panel.style.top = '30%';
                panel.style.width = '50%';
                panel.style.height = '20%';
            }
            else {
                panel.style.border = '3px solid red';
                panel.style.backgroundColor = 'white';
                panel.style.left = '25%';
                panel.style.top = '25%';
                panel.style.width = '50%';
                panel.style.height = '50%';
            }
            panel.style.zIndex = 10000;
            document.body.appendChild(panel);
            var insidePanel = document.createElement('div');
            insidePanel.style.width = '100%';
            insidePanel.style.height = '100%';
            insidePanel.style.overflow = 'auto';
            panel.appendChild(insidePanel);
            var friendlyError = document.createElement('div');
            friendlyError.style.fontWeight = 'bold';
            if (!wellKnown) {
                friendlyError.style.paddingBottom = '5px';
                friendlyError.style.borderBottom = '1px solid gray';
            }
            friendlyError.style.position = 'relative';
            var friendlyErrorText = document.createElement('div');
            friendlyErrorText.innerHTML = (wellKnown) ? wellKnownError : unknownError;
            friendlyError.appendChild(friendlyErrorText);
            insidePanel.appendChild(friendlyError);
            if (!wellKnown) {
                var fullError = document.createElement('div');
                fullError.innerHTML = errorDetails;
                fullError.style.marginTop = '20px';
                fullError.style.display = 'none';
                fullError.style.fontSize = '0.8em';
                insidePanel.appendChild(fullError);
                var toggle = document.createElement('div');
                toggle.innerHTML = 'Something unexpected happened and we had to stop processing your action.<br/><br/>' + 'Please reload the page. If the error persists, contact your system administrator.<br/><br/>' + 'Click here to display the error details.';
                toggle.style.marginTop = '20px';
                toggle.style.cursor = 'pointer';
                insidePanel.style.fontSize = '0.9em';
                toggle.attachEvent('onclick', ss.Delegate.create(this, function() {
                    fullError.style.display = 'block';
                    toggle.style.display = 'none';
                    panel.style.width = '90%';
                    panel.style.height = '90%';
                    panel.style.top = '10px';
                    panel.style.left = '5%';
                }));
                insidePanel.appendChild(toggle);
            }
            eval('if (window.external && window.external.PostBackErrorHandler) { window.external.PostBackErrorHandler(); }');
        }
    },
    
    _applyResults: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_applyResults() {
        /// <summary>
        /// Applies the result of the postback.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_Response);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Calling ProcessXmlFromServer...');
        this._processXmlFromServer();
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('ProcessXmlFromServer finished.');
    },
    
    _processXmlFromServer: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_processXmlFromServer() {
        /// <summary>
        /// Processes the xml sent by the server.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this._m_Response);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Calling ProcessXmlFromServer on AjaxManagerScript...');
        this._m_PostRequestProcesses = new Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager();
        this._m_Manager._processXmlFromServer(this._m_Response, this._m_PostRequestProcesses);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('ProcessXmlFromServer on AjaxManagerScript finished.');
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Updating view state...');
        var viewstate = this._m_Response.selectSingleNode('/AjaxManager/ViewState');
        if (viewstate != null) {
            (this._m_Manager.get_form()[Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE]).value = viewstate.text;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing updated controls...');
        var nodes = this._m_Response.selectNodes('/AjaxManager/Updated/Control');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            var effect = (node.attributes.getNamedItem('Effect')).value;
            var scope = (node.attributes.getNamedItem('Scope')).value;
            var reason = (node.attributes.getNamedItem('Reason')).value;
            this._m_Manager._tearDownObjectsBelow(scope);
            var target = document.getElementById(id);
            var flipper = new Coveo.CNL.Web.Scripts.Ajax.ControlFlipper(target, node.text);
            if (!this._m_Manager.get_enableUpdateDebugging()) {
                this._m_PostRequestProcesses.add(Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.create(target, flipper, effect));
            }
            else {
                this._m_PostRequestProcesses.add(new Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger(flipper, reason));
            }
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Control ' + id + ' was updated.');
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing updated regions...');
        nodes = this._m_Response.selectNodes('/AjaxManager/Updated/Region');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            var effect = (node.attributes.getNamedItem('Effect')).value;
            var scope = (node.attributes.getNamedItem('Scope')).value;
            var reason = (node.attributes.getNamedItem('Reason')).value;
            if (scope !== '') {
                this._m_Manager._tearDownObjectsBelow(scope);
            }
            var target = document.getElementById(id);
            var flipper = new Coveo.CNL.Web.Scripts.Ajax.RegionFlipper(target, node.text);
            if (!this._m_Manager.get_enableUpdateDebugging()) {
                this._m_PostRequestProcesses.add(Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.create(target, new Coveo.CNL.Web.Scripts.Ajax.RegionFlipper(target, node.text), effect));
            }
            else {
                this._m_PostRequestProcesses.add(new Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger(flipper, reason));
            }
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Region ' + id + ' was updated.');
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing modal boxes...');
        nodes = this._m_Response.selectNodes('/AjaxManager/Close/Box');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var boxId = (node.attributes.getNamedItem('BoxId')).value;
            this._m_Manager._tearDownObjectsBelow(boxId);
            this._m_Manager.closeModalBox(boxId);
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Modal box ' + boxId + ' was closed.');
        }
        nodes = this._m_Response.selectNodes('/AjaxManager/ModalBoxes/Box');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var boxId = (node.attributes.getNamedItem('BoxId')).value;
            var width = parseInt((node.attributes.getNamedItem('Width')).value);
            var height = parseInt((node.attributes.getNamedItem('Height')).value);
            var horizontalMargin = parseInt((node.attributes.getNamedItem('HorizontalMargin')).value);
            var verticalMargin = parseInt((node.attributes.getNamedItem('VerticalMargin')).value);
            var EnableOutsideClick = Boolean.parse((node.attributes.getNamedItem('EnableOutsideClick')).value);
            var box = new Coveo.CNL.Web.Scripts.Ajax.ModalBox(this._m_Manager, boxId, node.text, width, height, horizontalMargin, verticalMargin, EnableOutsideClick);
            this._m_Manager.addModalBox(box);
            box.show();
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Modal box ' + boxId + ' was shown.');
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing postback return value...');
        var retval = this._m_Response.selectSingleNode('/AjaxManager/Return');
        var retvalHtml = this._m_Response.selectSingleNode('/AjaxManager/ReturnHtml');
        var retvalXml = this._m_Response.selectSingleNode('/AjaxManager/ReturnXml');
        if (retval != null) {
            var type = (retval.attributes.getNamedItem('Type')).value;
            this._m_ReturnValue = Coveo.CNL.Web.Scripts.MarshalUtilities.unmarshalValue(type, retval.text);
        }
        else if (retvalHtml != null) {
            var elem = document.createElement('div');
            elem.innerHTML = retvalHtml.text;
            this._m_ReturnValue = elem;
        }
        else if (retvalXml != null) {
            this._m_ReturnValue = retvalXml;
        }
        var resetTimerCount = this._m_Response.selectSingleNode('/AjaxManager/ResetTimerCount');
        if (resetTimerCount != null) {
            this._m_Manager.resetTimer();
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Starting Post-request processes...');
        this._m_PostRequestProcesses.startAll(ss.Delegate.create(this, this._postOperationsAreDoneCallback));
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Post-request processes started.');
        var scrollBackUpNode = this._m_Response.selectSingleNode('/AjaxManager/ScrollBackUp');
        if (scrollBackUpNode != null) {
            var scrollText = scrollBackUpNode.text;
            Coveo.CNL.Web.Scripts.DOMUtilities.scrollAllTheWayUp((scrollText.toLowerCase() === 'true') ? null : scrollText);
        }
    },
    
    _postOperationsAreDoneCallback: function Coveo_CNL_Web_Scripts_Ajax_PartialPostBack$_postOperationsAreDoneCallback(p_Sender, p_Args) {
        /// <summary>
        /// Callback for when all post request operations are done.
        /// </summary>
        /// <param name="p_Sender" type="Object">
        /// </param>
        /// <param name="p_Args" type="ss.EventArgs">
        /// </param>
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Post-request operations are done.');
        this._m_PostRequestProcesses = null;
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing updated regions to update after everything...');
        var nodes = this._m_Response.selectNodes('/AjaxManager/Updated/RegionAtEnd');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            var target = document.getElementById(id);
            target.innerHTML = node.text;
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Region ' + id + ' was updated.');
        }
        this._m_Manager._processXmlForAfterScriptsAreLoaded(this._m_Response);
        this._m_Manager._hookButtonControls();
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE6() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isEmulatingIE7()) {
            document.body.className = document.body.className;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('ProcessXmlForAjaxObjects done.');
        if (this._m_Callback != null) {
            this._m_Callback.invoke(this._m_ReturnValue);
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Postback callback function called.');
        }
        if (!this._m_IgnoreResults) {
            Coveo.CNL.Web.Scripts.DOMUtilities.decrementBusyCounter();
        }
        this._m_Manager.postBackIsFinished();
        if (this._m_Profiler != null) {
            this._m_Profiler.stop();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax._feedbackInfo

Coveo.CNL.Web.Scripts.Ajax._feedbackInfo = function Coveo_CNL_Web_Scripts_Ajax__feedbackInfo() {
    /// <summary>
    /// Holds information about a feedback
    /// </summary>
    /// <field name="m_Id" type="String">
    /// </field>
    /// <field name="m_Name" type="String">
    /// </field>
    /// <field name="m_Type" type="String">
    /// </field>
    /// <field name="m_Target" type="String">
    /// </field>
    /// <field name="m_Fullscreen" type="Boolean">
    /// </field>
    /// <field name="m_Text" type="String">
    /// </field>
    /// <field name="m_Image" type="String">
    /// </field>
}
Coveo.CNL.Web.Scripts.Ajax._feedbackInfo.prototype = {
    m_Id: null,
    m_Name: null,
    m_Type: null,
    m_Target: null,
    m_Fullscreen: false,
    m_Text: null,
    m_Image: null
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript

Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript = function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript() {
    /// <summary>
    /// Client side code for the AjaxManager class.
    /// </summary>
    /// <field name="_s_Instance" type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" static="true">
    /// </field>
    /// <field name="_m_Id" type="String">
    /// </field>
    /// <field name="_m_Form" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_AdditionalForms" type="Array" elementType="Object" elementDomElement="true">
    /// </field>
    /// <field name="_m_Bootstrap" type="Boolean">
    /// </field>
    /// <field name="_m_NewBootstrap" type="Boolean">
    /// </field>
    /// <field name="_m_CanAddHttpHeaders" type="Boolean">
    /// </field>
    /// <field name="_m_FrameworkDoPostBack" type="Coveo.CNL.Web.Scripts.Ajax.PostBackMethod">
    /// </field>
    /// <field name="_m_IdSubstitutions" type="Object">
    /// </field>
    /// <field name="_m_PartialOrFullMappings" type="Coveo.CNL.Web.Scripts.Ajax.IdMappings">
    /// </field>
    /// <field name="_m_AlwaysSend" type="Array">
    /// </field>
    /// <field name="_m_Feedbacks" type="Array">
    /// </field>
    /// <field name="_m_FeedbackMappings" type="Coveo.CNL.Web.Scripts.Ajax.IdMappings">
    /// </field>
    /// <field name="_m_FeedbackNameMappings" type="Coveo.CNL.Web.Scripts.Ajax.IdMappings">
    /// </field>
    /// <field name="_m_BlankOnHistory" type="Array">
    /// </field>
    /// <field name="_m_LoadedScripts" type="Object">
    /// </field>
    /// <field name="_m_LoadedStyleSheets" type="Object">
    /// </field>
    /// <field name="_m_AjaxObjects" type="Array">
    /// </field>
    /// <field name="_m_CurrentPostBack" type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack">
    /// </field>
    /// <field name="_m_ModalBoxes" type="Array">
    /// </field>
    /// <field name="_m_EnableProgress" type="Boolean">
    /// </field>
    /// <field name="_m_ProgressPageUri" type="String">
    /// </field>
    /// <field name="_m_EnableUpdateDebugging" type="Boolean">
    /// </field>
    /// <field name="_m_EnableProfiling" type="Boolean">
    /// </field>
    /// <field name="_m_EnableHistory" type="Boolean">
    /// </field>
    /// <field name="_m_CurrentState" type="String">
    /// </field>
    /// <field name="_m_TimerEnabled" type="Boolean">
    /// </field>
    /// <field name="_m_TimerId" type="Number" integer="true">
    /// </field>
    /// <field name="_m_TimerInterval" type="Number" integer="true">
    /// </field>
    /// <field name="_m_TimerTickedCount" type="Number" integer="true">
    /// </field>
    /// <field name="_m_TimerHardStop" type="Number" integer="true">
    /// </field>
    /// <field name="_m_NbTimerBlockingControls" type="Number" integer="true">
    /// </field>
    /// <field name="_m_ControlToFocus" type="String">
    /// </field>
    /// <field name="_m_FocusWithoutScrolling" type="Boolean">
    /// </field>
    /// <field name="_m_MaxNumberOfFocusAttemps" type="Number" integer="true">
    /// </field>
    /// <field name="_m_CurrentNumberOfFocusAttemps" type="Number" integer="true">
    /// </field>
    /// <field name="_m_AsynchronousCalls" type="XmlNodeList">
    /// </field>
    this._m_IdSubstitutions = {};
    this._m_PartialOrFullMappings = new Coveo.CNL.Web.Scripts.Ajax.IdMappings();
    this._m_AlwaysSend = [];
    this._m_Feedbacks = [];
    this._m_FeedbackMappings = new Coveo.CNL.Web.Scripts.Ajax.IdMappings();
    this._m_FeedbackNameMappings = new Coveo.CNL.Web.Scripts.Ajax.IdMappings();
    this._m_BlankOnHistory = [];
    this._m_LoadedScripts = {};
    this._m_LoadedStyleSheets = {};
    this._m_AjaxObjects = [];
    this._m_ModalBoxes = [];
    this._m_TimerId = -1;
}
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current = function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_current() {
    /// <summary>
    /// The current instance of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" />.
    /// </summary>
    /// <value type="Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript"></value>
    return Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript._s_Instance;
}
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.takeBackupOfValue = function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$takeBackupOfValue(p_Element) {
    /// <summary>
    /// Takes a backup of the value of a form element, to be restored later.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element to backup.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isFirefox() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isChrome()) {
        p_Element.type = 'text';
        p_Element.style.display = 'none';
    }
    var def = p_Element.defaultValue;
    p_Element.__bak = def;
}
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.getBackupValueIfAny = function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$getBackupValueIfAny(p_Element) {
    /// <summary>
    /// Reads back the backup value of a form element, if any.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose backup value to read.
    /// </param>
    /// <returns type="String"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    var value = p_Element.__bak;
    if (value != null) {
        p_Element.__bak = null;
    }
    return value;
}
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.prototype = {
    _m_Id: null,
    _m_Form: null,
    _m_AdditionalForms: null,
    _m_Bootstrap: false,
    _m_NewBootstrap: false,
    _m_CanAddHttpHeaders: false,
    _m_FrameworkDoPostBack: null,
    _m_CurrentPostBack: null,
    _m_EnableProgress: false,
    _m_ProgressPageUri: null,
    _m_EnableUpdateDebugging: false,
    _m_EnableProfiling: false,
    _m_EnableHistory: false,
    _m_CurrentState: '',
    _m_TimerEnabled: true,
    _m_TimerInterval: 0,
    _m_TimerTickedCount: 0,
    _m_TimerHardStop: 0,
    _m_NbTimerBlockingControls: 0,
    _m_ControlToFocus: null,
    _m_FocusWithoutScrolling: false,
    _m_MaxNumberOfFocusAttemps: 10,
    _m_CurrentNumberOfFocusAttemps: 0,
    _m_AsynchronousCalls: null,
    
    get_form: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_form() {
        /// <summary>
        /// The ASP.NET form inside the page.
        /// </summary>
        /// <value type="Object" domElement="true"></value>
        return this._m_Form;
    },
    
    get_bootstrap: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_bootstrap() {
        /// <summary>
        /// Gets or sets whether the interface has been bootstrapped.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_Bootstrap;
    },
    set_bootstrap: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_bootstrap(value) {
        /// <summary>
        /// Gets or sets whether the interface has been bootstrapped.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_Bootstrap = value;
        return value;
    },
    
    get_newBootstrap: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_newBootstrap() {
        /// <summary>
        /// Gets or sets whether the interface has been bootstrapped.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_NewBootstrap;
    },
    set_newBootstrap: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_newBootstrap(value) {
        /// <summary>
        /// Gets or sets whether the interface has been bootstrapped.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_NewBootstrap = value;
        return value;
    },
    
    get_canAddHttpHeaders: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_canAddHttpHeaders() {
        /// <summary>
        /// Gets or sets whether custom entries can be added in the header of HTTP requests.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_CanAddHttpHeaders;
    },
    
    get_enableProgress: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_enableProgress() {
        /// <summary>
        /// Whether postback progress tracking is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_EnableProgress;
    },
    set_enableProgress: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_enableProgress(value) {
        /// <summary>
        /// Whether postback progress tracking is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_EnableProgress = value;
        return value;
    },
    
    get_progressPageUri: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_progressPageUri() {
        /// <summary>
        /// Gets or sets the uri of the page used to fetch progress information.
        /// </summary>
        /// <value type="String"></value>
        return this._m_ProgressPageUri;
    },
    set_progressPageUri: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_progressPageUri(value) {
        /// <summary>
        /// Gets or sets the uri of the page used to fetch progress information.
        /// </summary>
        /// <value type="String"></value>
        this._m_ProgressPageUri = value;
        return value;
    },
    
    get_enableUpdateDebugging: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_enableUpdateDebugging() {
        /// <summary>
        /// Whether update debugging is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_EnableUpdateDebugging;
    },
    set_enableUpdateDebugging: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_enableUpdateDebugging(value) {
        /// <summary>
        /// Whether update debugging is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_EnableUpdateDebugging = value;
        return value;
    },
    
    get_enableProfiling: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_enableProfiling() {
        /// <summary>
        /// Whether profiling is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_EnableProfiling;
    },
    set_enableProfiling: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_enableProfiling(value) {
        /// <summary>
        /// Whether profiling is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_EnableProfiling = value;
        return value;
    },
    
    get_enableHistory: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_enableHistory() {
        /// <summary>
        /// Whether history is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_EnableHistory;
    },
    set_enableHistory: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$set_enableHistory(value) {
        /// <summary>
        /// Whether history is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        this._m_EnableHistory = value;
        return value;
    },
    
    get_currentPostBack: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$get_currentPostBack() {
        /// <summary>
        /// The currently pending <see cref="T:Coveo.CNL.Web.Scripts.Ajax.PartialPostBack" />.
        /// </summary>
        /// <value type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack"></value>
        return this._m_CurrentPostBack;
    },
    
    initialize: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$initialize(p_Id, p_Form, p_AdditionalForms, p_DoPostBack, p_Xml, p_SkipInitialHistoryState, p_CanAddHttpHeaders) {
        /// <summary>
        /// Initializes a new instance of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript" />.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id of the AjaxManager control.
        /// </param>
        /// <param name="p_Form" type="Object" domElement="true">
        /// The ASP.NET form element.
        /// </param>
        /// <param name="p_AdditionalForms" type="Array" elementType="Object" elementDomElement="true">
        /// Optional additional forms that contain stuff we must manage.
        /// </param>
        /// <param name="p_DoPostBack" type="Coveo.CNL.Web.Scripts.Ajax.PostBackMethod">
        /// The framework's __doPostBack function.
        /// </param>
        /// <param name="p_Xml" type="XmlDocument">
        /// The initialization xml.
        /// </param>
        /// <param name="p_SkipInitialHistoryState" type="Boolean">
        /// Whether to skip the initial history state.
        /// </param>
        /// <param name="p_CanAddHttpHeaders" type="Boolean">
        /// Whether custom entries can be added in the header of HTTP requests.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript._s_Instance);
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Form);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_DoPostBack);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Xml);
        this._m_Id = p_Id;
        this._m_Form = p_Form;
        this._m_AdditionalForms = p_AdditionalForms;
        this._m_FrameworkDoPostBack = p_DoPostBack;
        this._m_TimerTickedCount = 0;
        this._m_CanAddHttpHeaders = p_CanAddHttpHeaders;
        var scripts = document.getElementsByTagName('script');
        for (var i = 0; i < scripts.length; ++i) {
            var script = scripts[i];
            var src = script.getAttribute('src');
            if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(src)) {
                this.registerScript(src);
            }
        }
        var links = document.getElementsByTagName('link');
        for (var i = 0; i < links.length; ++i) {
            var link = links[i];
            var rel = link.getAttribute('rel');
            var href = link.getAttribute('href');
            if (Coveo.CNL.Web.Scripts.Utilities.equals(rel, 'stylesheet', true)) {
                this._m_LoadedStyleSheets[href] = link;
            }
        }
        if (this._m_EnableHistory) {
            $(window).bind('hashchange', ss.Delegate.create(this, this._history_Navigated));
        }
        if (p_SkipInitialHistoryState) {
            this._m_CurrentState = window.location.hash.substr(1);
        }
        var async = new Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager();
        this._processXmlFromServer(p_Xml, async);
        async.startAll(ss.Delegate.create(this, function(p_Sender, p_Args) {
            this._processXmlForAfterScriptsAreLoaded(p_Xml);
            this._hookButtonControls();
            Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript._s_Instance = this;
        }));
        if (this._m_EnableHistory && !ss.isNullOrUndefined($.bbq.getState('s'))) {
            this._history_Navigated(null);
        }
    },
    
    DPB: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$DPB(p_Target, p_Argument, p_Preemptive, p_NonCancelable) {
        /// <summary>
        /// Replacement for the framework's __doPostBack function.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The id of the target control.
        /// </param>
        /// <param name="p_Argument" type="String">
        /// The postback arguments.
        /// </param>
        /// <param name="p_Preemptive" type="Boolean">
        /// Whether this is a preemptive postback.
        /// </param>
        /// <param name="p_NonCancelable" type="Boolean">
        /// Whether this postback is non cancelable.
        /// </param>
        /// <returns type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Argument);
        if (this.cancelPendingOperations()) {
            var substituted = this._getSubstitutedId(p_Target);
            if (this._isPartialPostbackTarget(substituted)) {
                var feedbacks = (!p_Preemptive) ? this._getFeedbacksForTarget(substituted) : [];
                this._m_CurrentPostBack = new Coveo.CNL.Web.Scripts.Ajax.PartialPostBack(this, p_Target, p_Argument, feedbacks, false, p_Preemptive, p_NonCancelable);
                this._m_CurrentPostBack.execute();
            }
            else {
                this._m_FrameworkDoPostBack.invoke(p_Target, p_Argument);
            }
        }
        return this._m_CurrentPostBack;
    },
    
    doPostBack: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$doPostBack(p_Target, p_Argument, p_Preemptive) {
        /// <summary>
        /// Replacement for the framework's __doPostBack function.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The id of the target control.
        /// </param>
        /// <param name="p_Argument" type="String">
        /// The postback arguments.
        /// </param>
        /// <param name="p_Preemptive" type="Boolean">
        /// Whether this is a preemptive postback.
        /// </param>
        /// <returns type="Coveo.CNL.Web.Scripts.Ajax.PartialPostBack"></returns>
        return this.DPB(p_Target, p_Argument, p_Preemptive, false);
    },
    
    DMC: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$DMC(p_Target, p_Method, p_Options, p_Callback, p_Args) {
        /// <summary>
        /// Performs a server-side method call.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The id of the target control.
        /// </param>
        /// <param name="p_Method" type="String">
        /// The method to call.
        /// </param>
        /// <param name="p_Options" type="String">
        /// The string that holds the postback options.
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// The callback for the method call.
        /// </param>
        /// <param name="p_Args" type="Array" elementType="Object">
        /// The arguments to pass to the method.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Method);
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Options);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Args);
        if (this.cancelPendingOperations()) {
            var options = new Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript(p_Options);
            var args = 'M:' + encodeURIComponent(p_Target);
            args += '&' + encodeURIComponent(p_Method);
            for (var i = 0; i < p_Args.length - 1; ++i) {
                args += '&' + this._encodeArg(p_Args[i]);
            }
            var substituted = this._getSubstitutedId(p_Target);
            if (options.get_forcePartialPostback() || this._isPartialPostbackTarget(substituted)) {
                var feedbacks = (options.get_triggerFeedbacks()) ? this._getFeedbacksForTarget(substituted) : [];
                this._m_CurrentPostBack = new Coveo.CNL.Web.Scripts.Ajax.PartialPostBack(this, this._m_Id, args, feedbacks, false, false, false);
                this._m_CurrentPostBack.set_callback(p_Callback);
                this._m_CurrentPostBack.set_sendControlData(options.get_sendControlData());
                this._m_CurrentPostBack.set_ignoreResults(options.get_ignoreResults());
                this._m_CurrentPostBack.execute();
            }
            else {
                this._m_FrameworkDoPostBack.invoke(this._m_Id, args);
            }
        }
    },
    
    doMethodCall: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$doMethodCall(p_Target, p_Method, p_Options, p_Callback, p_Args) {
        /// <summary>
        /// Performs a server-side method call.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The id of the target control.
        /// </param>
        /// <param name="p_Method" type="String">
        /// The method to call.
        /// </param>
        /// <param name="p_Options" type="String">
        /// The string that holds the postback options.
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// The callback for the method call.
        /// </param>
        /// <param name="p_Args" type="Array" elementType="Object">
        /// The arguments to pass to the method.
        /// </param>
        this.DMC(p_Target, p_Method, p_Options, p_Callback, p_Args);
    },
    
    cancelPendingOperations: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$cancelPendingOperations() {
        /// <summary>
        /// Cancels any currently pending operation.
        /// </summary>
        /// <returns type="Boolean"></returns>
        var cancelled = true;
        if (this._m_CurrentPostBack != null) {
            if (this._m_CurrentPostBack.cancel()) {
                this._m_CurrentPostBack = null;
            }
            else {
                cancelled = false;
            }
        }
        return cancelled;
    },
    
    shouldAlwaysBeSent: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$shouldAlwaysBeSent(p_Id) {
        /// <summary>
        /// Checks if a form field should always be sent to the server.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id of the form field.
        /// </param>
        /// <returns type="Boolean"></returns>
        var always = false;
        for (var i = 0; i < this._m_AlwaysSend.length; i++) {
            var id = this._m_AlwaysSend[i];
            if (Coveo.CNL.Web.Scripts.Utilities.equals(id, p_Id, true)) {
                always = true;
                break;
            }
        }
        return always;
    },
    
    isScriptLoaded: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$isScriptLoaded(p_Uri) {
        /// <summary>
        /// Checks if a script is already loaded.
        /// </summary>
        /// <param name="p_Uri" type="String">
        /// The uri of the script.
        /// </param>
        /// <returns type="Boolean"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
        var cleaned = this._cleanupScriptUri(p_Uri);
        return this._m_LoadedScripts[cleaned] != null || cleaned.indexOf('k=embedding') !== -1 || cleaned.indexOf('k=ccs') !== -1;
    },
    
    registerScript: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$registerScript(p_Uri) {
        /// <summary>
        /// Registers a new loaded script.
        /// </summary>
        /// <param name="p_Uri" type="String">
        /// The uri of the script.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
        var cleaned = this._cleanupScriptUri(p_Uri);
        this._m_LoadedScripts[cleaned] = 1;
    },
    
    getAllFormElements: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$getAllFormElements() {
        /// <summary>
        /// Returns the list of all form elements that we must manage (including those in additional forms).
        /// </summary>
        /// <returns type="Array"></returns>
        var result = this._getFormElements(this._m_Form);
        if (this._m_AdditionalForms != null) {
            var $enum1 = ss.IEnumerator.getEnumerator(this._m_AdditionalForms);
            while ($enum1.moveNext()) {
                var form = $enum1.get_current();
                var $enum2 = ss.IEnumerator.getEnumerator(this._getFormElements(form));
                while ($enum2.moveNext()) {
                    var elem = $enum2.get_current();
                    ArrayPrototype_add(result, elem);
                }
            }
        }
        return result;
    },
    
    addModalBox: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$addModalBox(p_Box) {
        /// <summary>
        /// Adds a modal dialog box to the list.
        /// </summary>
        /// <param name="p_Box" type="Coveo.CNL.Web.Scripts.Ajax.ModalBox">
        /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.ModalBox" /> to push.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Box);
        ArrayPrototype_add(this._m_ModalBoxes, p_Box);
    },
    
    closeModalBox: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$closeModalBox(p_BoxId) {
        /// <summary>
        /// Closes a modal box.
        /// </summary>
        /// <param name="p_BoxId" type="String">
        /// The unique identifier of the box to close.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_BoxId);
        var found = null;
        for (var i = 0; i < this._m_ModalBoxes.length; i++) {
            var box = this._m_ModalBoxes[i];
            if (box.get_id() === p_BoxId) {
                found = box;
                break;
            }
        }
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(found);
        if (found.get_visible()) {
            found.close();
        }
        ArrayPrototype_remove(this._m_ModalBoxes, found);
    },
    
    postBackIsFinished: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$postBackIsFinished() {
        /// <summary>
        /// Called when a PostBack is finished.
        /// </summary>
        this._m_CurrentPostBack = null;
    },
    
    blockTimer: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$blockTimer() {
        /// <summary>
        /// Block the timer.
        /// </summary>
        this._m_NbTimerBlockingControls += 1;
    },
    
    unblockTimer: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$unblockTimer() {
        /// <summary>
        /// Unblock and start the timer.
        /// </summary>
        this._m_NbTimerBlockingControls -= 1;
        Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_NbTimerBlockingControls >= 0);
        if (this._m_NbTimerBlockingControls === 0) {
            this._startTimer();
        }
    },
    
    resetTimer: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$resetTimer() {
        /// <summary>
        /// Reset the timer count.
        /// </summary>
        this._m_TimerTickedCount = 0;
    },
    
    _processXmlFromServer: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_processXmlFromServer(p_Xml, p_Async) {
        /// <summary>
        /// Processes xml sent by the server.
        /// </summary>
        /// <param name="p_Xml" type="XmlDocument">
        /// The <see cref="T:System.Xml.XmlDocument" /> to process.
        /// </param>
        /// <param name="p_Async" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager">
        /// The <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager" /> in which to register any required asynchronous process.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Xml);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Async);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing redirect uri...');
        var redirectUri = (p_Xml).selectSingleNode('/AjaxManager/Redirect/Uri');
        if (redirectUri != null) {
            var newWindow = p_Xml.selectSingleNode('/AjaxManager/Redirect/NewWindow');
            if (newWindow != null && Boolean.parse(newWindow.text)) {
                window.open(redirectUri.text, '_blank');
            }
            else {
                window.navigate(redirectUri.text);
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing download uri...');
        var downloadUri = (p_Xml).selectSingleNode('/AjaxManager/Download');
        if (downloadUri != null) {
            var ifr = document.createElement('iframe');
            ifr.setAttribute('style', 'display: none; height: 0; width: 0;');
            ifr.setAttribute('height', '0');
            ifr.setAttribute('width', '0');
            ifr.setAttribute('src', downloadUri.text);
            document.body.appendChild(ifr);
        }
        var pageTitle = p_Xml.selectSingleNode('/AjaxManager/PageTitle');
        if (pageTitle != null) {
            document.title = pageTitle.text;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing history state...');
        var history = p_Xml.selectSingleNode('/AjaxManager/History');
        if (history != null && this.get_enableHistory()) {
            this._m_CurrentState = history.text;
            var dic = {};
            dic['s'] = this._m_CurrentState;
            $.bbq.pushState(dic);
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    History state ' + this._m_CurrentState + ' was added.');
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing id substitutions...');
        this._m_IdSubstitutions = {};
        var nodes = p_Xml.selectNodes('/AjaxManager/Substitutions/Substitution');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            this._m_IdSubstitutions[(node.attributes.getNamedItem('Target')).value] = (node.attributes.getNamedItem('Substitute')).value;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list of partial postback controls...');
        this._m_PartialOrFullMappings.clear();
        nodes = p_Xml.selectNodes('/AjaxManager/Partial/Control');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            this._m_PartialOrFullMappings.add(this._getSubstitutedId(id), true);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list of full postback controls...');
        nodes = p_Xml.selectNodes('/AjaxManager/Full/Control');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            this._m_PartialOrFullMappings.add(this._getSubstitutedId(id), false);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list always sent form fields...');
        ArrayPrototype_clear(this._m_AlwaysSend);
        nodes = p_Xml.selectNodes('/AjaxManager/AlwaysSend/AlwaysSend');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            ArrayPrototype_add(this._m_AlwaysSend, id);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list of panel feedbacks...');
        ArrayPrototype_clear(this._m_Feedbacks);
        nodes = p_Xml.selectNodes('/AjaxManager/Feedbacks/PanelFeedback');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var info = new Coveo.CNL.Web.Scripts.Ajax._feedbackInfo();
            info.m_Id = (node.attributes.getNamedItem('Id')).value;
            info.m_Type = (node.attributes.getNamedItem('Type')).value;
            info.m_Fullscreen = Boolean.parse((node.attributes.getNamedItem('Fullscreen')).value);
            info.m_Text = (node.attributes.getNamedItem('Text')).value;
            info.m_Image = (node.attributes.getNamedItem('Image')).value;
            var panel = this._getSubstitutedId((node.attributes.getNamedItem('Panel')).value);
            ArrayPrototype_add(this._m_Feedbacks, info);
            this._m_FeedbackMappings.add(panel, info);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list of named feedbacks...');
        nodes = p_Xml.selectNodes('/AjaxManager/Feedbacks/NamedFeedback');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var info = new Coveo.CNL.Web.Scripts.Ajax._feedbackInfo();
            info.m_Id = (node.attributes.getNamedItem('Id')).value;
            info.m_Name = (node.attributes.getNamedItem('Name')).value;
            info.m_Type = (node.attributes.getNamedItem('Type')).value;
            info.m_Fullscreen = Boolean.parse((node.attributes.getNamedItem('Fullscreen')).value);
            info.m_Text = (node.attributes.getNamedItem('Text')).value;
            info.m_Image = (node.attributes.getNamedItem('Image')).value;
            ArrayPrototype_add(this._m_Feedbacks, info);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing list of targeted feedbacks...');
        nodes = p_Xml.selectNodes('/AjaxManager/Feedbacks/TargetFeedback');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var info = new Coveo.CNL.Web.Scripts.Ajax._feedbackInfo();
            info.m_Id = (node.attributes.getNamedItem('Id')).value;
            info.m_Target = (node.attributes.getNamedItem('TargetClientID')).value;
            info.m_Type = (node.attributes.getNamedItem('Type')).value;
            info.m_Fullscreen = Boolean.parse((node.attributes.getNamedItem('Fullscreen')).value);
            info.m_Text = (node.attributes.getNamedItem('Text')).value;
            info.m_Image = (node.attributes.getNamedItem('Image')).value;
            var target = this._getSubstitutedId((node.attributes.getNamedItem('TargetUniqueID')).value);
            ArrayPrototype_add(this._m_Feedbacks, info);
            this._m_FeedbackMappings.add(target, info);
        }
        nodes = p_Xml.selectNodes('/AjaxManager/Feedbacks/NamedFeedbackMapping');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var info = new Coveo.CNL.Web.Scripts.Ajax._feedbackInfo();
            info.m_Id = this._getSubstitutedId((node.attributes.getNamedItem('Id')).value);
            info.m_Name = (node.attributes.getNamedItem('Name')).value;
            this._m_FeedbackNameMappings.add(info.m_Id, info.m_Name);
        }
        ArrayPrototype_clear(this._m_BlankOnHistory);
        nodes = p_Xml.selectNodes('/AjaxManager/BlankOnHistory/BlankOnHistory');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(id);
            ArrayPrototype_add(this._m_BlankOnHistory, id);
        }
        var styleSheetsToRemove = {};
        nodes = p_Xml.selectNodes('/AjaxManager/StyleSheets/Remove');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var uri = node.text;
            styleSheetsToRemove[uri] = '';
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing stylesheets...');
        nodes = p_Xml.selectNodes('/AjaxManager/StyleSheets/StyleSheet');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var uri = node.text;
            if (Object.keyExists(styleSheetsToRemove, uri)) {
                this._removeStyleSheet(uri);
                delete styleSheetsToRemove[uri];
            }
            if (this._m_LoadedStyleSheets[uri] == null) {
                var link = document.createElement('link');
                link.rel = 'stylesheet';
                link.type = 'text/css';
                link.href = uri;
                if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
                    link.attachEvent('onload', ss.Delegate.create(this, function() {
                        document.body.click();
                    }));
                    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_quirksMode() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIEWithHistoryFrame()) {
                        document.body.appendChild(link);
                    }
                    else {
                        document.getElementsByTagName('head')[0].appendChild(link);
                    }
                }
                else {
                    document.getElementsByTagName('head')[0].appendChild(link);
                }
                this._m_LoadedStyleSheets[uri] = link;
                Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Stylesheet ' + uri + ' was added to the DOM.');
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing stylesheets to unload...');
        var $dict1 = styleSheetsToRemove;
        for (var $key2 in $dict1) {
            var entryToRemove = { key: $key2, value: $dict1[$key2] };
            var uri = entryToRemove.key;
            this._removeStyleSheet(uri);
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing hidden fields...');
        nodes = p_Xml.selectNodes('/AjaxManager/HiddenFields/HiddenField');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var name = (node.attributes.getNamedItem('Name')).value;
            var toDelete = Boolean.parse((node.attributes.getNamedItem('Delete')).value);
            var value = node.text;
            var input = document.getElementById(name);
            if (toDelete) {
                if (input != null) {
                    input.parentNode.removeChild(input);
                    Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Field ' + name + ' was deleted.');
                }
            }
            else {
                if (input == null) {
                    Coveo.CNL.Web.Scripts.CNLAssert.failWithMessage('Adding a new hidden field in a partial postback (after the initial load of the page) causes the navigation history to be lost in \"IE with history frame\" when navigating away and back to the search page. You should modify your code to avoid this.');
                    input = document.createElement('input');
                    input.type = 'hidden';
                    input.id = name;
                    input.name = name;
                    var elements = this._m_Form.elements;
                    elements[0].parentNode.appendChild(input);
                    Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Field ' + name + ' was created.');
                }
                input.value = value;
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing images to update...');
        nodes = p_Xml.selectNodes('/AjaxManager/ImagesToUpdate/ImageToUpdate');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            var value = node.text;
            var elem = document.getElementById(id);
            if (elem != null) {
                elem.src = value;
                Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    The url of control ' + id + ' was set to ' + value);
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing control values...');
        nodes = p_Xml.selectNodes('/AjaxManager/ControlValues/ControlValue');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var id = (node.attributes.getNamedItem('Id')).value;
            var value = node.text;
            var input = document.getElementById(id);
            if (input != null) {
                input.value = value;
                Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Value of control ' + id + ' was set to ' + value);
            }
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing timer stuff...');
        var globalTimer = p_Xml.selectSingleNode('/AjaxManager/GlobalTimer');
        if (globalTimer != null) {
            this._m_TimerInterval = parseInt((globalTimer.attributes.getNamedItem('Delay')).value);
            this._m_TimerHardStop = parseInt((globalTimer.attributes.getNamedItem('HardStop')).value);
        }
        else {
            this._m_TimerInterval = 0;
            this._m_TimerHardStop = 0;
        }
        if (this._m_TimerInterval > 0) {
            this._m_TimerEnabled = true;
            this._startTimer();
        }
        else {
            this._m_TimerEnabled = false;
            window.clearTimeout(this._m_TimerId);
            this._m_TimerId = -1;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing external scripts...');
        nodes = p_Xml.selectNodes('/AjaxManager/ExternalScripts/Script');
        if (nodes.length > 0) {
            var loader = null;
            for (var i = 0; i < nodes.length; ++i) {
                var node = nodes[i];
                var uri = (node.attributes.getNamedItem('Uri')).value;
                if (!this.isScriptLoaded(uri)) {
                    Coveo.CNL.Web.Scripts.CNLAssert.fail();
                    if (loader == null) {
                        loader = new Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper();
                    }
                    loader.add(uri);
                    this.registerScript(uri);
                    Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Script ' + uri + ' queued to be loaded.');
                }
            }
            if (loader != null) {
                p_Async.add(loader);
            }
        }
    },
    
    _processXmlForAfterScriptsAreLoaded: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_processXmlForAfterScriptsAreLoaded(p_Xml) {
        /// <summary>
        /// Processes the xml for the <see cref="T:Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript" /> objects from the server.
        /// </summary>
        /// <param name="p_Xml" type="XmlDocument">
        /// The <see cref="T:System.Xml.XmlDocument" /> to process.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Xml);
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing constants...');
        var nodes = p_Xml.selectNodes('/AjaxManager/Consts/Const');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var cls = (node.attributes.getNamedItem('Class')).value;
            var name = (node.attributes.getNamedItem('Name')).value;
            var kind = (node.attributes.getNamedItem('Type')).value;
            var value = Coveo.CNL.Web.Scripts.MarshalUtilities.unmarshalValue(kind, node.text);
            eval(cls)[name] = value;
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Constant ' + cls + '.' + name + ' was set to ' + value);
        }
        var count = 0;
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log('Processing inline scripts...');
        nodes = p_Xml.selectNodes('/AjaxManager/InlineScripts/Script');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            eval(node.text);
            ++count;
        }
        Coveo.CNL.Web.Scripts.Ajax.Profiler.log(count.toString() + ' inline scripts have been executed.');
        nodes = p_Xml.selectNodes('/AjaxManager/AjaxObjects/AjaxObject');
        for (var i = 0; i < nodes.length; ++i) {
            var node = nodes[i];
            var type = (node.attributes.getNamedItem('Type')).value;
            var ownerId = (node.attributes.getNamedItem('OwnerId')).value;
            ownerId = this._getSubstitutedId(ownerId);
            var obj = null;
            var existing = node.attributes.getNamedItem('Existing') != null;
            if (existing) {
                for (var j = 0; j < this._m_AjaxObjects.length; ++j) {
                    var ao = this._m_AjaxObjects[j];
                    if (ao.get_ownerId() === ownerId) {
                        obj = ao;
                        break;
                    }
                }
                Coveo.CNL.Web.Scripts.CNLAssert.notNull(obj);
            }
            else {
                obj = eval('new ' + type + '()');
                obj.set_ownerId(ownerId);
            }
            var subs = node.selectNodes('ProtectedField');
            for (var j = 0; j < subs.length; ++j) {
                var sub = subs[j];
                var name = (sub.attributes.getNamedItem('Name')).value;
                var kind = (sub.attributes.getNamedItem('Type')).value;
                var value = Coveo.CNL.Web.Scripts.MarshalUtilities.unmarshalValue(kind, sub.text);
                obj[name] = value;
            }
            subs = node.selectNodes('ProtectedDomElement');
            for (var j = 0; j < subs.length; ++j) {
                var sub = subs[j];
                var name = (sub.attributes.getNamedItem('Name')).value;
                var id = (sub.attributes.getNamedItem('Id')).value;
                var elem = document.getElementById(id);
                Coveo.CNL.Web.Scripts.CNLAssert.notNull(elem);
                obj[name] = elem;
            }
            subs = node.selectNodes('ProtectedMethods');
            for (var j = 0; j < subs.length; ++j) {
                var sub = subs[j];
                var name = (sub.attributes.getNamedItem('Name')).value;
                obj[name] = eval('dummyVariableNobodyWillEverUse = ' + sub.text);;
            }
            subs = node.selectNodes('PublicProperty');
            for (var j = 0; j < subs.length; ++j) {
                var sub = subs[j];
                var name = (sub.attributes.getNamedItem('Name')).value;
                var kind = (sub.attributes.getNamedItem('Type')).value;
                var value = Coveo.CNL.Web.Scripts.MarshalUtilities.unmarshalValue(kind, sub.text);
                obj['set_' + name](value);
            }
            if (!existing) {
                ArrayPrototype_add(this._m_AjaxObjects, obj);
                obj.initialize();
            }
            subs = node.selectNodes('Method');
            for (var j = 0; j < subs.length; j++) {
                var sub = subs[j];
                var name = (sub.attributes.getNamedItem('Name')).value;
                var dummyVariableNobodyWillEverUse = obj;;
                eval('dummyVariableNobodyWillEverUse.' + name + '(' + sub.text + ')');
            }
        }
        this._m_AsynchronousCalls = p_Xml.selectNodes('/AjaxManager/AsynchronousCalls/AsynchronousCall');
        if (this._m_AsynchronousCalls.length > 0) {
            var runCalls = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._runAsynchronousCalls), 0);
        }
        var focus = p_Xml.selectSingleNode('/AjaxManager/SetFocus');
        if (focus != null) {
            this._m_ControlToFocus = focus.text;
            this._m_FocusWithoutScrolling = Boolean.parse((focus.attributes.getNamedItem('WithoutScrolling')).value);
            this._m_CurrentNumberOfFocusAttemps = 0;
            var timer = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._setFocus), 0);
        }
        else {
            this._m_ControlToFocus = '';
            this._m_FocusWithoutScrolling = false;
        }
    },
    
    _hookButtonControls: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_hookButtonControls() {
        /// <summary>
        /// Hooks the OnClick event of all button controls within the form.
        /// </summary>
        var $enum1 = ss.IEnumerator.getEnumerator(this.getAllFormElements());
        while ($enum1.moveNext()) {
            var elem = $enum1.get_current();
            if (elem.tagName.toLowerCase() === 'input') {
                var inputElem = elem;
                var name = inputElem.name;
                if ((inputElem.type === 'submit' || inputElem.type === 'button' || inputElem.type === 'image') && !String.isNullOrEmpty(name) && inputElem.onclick == null) {
                    var d = this._createOnClickDelegateForButton(name);
                    inputElem.onclick = d;
                }
            }
        }
    },
    
    _tearDownObjectsBelow: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_tearDownObjectsBelow(p_Scope) {
        /// <summary>
        /// Removes all objects registered under a given scope.
        /// </summary>
        /// <param name="p_Scope" type="String">
        /// The scope at which to remove objects.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Scope);
        var scope = this._getSubstitutedId(p_Scope);
        var toRemove = [];
        for (var i = 0; i < this._m_AjaxObjects.length; i++) {
            var obj = this._m_AjaxObjects[i];
            if (obj.get_ownerId().startsWith(scope)) {
                ArrayPrototype_add(toRemove, obj);
            }
        }
        for (var i = 0; i < toRemove.length; i++) {
            var obj = toRemove[i];
            obj.tearDown();
            ArrayPrototype_remove(this._m_AjaxObjects, obj);
        }
    },
    
    _removeStyleSheet: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_removeStyleSheet(p_Uri) {
        /// <summary>
        /// Removes a stylesheet from the DOM.
        /// </summary>
        /// <param name="p_Uri" type="String">
        /// Uri of the stylesheet to remove.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
        if (this._m_LoadedStyleSheets[p_Uri] != null) {
            var link = this._m_LoadedStyleSheets[p_Uri];
            Coveo.CNL.Web.Scripts.DOMUtilities.removeLinkAndStylesheet(link);
            this._m_LoadedStyleSheets[p_Uri] = null;
            Coveo.CNL.Web.Scripts.Ajax.Profiler.log('    Stylesheet ' + p_Uri + ' was removed from the DOM.');
        }
    },
    
    _setFocus: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_setFocus() {
        /// <summary>
        /// Sets the focus on the element to focus.
        /// </summary>
        this._m_CurrentNumberOfFocusAttemps++;
        if (!Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty(this._m_ControlToFocus)) {
            var elem = document.getElementById(this._m_ControlToFocus);
            try {
                Coveo.CNL.Web.Scripts.DOMUtilities.focusElement(elem, this._m_FocusWithoutScrolling);
                if (document.activeElement !== elem && this._m_CurrentNumberOfFocusAttemps < this._m_MaxNumberOfFocusAttemps) {
                    var timer = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._setFocus), 0);
                }
                else {
                    if (elem.tagName.toLowerCase() === 'input') {
                        var inputElem = elem;
                        if (inputElem.type === 'text') {
                            Coveo.CNL.Web.Scripts.DOMUtilities.moveCaretAtTheEnd(elem);
                        }
                    }
                }
            }
            catch ($e1) {
            }
        }
    },
    
    _isPartialPostbackTarget: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_isPartialPostbackTarget(p_Target) {
        /// <summary>
        /// Checks if postbacks to a target control should be partial.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The target control.
        /// </param>
        /// <returns type="Boolean"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
        var partial;
        var mapping = this._m_PartialOrFullMappings.get(p_Target);
        if (mapping != null) {
            partial = mapping;
        }
        else {
            partial = false;
        }
        return partial;
    },
    
    _getFeedbacksForTarget: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_getFeedbacksForTarget(p_Target) {
        /// <summary>
        /// Retrieves the list of <see cref="T:Coveo.CNL.Web.Scripts.Ajax.Feedback" /> objects for a given postback target.
        /// </summary>
        /// <param name="p_Target" type="String">
        /// The target of the postback..
        /// </param>
        /// <returns type="Array"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Target);
        var toCreate = [];
        var feedback = this._m_FeedbackMappings.get(p_Target);
        if (feedback != null) {
            ArrayPrototype_add(toCreate, feedback);
        }
        var name = this._m_FeedbackNameMappings.get(p_Target);
        if (name != null) {
            for (var i = 0; i < this._m_Feedbacks.length; i++) {
                var fb = this._m_Feedbacks[i];
                if (Coveo.CNL.Web.Scripts.Utilities.equals(fb.m_Name, name, true)) {
                    ArrayPrototype_add(toCreate, fb);
                }
            }
        }
        var feedbacks = [];
        for (var i = 0; i < toCreate.length; i++) {
            var fb = toCreate[i];
            ArrayPrototype_add(feedbacks, Coveo.CNL.Web.Scripts.Ajax.Feedback.create(fb.m_Id, fb.m_Type, fb.m_Target, fb.m_Fullscreen, fb.m_Text, fb.m_Image));
        }
        return feedbacks;
    },
    
    _getSubstitutedId: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_getSubstitutedId(p_Id) {
        /// <summary>
        /// Apply any registered substitution to a control id.
        /// </summary>
        /// <param name="p_Id" type="String">
        /// The id to substitute.
        /// </param>
        /// <returns type="String"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Id);
        var substituted = p_Id;
        var $dict1 = this._m_IdSubstitutions;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (substituted.startsWith(entry.key)) {
                substituted = entry.value + substituted.substring(entry.key.length, substituted.length);
            }
        }
        return substituted;
    },
    
    _cleanupScriptUri: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_cleanupScriptUri(p_Uri) {
        /// <summary>
        /// Cleans up a script uri, removing the changing part that may differ on
        /// multiple servers member of the same NLB cluster.
        /// </summary>
        /// <param name="p_Uri" type="String">
        /// The uri of the script to clean up.
        /// </param>
        /// <returns type="String"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Uri);
        var cleaned = p_Uri;
        var beg = cleaned.indexOf('&z=');
        if (beg !== -1) {
            var end = cleaned.indexOf('&', beg + 1);
            cleaned = cleaned.substring(0, beg);
            if (end !== -1) {
                cleaned += cleaned.substring(end - beg, cleaned.length);
            }
        }
        return cleaned;
    },
    
    _createOnClickDelegateForButton: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_createOnClickDelegateForButton(p_Name) {
        /// <summary>
        /// Creates a delegate for hooking up the onclick event of a button.
        /// </summary>
        /// <param name="p_Name" type="String">
        /// The name of the button to hook.
        /// </param>
        /// <returns type="Coveo.CNL.Web.Scripts.Ajax._buttonClickDelegate"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Name);
        return ss.Delegate.create(this, function() {
            this.DPB(p_Name, '', false, false);
            return false;
        });
    },
    
    _history_Navigated: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_history_Navigated(p_Args) {
        /// <param name="p_Args" type="jQueryEvent">
        /// </param>
        var decoded = $.bbq.getState('s');
        if (Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(decoded)) {
            decoded = '';
        }
        if (decoded !== this._m_CurrentState) {
            var blank = [];
            for (var i = 0; i < this._m_BlankOnHistory.length; i++) {
                var id = this._m_BlankOnHistory[i];
                var elem = document.getElementById(id);
                Coveo.CNL.Web.Scripts.CNLAssert.notNull(elem);
                elem.style.visibility = 'hidden';
                ArrayPrototype_add(blank, elem);
            }
            this._m_CurrentState = decoded;
            if (this.cancelPendingOperations()) {
                this._m_CurrentPostBack = new Coveo.CNL.Web.Scripts.Ajax.PartialPostBack(this, this._m_Id, 'R:' + this._m_CurrentState, [], false, false, true);
                this._m_CurrentPostBack.set_sendControlData(false);
                this._m_CurrentPostBack.set_callback(ss.Delegate.create(this, function(p_Return) {
                    for (var i = 0; i < blank.length; i++) {
                        var elem = blank[i];
                        elem.style.visibility = 'visible';
                    }
                }));
                if (this.get_bootstrap() && String.isNullOrEmpty(this._m_CurrentState)) {
                    this._m_CurrentPostBack.set_keepQueryStringArguments(true);
                }
                this._m_CurrentPostBack.execute();
            }
        }
    },
    
    _timerTick: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_timerTick() {
        this._m_TimerId = -1;
        this._m_TimerTickedCount += 1;
        if (this._m_NbTimerBlockingControls === 0) {
            if (this._m_CurrentPostBack == null) {
                this._m_CurrentPostBack = new Coveo.CNL.Web.Scripts.Ajax.PartialPostBack(this, this._m_Id, 'T:', [], true, false, false);
                this._m_CurrentPostBack.set_sendControlData(false);
                this._m_CurrentPostBack.set_enableProgress(false);
                this._m_CurrentPostBack.execute();
            }
            else {
                this._startTimer();
            }
        }
    },
    
    _startTimer: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_startTimer() {
        /// <summary>
        /// Start the timer if it is enabled, no controls are blocking it, it is
        /// not already started and the interval is valid.
        /// </summary>
        if (this._m_TimerEnabled) {
            if (this._m_TimerHardStop === 0 || this._m_TimerTickedCount < this._m_TimerHardStop) {
                if (this._m_NbTimerBlockingControls === 0) {
                    if (this._m_TimerId === -1) {
                        if (this._m_TimerInterval > 0) {
                            this._m_TimerId = window.setTimeout(ss.Delegate.create(this, this._timerTick), this._m_TimerInterval);
                        }
                    }
                }
            }
        }
    },
    
    _runAsynchronousCalls: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_runAsynchronousCalls() {
        /// <summary>
        /// Executes the asynchronous calls if any.
        /// </summary>
        if (this._m_CurrentPostBack != null) {
            this._m_AsynchronousCalls = null;
        }
        else if (this._m_AsynchronousCalls != null) {
            var args = '';
            for (var i = 0; i < this._m_AsynchronousCalls.length; ++i) {
                args += this._m_AsynchronousCalls[i].text + '\n';
            }
            Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_CurrentPostBack == null);
            this._m_CurrentPostBack = new Coveo.CNL.Web.Scripts.Ajax.PartialPostBack(this, this._m_Id, args, [], false, false, false);
            this._m_CurrentPostBack.execute();
            this._m_AsynchronousCalls = null;
        }
    },
    
    _encodeArg: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_encodeArg(p_Arg) {
        /// <summary>
        /// Encodes a method argument.
        /// </summary>
        /// <param name="p_Arg" type="Object">
        /// </param>
        /// <returns type="String"></returns>
        var encoded;
        if (Type.canCast(p_Arg, Array)) {
            var array = p_Arg;
            var values = encodeURIComponent(array.length.toString());
            for (var i = 0; i < array.length; ++i) {
                values += '&' + this._encodeArg(array[i]);
            }
            encoded = encodeURIComponent(Coveo.CNL.Web.Scripts.MarshalUtilities.marshalValue(values));
        }
        else {
            encoded = encodeURIComponent(Coveo.CNL.Web.Scripts.MarshalUtilities.marshalValue(p_Arg));
        }
        return encoded;
    },
    
    _getFormElements: function Coveo_CNL_Web_Scripts_Ajax_AjaxManagerScript$_getFormElements(p_Form) {
        /// <summary>
        /// Get the child Elements of a FormElement.
        /// </summary>
        /// <param name="p_Form" type="Object" domElement="true">
        /// The parent form element to look at.
        /// </param>
        /// <returns type="Array"></returns>
        var result = [];
        var dictionary = {};
        for (var elIndex = 0; elIndex <= p_Form.elements.length; elIndex++) {
            var elem = p_Form.elements[elIndex];
            if (elem != null) {
                ArrayPrototype_add(result, elem);
                dictionary[elem.id] = elem;
            }
        }
        var formElems = this._m_Form.getElementsByTagName('input');
        for (var elIndex = 0; elIndex <= formElems.length; elIndex++) {
            var elem = formElems[elIndex];
            if (elem != null && !Object.keyExists(dictionary, elem.id)) {
                ArrayPrototype_add(result, elem);
                dictionary[elem.id] = elem;
            }
        }
        return result;
    }
}


Type.registerNamespace('Coveo.CNL.Web.Scripts');

////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.PositionEnum

Coveo.CNL.Web.Scripts.PositionEnum = function() { 
    /// <summary>
    /// This enumeration lists the positions (relative to another object) where
    /// a box can be dynamically placed.
    /// </summary>
    /// <field name="leftAbove" type="Number" integer="true" static="true">
    /// Left of the reference object, and going up.
    /// </field>
    /// <field name="leftBelow" type="Number" integer="true" static="true">
    /// Left of the reference object, and going down.
    /// </field>
    /// <field name="rightAbove" type="Number" integer="true" static="true">
    /// Right of the reference object, and going up.
    /// </field>
    /// <field name="rightBelow" type="Number" integer="true" static="true">
    /// Right of the reference object, and goind down.
    /// </field>
    /// <field name="aboveLeft" type="Number" integer="true" static="true">
    /// Above the reference object, and left aligned.
    /// </field>
    /// <field name="aboveRight" type="Number" integer="true" static="true">
    /// Above the reference object, and right aligned
    /// </field>
    /// <field name="belowLeft" type="Number" integer="true" static="true">
    /// Below the reference object, and left aligned
    /// </field>
    /// <field name="belowRight" type="Number" integer="true" static="true">
    /// Below the reference object, and right aligned
    /// </field>
};
Coveo.CNL.Web.Scripts.PositionEnum.prototype = {
    leftAbove: 0, 
    leftBelow: 1, 
    rightAbove: 2, 
    rightBelow: 3, 
    aboveLeft: 4, 
    aboveRight: 5, 
    belowLeft: 6, 
    belowRight: 7
}
Coveo.CNL.Web.Scripts.PositionEnum.registerEnum('Coveo.CNL.Web.Scripts.PositionEnum', false);


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.CookieUtilities

Coveo.CNL.Web.Scripts.CookieUtilities = function Coveo_CNL_Web_Scripts_CookieUtilities() {
    /// <summary>
    /// Provides various utilities for cookies handling.
    /// </summary>
}
Coveo.CNL.Web.Scripts.CookieUtilities.getCookie = function Coveo_CNL_Web_Scripts_CookieUtilities$getCookie(p_Name) {
    /// <summary>
    /// Gets a cookie value by it's name.
    /// </summary>
    /// <param name="p_Name" type="String">
    /// The name of the cookie to retrieve.
    /// </param>
    /// <returns type="String"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Name);
    var cookies = document.cookie;
    var prefix = p_Name + '=';
    var begin = cookies.indexOf('; ' + prefix);
    if (begin === -1) {
        begin = cookies.indexOf(prefix);
        if (begin !== 0) {
            return null;
        }
    }
    else {
        begin += 2;
    }
    var end = cookies.indexOf(';', begin);
    if (end === -1) {
        end = cookies.length;
    }
    return unescape(cookies.substring(begin + prefix.length, end));
}
Coveo.CNL.Web.Scripts.CookieUtilities.setCookie = function Coveo_CNL_Web_Scripts_CookieUtilities$setCookie(p_Name, p_Value, p_Expires) {
    /// <summary>
    /// Sets a cookie with expiration.
    /// </summary>
    /// <param name="p_Name" type="String">
    /// The name of the cookie to set.
    /// </param>
    /// <param name="p_Value" type="String">
    /// The value of the cookie to set.
    /// </param>
    /// <param name="p_Expires" type="Number" integer="true">
    /// The expiration of the cookie to set.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notEmpty(p_Name);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Value);
    var expires = '';
    if (!ss.isNull(p_Expires)) {
        var date = Date.get_now();
        date.setTime(date.getTime() + (p_Expires * 24 * 60 * 60 * 1000));
        expires = '; expires=' + date.toUTCString();
    }
    var curCookie = p_Name + '=' + escape(p_Value) + expires + '; path=/';
    document.cookie = curCookie;
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.MouseCapture

Coveo.CNL.Web.Scripts.MouseCapture = function Coveo_CNL_Web_Scripts_MouseCapture(p_MouseMoveHandler, p_MouseUpHandler) {
    /// <summary>
    /// Implements cross-browser mouse capture behavior.
    /// </summary>
    /// <param name="p_MouseMoveHandler" type="ElementEventHandler">
    /// The <see cref="T:System.EventHandler" /> to notify when the mouse moves.
    /// </param>
    /// <param name="p_MouseUpHandler" type="ElementEventHandler">
    /// The <see cref="T:System.EventHandler" /> to notify when the mouse button is released.
    /// </param>
    /// <field name="_m_MouseMoveHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_MouseUpHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_DocumentMouseMoveEventHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_DocumentMouseUpEventHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_DocumentMouseOutEventHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_LastX" type="Number" integer="true">
    /// </field>
    /// <field name="_m_LastY" type="Number" integer="true">
    /// </field>
    /// <field name="_m_OffsetX" type="Number" integer="true">
    /// </field>
    /// <field name="_m_OffsetY" type="Number" integer="true">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_MouseMoveHandler);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_MouseUpHandler);
    this._m_MouseMoveHandler = p_MouseMoveHandler;
    this._m_MouseUpHandler = p_MouseUpHandler;
    this._m_LastX = window.event.screenX;
    this._m_LastY = window.event.screenY;
    this._m_DocumentMouseMoveEventHandler = ss.Delegate.create(this, this._document_MouseMove);
    document.attachEvent('onmousemove', this._m_DocumentMouseMoveEventHandler);
    this._m_DocumentMouseUpEventHandler = ss.Delegate.create(this, this._document_MouseUp);
    document.attachEvent('onmouseup', this._m_DocumentMouseUpEventHandler);
    this._m_DocumentMouseOutEventHandler = ss.Delegate.create(this, this._document_MouseOut);
    document.attachEvent('onmouseout', this._m_DocumentMouseOutEventHandler);
}
Coveo.CNL.Web.Scripts.MouseCapture.prototype = {
    _m_MouseMoveHandler: null,
    _m_MouseUpHandler: null,
    _m_DocumentMouseMoveEventHandler: null,
    _m_DocumentMouseUpEventHandler: null,
    _m_DocumentMouseOutEventHandler: null,
    _m_LastX: 0,
    _m_LastY: 0,
    _m_OffsetX: 0,
    _m_OffsetY: 0,
    
    get_offsetX: function Coveo_CNL_Web_Scripts_MouseCapture$get_offsetX() {
        /// <summary>
        /// Gets the X offset since the last mouse event.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return this._m_OffsetX;
    },
    
    get_offsetY: function Coveo_CNL_Web_Scripts_MouseCapture$get_offsetY() {
        /// <summary>
        /// Gets the Y offset since the last mouse event.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return this._m_OffsetY;
    },
    
    dispose: function Coveo_CNL_Web_Scripts_MouseCapture$dispose() {
        /// <summary>
        /// Disposes the object.
        /// </summary>
        if (this._m_DocumentMouseMoveEventHandler != null) {
            document.detachEvent('onmousemove', this._m_DocumentMouseMoveEventHandler);
            this._m_DocumentMouseMoveEventHandler = null;
        }
        if (this._m_DocumentMouseUpEventHandler != null) {
            document.detachEvent('onmouseup', this._m_DocumentMouseUpEventHandler);
            this._m_DocumentMouseUpEventHandler = null;
        }
        if (this._m_DocumentMouseOutEventHandler != null) {
            document.detachEvent('onmouseout', this._m_DocumentMouseOutEventHandler);
            this._m_DocumentMouseOutEventHandler = null;
        }
    },
    
    _document_MouseMove: function Coveo_CNL_Web_Scripts_MouseCapture$_document_MouseMove() {
        var currentX = window.event.screenX;
        this._m_OffsetX = this._m_LastX - currentX;
        var currentY = window.event.screenY;
        this._m_OffsetY = this._m_LastY - currentY;
        if (this._m_MouseMoveHandler != null) {
            this._m_MouseMoveHandler.invoke();
        }
        this._m_LastX = currentX;
        this._m_LastY = currentY;
        window.event.returnValue = false;
        window.event.cancelBubble = true;
    },
    
    _document_MouseUp: function Coveo_CNL_Web_Scripts_MouseCapture$_document_MouseUp() {
        if (this._m_MouseUpHandler != null) {
            this._m_MouseUpHandler.invoke();
        }
        window.event.returnValue = false;
        window.event.cancelBubble = true;
    },
    
    _document_MouseOut: function Coveo_CNL_Web_Scripts_MouseCapture$_document_MouseOut() {
        if (window.event.toElement == null || window.event.toElement === document.documentElement) {
            if (this._m_MouseUpHandler != null) {
                this._m_MouseUpHandler.invoke();
            }
            window.event.returnValue = false;
            window.event.cancelBubble = true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.MulticastEventHandler

Coveo.CNL.Web.Scripts.MulticastEventHandler = function Coveo_CNL_Web_Scripts_MulticastEventHandler() {
    /// <summary>
    /// Class that siulates a MulticastDelegate.
    /// </summary>
    /// <field name="_m_EventHandlers" type="Array">
    /// </field>
    this._m_EventHandlers = [];
}
Coveo.CNL.Web.Scripts.MulticastEventHandler.prototype = {
    _m_EventHandlers: null,
    
    add: function Coveo_CNL_Web_Scripts_MulticastEventHandler$add(p_Handler) {
        /// <summary>
        /// Add a new EventHandler to the list.
        /// </summary>
        /// <param name="p_Handler" type="Object">
        /// The EventHandler to add.
        /// </param>
        ArrayPrototype_remove(this._m_EventHandlers, p_Handler);
    },
    
    remove: function Coveo_CNL_Web_Scripts_MulticastEventHandler$remove(p_Handler) {
        /// <summary>
        /// Removes an existing EventHandler from the list.
        /// </summary>
        /// <param name="p_Handler" type="Object">
        /// The EventHandler to remove.
        /// </param>
        ArrayPrototype_remove(this._m_EventHandlers, p_Handler);
    },
    
    invoke: function Coveo_CNL_Web_Scripts_MulticastEventHandler$invoke(p_Sender, p_Args) {
        /// <summary>
        /// Invoke the list of EventHandlers
        /// </summary>
        /// <param name="p_Sender" type="Object">
        /// The sender.
        /// </param>
        /// <param name="p_Args" type="Object">
        /// The arguments.
        /// </param>
        for (var i = 0; i < this._m_EventHandlers.length; i++) {
            var handler = this._m_EventHandlers[i];
            handler.invoke(p_Sender, p_Args);
        }
    },
    
    isDefined: function Coveo_CNL_Web_Scripts_MulticastEventHandler$isDefined() {
        /// <summary>
        /// Whether at least one event handler is defined or not.
        /// </summary>
        /// <returns type="Boolean"></returns>
        return this._m_EventHandlers.length > 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.OnClickElsewhereEvent

Coveo.CNL.Web.Scripts.OnClickElsewhereEvent = function Coveo_CNL_Web_Scripts_OnClickElsewhereEvent(p_Elements, p_Handler, p_EscapeToo) {
    /// <summary>
    /// Implements an event that fires when the user clicks somewhere else than on a given set of elements.
    /// </summary>
    /// <param name="p_Elements" type="Array" elementType="Object" elementDomElement="true">
    /// The elements outside of which a click must occur.
    /// </param>
    /// <param name="p_Handler" type="ElementEventHandler">
    /// The <see cref="T:System.Html.ElementEventHandler" /> that handles the event.
    /// </param>
    /// <param name="p_EscapeToo" type="Boolean">
    /// Whether to trigger the event when the user presses Escape.
    /// </param>
    /// <field name="_m_Elements" type="Array" elementType="Object" elementDomElement="true">
    /// </field>
    /// <field name="_m_Handler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_ClickDomEventHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_KeyDownEventHandler" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Elements);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Handler);
    this._m_Elements = p_Elements;
    this._m_Handler = p_Handler;
    this._m_ClickDomEventHandler = ss.Delegate.create(this, this._body_Click);
    document.body.attachEvent('onclick', this._m_ClickDomEventHandler);
    if (p_EscapeToo) {
        this._m_KeyDownEventHandler = ss.Delegate.create(this, this._body_KeyDown);
        document.body.attachEvent('onkeydown', this._m_KeyDownEventHandler);
    }
}
Coveo.CNL.Web.Scripts.OnClickElsewhereEvent.prototype = {
    _m_Elements: null,
    _m_Handler: null,
    _m_ClickDomEventHandler: null,
    _m_KeyDownEventHandler: null,
    
    dispose: function Coveo_CNL_Web_Scripts_OnClickElsewhereEvent$dispose() {
        /// <summary>
        /// Detaches the event handler.
        /// </summary>
        if (this._m_ClickDomEventHandler != null) {
            document.body.detachEvent('onclick', this._m_ClickDomEventHandler);
            this._m_ClickDomEventHandler = null;
        }
        if (this._m_KeyDownEventHandler != null) {
            document.body.detachEvent('onkeydown', this._m_KeyDownEventHandler);
            this._m_KeyDownEventHandler = null;
        }
    },
    
    _body_Click: function Coveo_CNL_Web_Scripts_OnClickElsewhereEvent$_body_Click() {
        var contains = false;
        for (var i = 0; i < this._m_Elements.length; i++) {
            var elem = this._m_Elements[i];
            if (elem.contains(window.event.srcElement)) {
                contains = true;
                break;
            }
        }
        if (!contains) {
            this._m_Handler.invoke();
        }
    },
    
    _body_KeyDown: function Coveo_CNL_Web_Scripts_OnClickElsewhereEvent$_body_KeyDown() {
        if (window.event.keyCode === 27) {
            this._m_Handler.invoke();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.ScriptLoader

Coveo.CNL.Web.Scripts.ScriptLoader = function Coveo_CNL_Web_Scripts_ScriptLoader(p_URLs) {
    /// <summary>
    /// Allows to load script in an HTML page.
    /// </summary>
    /// <param name="p_URLs" type="Array" elementType="String">
    /// The List of Script Url to be loaded.
    /// </param>
    /// <field name="_m_ScriptURLs" type="Array" elementType="String">
    /// </field>
    /// <field name="_m_LoadedHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_ErrorHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_IsIE" type="Boolean">
    /// </field>
    /// <field name="_m_OnLoadHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnErrorHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_ScriptLoadedIndex" type="Number" integer="true">
    /// </field>
    /// <field name="_m_ScriptElements" type="Array">
    /// </field>
    /// <field name="_m_LoadedScripts" type="Number" integer="true">
    /// </field>
    /// <field name="_m_InError" type="Boolean">
    /// </field>
    /// <field name="_m_Loaded" type="Boolean">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_URLs);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_URLs.length > 0);
    this._m_ScriptURLs = p_URLs;
    this._m_ScriptLoadedIndex = -1;
}
Coveo.CNL.Web.Scripts.ScriptLoader.prototype = {
    _m_ScriptURLs: null,
    _m_LoadedHandler: null,
    _m_ErrorHandler: null,
    _m_IsIE: false,
    _m_OnLoadHandler: null,
    _m_OnErrorHandler: null,
    _m_ScriptLoadedIndex: 0,
    _m_ScriptElements: null,
    _m_LoadedScripts: 0,
    _m_InError: false,
    _m_Loaded: false,
    
    dispose: function Coveo_CNL_Web_Scripts_ScriptLoader$dispose() {
        if (this._m_ScriptElements != null) {
            for (var i = 0; i < this._m_ScriptElements.length; i++) {
                var scriptElement = this._m_ScriptElements[i];
                if (this._m_IsIE) {
                    scriptElement.detachEvent('onreadystatechange', this._m_OnLoadHandler);
                }
                else {
                    scriptElement.detachEvent('onload', this._m_OnLoadHandler);
                    scriptElement.detachEvent('onerror', this._m_OnErrorHandler);
                }
            }
            this._m_ScriptElements = null;
        }
    },
    
    load: function Coveo_CNL_Web_Scripts_ScriptLoader$load(p_LoadInParallel, p_TimeOut, p_LoadedHandler, p_ErrorHandler) {
        /// <summary>
        /// Load the sript(s) in the current page.
        /// </summary>
        /// <param name="p_LoadInParallel" type="Boolean">
        /// Whether scripts should be loaded in parallel or not.
        /// </param>
        /// <param name="p_TimeOut" type="Number" integer="true">
        /// Time allowed to load a script.
        /// </param>
        /// <param name="p_LoadedHandler" type="ElementEventHandler">
        /// An event to fire when the script(s) will be loaded.
        /// </param>
        /// <param name="p_ErrorHandler" type="ElementEventHandler">
        /// An event to fire if an error occurs.
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_ErrorHandler);
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_ErrorHandler);
        this._m_LoadedHandler = p_LoadedHandler;
        this._m_ErrorHandler = p_ErrorHandler;
        this._m_OnLoadHandler = ss.Delegate.create(this, this.onScriptError);
        this._m_IsIE = window.navigator.userAgent.indexOf('MSIE') >= 0;
        if (this._m_IsIE) {
            this._m_OnErrorHandler = ss.Delegate.create(this, this.onScriptError);
        }
        this._m_ScriptElements = [];
        if (p_LoadInParallel) {
            for (var i = 0; i < this._m_ScriptURLs.length; i++) {
                this.loadScript(this._m_ScriptURLs[i]);
            }
        }
        else {
            this._m_ScriptLoadedIndex++;
            this.loadScript(this._m_ScriptURLs[this._m_ScriptLoadedIndex]);
        }
        if (p_TimeOut > 0) {
            window.setTimeout(ss.Delegate.create(this, this.onScriptError), p_TimeOut);
        }
    },
    
    loadScript: function Coveo_CNL_Web_Scripts_ScriptLoader$loadScript(p_ScriptURL) {
        /// <summary>
        /// Load a script into the head of the current page.
        /// </summary>
        /// <param name="p_ScriptURL" type="String">
        /// the url of the script to load.
        /// </param>
        var scriptElement = document.createElement('SCRIPT');
        if (this._m_IsIE) {
            scriptElement.attachEvent('onreadystatechange', this._m_OnLoadHandler);
        }
        else {
            scriptElement.readyState = 'complete';
            scriptElement.attachEvent('onload', this._m_OnLoadHandler);
            scriptElement.attachEvent('onerror', this._m_OnErrorHandler);
        }
        scriptElement.type = 'text/javascript';
        scriptElement.src = p_ScriptURL;
        ArrayPrototype_add(this._m_ScriptElements, scriptElement);
        document.getElementsByTagName('HEAD')[0].appendChild(scriptElement);
    },
    
    onScriptError: function Coveo_CNL_Web_Scripts_ScriptLoader$onScriptError() {
        if (!this._m_InError && !this._m_Loaded) {
            this._m_InError = true;
            this._m_ErrorHandler.invoke();
        }
    },
    
    onScriptLoad: function Coveo_CNL_Web_Scripts_ScriptLoader$onScriptLoad() {
        if (this._m_InError) {
            return;
        }
        var scriptElement = window.event.srcElement;
        if (scriptElement.readyState !== 'complete' && scriptElement.readyState !== 'loaded') {
            return;
        }
        if (this._m_ScriptLoadedIndex !== -1) {
            this._m_ScriptLoadedIndex++;
            if (this._m_ScriptLoadedIndex !== this._m_ScriptURLs.length) {
                this.loadScript(this._m_ScriptURLs[this._m_ScriptLoadedIndex]);
                return;
            }
        }
        else {
            this._m_LoadedScripts++;
            if (this._m_LoadedScripts !== this._m_ScriptURLs.length) {
                return;
            }
        }
        this._m_Loaded = true;
        this._m_LoadedHandler.invoke();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.StringDeserializer

Coveo.CNL.Web.Scripts.StringDeserializer = function Coveo_CNL_Web_Scripts_StringDeserializer(p_String) {
    /// <summary>
    /// Allows data to be deserialized from a string built by StringSerializer.
    /// </summary>
    /// <param name="p_String" type="String">
    /// The string that contains the serialized data.
    /// </param>
    /// <field name="_m_String" type="String">
    /// </field>
    /// <field name="_m_Special" type="Array" elementType="String">
    /// </field>
    /// <field name="_m_Current" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Builder" type="ss.StringBuilder">
    /// </field>
    /// <field name="SEPARATOR" type="String" static="true">
    /// The separator used to delimitate fields.
    /// </field>
    /// <field name="escapE_CHARACTER" type="String" static="true">
    /// The character used for character escapes.
    /// </field>
    /// <field name="versioN_MARKER" type="String" static="true">
    /// The marker used to identify a version number at the beginning of the string.
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_String);
    this._m_String = p_String;
    this._m_Special = [ Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER, Coveo.CNL.Web.Scripts.StringDeserializer.SEPARATOR ];
    Coveo.CNL.Web.Scripts.CNLAssert.check(this._m_String.startsWith(Coveo.CNL.Web.Scripts.StringDeserializer.versioN_MARKER));
    var marker = this.getString();
    Coveo.CNL.Web.Scripts.CNLAssert.check(marker.startsWith(Coveo.CNL.Web.Scripts.StringDeserializer.versioN_MARKER));
}
Coveo.CNL.Web.Scripts.StringDeserializer.prototype = {
    _m_String: null,
    _m_Special: null,
    _m_Current: 0,
    _m_Builder: null,
    
    get_EOF: function Coveo_CNL_Web_Scripts_StringDeserializer$get_EOF() {
        /// <summary>
        /// This property will return true whenever end of file has been reached.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._m_Current === this._m_String.length;
    },
    
    getInt: function Coveo_CNL_Web_Scripts_StringDeserializer$getInt() {
        /// <summary>
        /// Deserializes an integer.
        /// </summary>
        /// <returns type="Number" integer="true"></returns>
        return parseInt(this._getNextValue());
    },
    
    getDouble: function Coveo_CNL_Web_Scripts_StringDeserializer$getDouble() {
        /// <summary>
        /// Deserializes a double.
        /// </summary>
        /// <returns type="Number"></returns>
        return parseFloat(this._getNextValue());
    },
    
    getBool: function Coveo_CNL_Web_Scripts_StringDeserializer$getBool() {
        /// <summary>
        /// Deserializes a boolean.
        /// </summary>
        /// <returns type="Boolean"></returns>
        return (this._getNextValue() === '0') ? false : true;
    },
    
    getString: function Coveo_CNL_Web_Scripts_StringDeserializer$getString() {
        /// <summary>
        /// Deserializes a string.
        /// </summary>
        /// <returns type="String"></returns>
        var value = this._getNextValue();
        var pos = value.indexOf(Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER);
        if (pos !== -1) {
            if (this._m_Builder == null) {
                this._m_Builder = new ss.StringBuilder();
            }
            else {
                this._m_Builder.clear();
            }
            var last = 0;
            do {
                this._m_Builder.append(value.substring(last, pos));
                if (value.charAt(pos + 1) === Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER) {
                    this._m_Builder.append(Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER.toString());
                }
                else {
                    this._m_Builder.append(Coveo.CNL.Web.Scripts.StringDeserializer.SEPARATOR.toString());
                }
                last = pos + 2;
                pos = value.indexOf(Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER, last);
            } while (pos !== -1);
            this._m_Builder.append(value.substring(last, value.length));
            value = this._m_Builder.toString();
        }
        return value;
    },
    
    getStringArray: function Coveo_CNL_Web_Scripts_StringDeserializer$getStringArray() {
        /// <summary>
        /// Deserializes an array of strings.
        /// </summary>
        /// <returns type="Array" elementType="String"></returns>
        var length = this.getInt();
        var array = new Array(length);
        for (var i = 0; i < length; ++i) {
            array[i] = this.getString();
        }
        return array;
    },
    
    _getNextValue: function Coveo_CNL_Web_Scripts_StringDeserializer$_getNextValue() {
        /// <summary>
        /// Retrieves the next value in the serialized string.
        /// </summary>
        /// <returns type="String"></returns>
        Coveo.CNL.Web.Scripts.CNLAssert.check(!this.get_EOF());
        var pos = Coveo.CNL.Web.Scripts.Utilities.indexOfAny(this._m_String, this._m_Special, this._m_Current);
        while (pos !== -1) {
            var cur = this._m_String.charAt(pos);
            if (cur === Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER) {
                Coveo.CNL.Web.Scripts.CNLAssert.check(pos < this._m_String.length - 1);
                pos += 2;
            }
            else if (cur === Coveo.CNL.Web.Scripts.StringDeserializer.SEPARATOR) {
                break;
            }
            pos = Coveo.CNL.Web.Scripts.Utilities.indexOfAny(this._m_String, this._m_Special, pos);
        }
        var value;
        if (pos !== -1) {
            value = this._m_String.substring(this._m_Current, pos);
            this._m_Current = pos + 1;
        }
        else {
            value = this._m_String.substring(this._m_Current, this._m_String.length);
            this._m_Current = this._m_String.length;
        }
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Utilities

Coveo.CNL.Web.Scripts.Utilities = function Coveo_CNL_Web_Scripts_Utilities() {
    /// <summary>
    /// Various utility methods.
    /// </summary>
}
Coveo.CNL.Web.Scripts.Utilities.fromChar = function Coveo_CNL_Web_Scripts_Utilities$fromChar(p_Char, p_Length) {
    /// <param name="p_Char" type="String">
    /// </param>
    /// <param name="p_Length" type="Number" integer="true">
    /// </param>
    /// <returns type="String"></returns>
    var result = p_Char.toString();
    for (var i = 1; i < p_Length; i++) {
        result += p_Char;
    }
    return result;
}
Coveo.CNL.Web.Scripts.Utilities.padLeft = function Coveo_CNL_Web_Scripts_Utilities$padLeft(p_String, p_TotalWidth, p_Char) {
    /// <param name="p_String" type="String">
    /// </param>
    /// <param name="p_TotalWidth" type="Number" integer="true">
    /// </param>
    /// <param name="p_Char" type="String">
    /// </param>
    /// <returns type="String"></returns>
    if (p_String.length < p_TotalWidth) {
        return Coveo.CNL.Web.Scripts.Utilities.fromChar(p_Char, p_TotalWidth - p_String.length) + p_String;
    }
    return p_String;
}
Coveo.CNL.Web.Scripts.Utilities.padRight = function Coveo_CNL_Web_Scripts_Utilities$padRight(p_String, p_TotalWidth, p_Char) {
    /// <param name="p_String" type="String">
    /// </param>
    /// <param name="p_TotalWidth" type="Number" integer="true">
    /// </param>
    /// <param name="p_Char" type="String">
    /// </param>
    /// <returns type="String"></returns>
    if (p_String.length < p_TotalWidth) {
        return p_String + Coveo.CNL.Web.Scripts.Utilities.fromChar(p_Char, p_TotalWidth - p_String.length);
    }
    return p_String;
}
Coveo.CNL.Web.Scripts.Utilities.isNullOrEmpty = function Coveo_CNL_Web_Scripts_Utilities$isNullOrEmpty(p_String) {
    /// <summary>
    /// Check if a string is null or empty.
    /// </summary>
    /// <param name="p_String" type="String">
    /// The string to look at.
    /// </param>
    /// <returns type="Boolean"></returns>
    return p_String == null || p_String === '';
}
Coveo.CNL.Web.Scripts.Utilities.equals = function Coveo_CNL_Web_Scripts_Utilities$equals(p_String1, p_String2, p_IgnoreCase) {
    /// <summary>
    /// Check if two strings are equals.
    /// </summary>
    /// <param name="p_String1" type="String">
    /// The first string to look at.
    /// </param>
    /// <param name="p_String2" type="String">
    /// The second string to look at.
    /// </param>
    /// <param name="p_IgnoreCase" type="Boolean">
    /// Whether casing should be ignored or not.
    /// </param>
    /// <returns type="Boolean"></returns>
    if (p_IgnoreCase) {
        return (p_String1.toLowerCase() === p_String2.toLowerCase());
    }
    else {
        return (p_String1 === p_String2);
    }
}
Coveo.CNL.Web.Scripts.Utilities.indexOfAny = function Coveo_CNL_Web_Scripts_Utilities$indexOfAny(p_String, p_Chars, p_StartIndex) {
    /// <param name="p_String" type="String">
    /// </param>
    /// <param name="p_Chars" type="Array" elementType="String">
    /// </param>
    /// <param name="p_StartIndex" type="Number" integer="true">
    /// </param>
    /// <returns type="Number" integer="true"></returns>
    var result = -1;
    for (var i = 0; i < p_Chars.length; i++) {
        var index = p_String.indexOf(p_Chars[i], p_StartIndex);
        if (index !== -1 && (result === -1 || index < result)) {
            result = index;
        }
    }
    return result;
}
Coveo.CNL.Web.Scripts.Utilities.isNull = function Coveo_CNL_Web_Scripts_Utilities$isNull(p_Object) {
    /// <summary>
    /// Whether or not an object is null.
    /// </summary>
    /// <param name="p_Object" type="Object">
    /// The object to look at.
    /// </param>
    /// <returns type="Boolean"></returns>
    return Boolean.parse(eval('p_Object === null').toString());
}
Coveo.CNL.Web.Scripts.Utilities.isUndefined = function Coveo_CNL_Web_Scripts_Utilities$isUndefined(p_Object) {
    /// <summary>
    /// Whether or not an object is undefined.
    /// </summary>
    /// <param name="p_Object" type="Object">
    /// The object to look at.
    /// </param>
    /// <returns type="Boolean"></returns>
    return Boolean.parse(eval('p_Object === undefined').toString());
}
Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined = function Coveo_CNL_Web_Scripts_Utilities$isNullOrUndefined(p_Object) {
    /// <summary>
    /// Whether or not an object is null or undefined.
    /// </summary>
    /// <param name="p_Object" type="Object">
    /// The object to look at.
    /// </param>
    /// <returns type="Boolean"></returns>
    return (Coveo.CNL.Web.Scripts.Utilities.isNull(p_Object) || Coveo.CNL.Web.Scripts.Utilities.isUndefined(p_Object));
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.TransferMargin

Coveo.CNL.Web.Scripts.TransferMargin = function Coveo_CNL_Web_Scripts_TransferMargin(p_From, p_To) {
    /// <summary>
    /// Allows transfering the margins of a <see cref="T:System.Html.Element" /> to another element.
    /// </summary>
    /// <param name="p_From" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> whose margins to transfer.
    /// </param>
    /// <param name="p_To" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to which to transfer margins.
    /// </param>
    /// <field name="_m_From" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Left" type="String">
    /// </field>
    /// <field name="_m_Top" type="String">
    /// </field>
    /// <field name="_m_Right" type="String">
    /// </field>
    /// <field name="_m_Bottom" type="String">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_From);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_To);
    this._m_From = p_From;
    p_To.style.marginLeft = p_From.currentStyle.marginLeft;
    p_To.style.marginTop = p_From.currentStyle.marginTop;
    p_To.style.marginRight = p_From.currentStyle.marginRight;
    p_To.style.marginBottom = p_From.currentStyle.marginBottom;
    this._m_Left = p_From.style.marginLeft;
    p_From.style.marginLeft = '0px';
    this._m_Top = p_From.style.marginTop;
    p_From.style.marginTop = '0px';
    this._m_Right = p_From.style.marginRight;
    p_From.style.marginRight = '0px';
    this._m_Bottom = p_From.style.marginBottom;
    p_From.style.marginBottom = '0px';
}
Coveo.CNL.Web.Scripts.TransferMargin.prototype = {
    _m_From: null,
    _m_Left: null,
    _m_Top: null,
    _m_Right: null,
    _m_Bottom: null,
    
    restore: function Coveo_CNL_Web_Scripts_TransferMargin$restore() {
        /// <summary>
        /// Restores the margins to their initial state.
        /// </summary>
        this._m_From.style.marginLeft = this._m_Left;
        this._m_From.style.marginTop = this._m_Top;
        this._m_From.style.marginRight = this._m_Right;
        this._m_From.style.marginBottom = this._m_Bottom;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Timeout

Coveo.CNL.Web.Scripts.Timeout = function Coveo_CNL_Web_Scripts_Timeout(p_Callback, p_Delay) {
    /// <summary>
    /// Encapsulates usage of Window.SetTimeout/&gt; and Window.ClearTimeout.
    /// </summary>
    /// <param name="p_Callback" type="Callback">
    /// The <see cref="T:System.Callback" /> to call when the timeout fires..
    /// </param>
    /// <param name="p_Delay" type="Number" integer="true">
    /// The delay after which to call the callback (in milliseconds).
    /// </param>
    /// <field name="_m_Timer" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Callback" type="Callback">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Callback != null);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Delay >= 0);
    this._m_Callback = p_Callback;
    this._m_Timer = window.setTimeout(ss.Delegate.create(this, this._timerCallback), p_Delay);
}
Coveo.CNL.Web.Scripts.Timeout.prototype = {
    _m_Timer: 0,
    _m_Callback: null,
    
    cancel: function Coveo_CNL_Web_Scripts_Timeout$cancel() {
        /// <summary>
        /// Cancels the timeout, preventing it from firing.
        /// </summary>
        if (this._m_Timer !== 0) {
            window.clearTimeout(this._m_Timer);
            this._m_Timer = 0;
        }
    },
    
    _timerCallback: function Coveo_CNL_Web_Scripts_Timeout$_timerCallback() {
        /// <summary>
        /// Callback for when the timeout fires.
        /// </summary>
        if (this._m_Timer !== 0) {
            this._m_Callback.invoke();
            this._m_Timer = 0;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.OnLeaveManyEvent

Coveo.CNL.Web.Scripts.OnLeaveManyEvent = function Coveo_CNL_Web_Scripts_OnLeaveManyEvent(p_Elements, p_Delay, p_Handler) {
    /// <summary>
    /// Implements an event that fires when the mouse leaves a list of <see cref="T:System.Html.Element" /> objects for long enough.
    /// </summary>
    /// <param name="p_Elements" type="Array" elementType="Object" elementDomElement="true">
    /// The elements on which to hook the event.
    /// </param>
    /// <param name="p_Delay" type="Number" integer="true">
    /// The delay during which the mouse must have been outside the elements for the event to fire.
    /// </param>
    /// <param name="p_Handler" type="ElementEventHandler">
    /// The <see cref="T:System.Html.ElementEventHandler" /> that handles the event.
    /// </param>
    /// <field name="_m_Elements" type="Array" elementType="Object" elementDomElement="true">
    /// </field>
    /// <field name="_m_Delay" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Handler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnMouseOverHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_OnMouseOutHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_Timeout" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Elements);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Delay > 0);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Handler);
    this.attach(p_Elements, p_Delay, p_Handler);
}
Coveo.CNL.Web.Scripts.OnLeaveManyEvent.prototype = {
    _m_Elements: null,
    _m_Delay: 0,
    _m_Handler: null,
    _m_OnMouseOverHandler: null,
    _m_OnMouseOutHandler: null,
    _m_Timeout: null,
    
    dispose: function Coveo_CNL_Web_Scripts_OnLeaveManyEvent$dispose() {
        /// <summary>
        /// Detaches the event handler.
        /// </summary>
        if (this._m_Timeout != null) {
            this._m_Timeout.cancel();
            this._m_Timeout = null;
        }
        for (var i = 0; i < this._m_Elements.length; i++) {
            var elem = this._m_Elements[i];
            elem.detachEvent('onmouseover', this._m_OnMouseOverHandler);
            elem.detachEvent('onmouseout', this._m_OnMouseOutHandler);
        }
    },
    
    attach: function Coveo_CNL_Web_Scripts_OnLeaveManyEvent$attach(p_Elements, p_Delay, p_Handler) {
        /// <summary>
        /// Ataches the event handler.
        /// </summary>
        /// <param name="p_Elements" type="Array" elementType="Object" elementDomElement="true">
        /// The elements on which to hook the event.
        /// </param>
        /// <param name="p_Delay" type="Number" integer="true">
        /// The delay during which the mouse must have been outside the elements for the event to fire.
        /// </param>
        /// <param name="p_Handler" type="ElementEventHandler">
        /// The <see cref="T:System.Html.ElementEventHandler" /> that handles the event.
        /// </param>
        this._m_Elements = p_Elements;
        this._m_Delay = p_Delay;
        this._m_Handler = p_Handler;
        this._m_OnMouseOverHandler = ss.Delegate.create(this, this._element_OnMouseOver);
        this._m_OnMouseOutHandler = ss.Delegate.create(this, this._element_OnMouseOut);
        for (var i = 0; i < this._m_Elements.length; i++) {
            var elem = this._m_Elements[i];
            elem.attachEvent('onmouseover', this._m_OnMouseOverHandler);
            elem.attachEvent('onmouseout', this._m_OnMouseOutHandler);
        }
    },
    
    _fireRealHandler: function Coveo_CNL_Web_Scripts_OnLeaveManyEvent$_fireRealHandler() {
        /// <summary>
        /// Called when the mouse has left the elements for long enough.
        /// </summary>
        this._m_Timeout = null;
        this._m_Handler.invoke();
    },
    
    _element_OnMouseOver: function Coveo_CNL_Web_Scripts_OnLeaveManyEvent$_element_OnMouseOver() {
        var outside = true;
        for (var i = 0; i < this._m_Elements.length; i++) {
            var elem = this._m_Elements[i];
            if (elem.contains(window.event.fromElement)) {
                outside = false;
                break;
            }
        }
        if (outside) {
            if (this._m_Timeout != null) {
                this._m_Timeout.cancel();
                this._m_Timeout = null;
            }
        }
    },
    
    _element_OnMouseOut: function Coveo_CNL_Web_Scripts_OnLeaveManyEvent$_element_OnMouseOut() {
        var outside = true;
        for (var i = 0; i < this._m_Elements.length; i++) {
            var elem = this._m_Elements[i];
            if (elem.contains(window.event.toElement)) {
                outside = false;
                break;
            }
        }
        if (outside) {
            if (this._m_Timeout == null) {
                this._m_Timeout = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._fireRealHandler), this._m_Delay);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.OnDwellEvent

Coveo.CNL.Web.Scripts.OnDwellEvent = function Coveo_CNL_Web_Scripts_OnDwellEvent(p_Element, p_Delay, p_Handler) {
    /// <summary>
    /// Implements an event that fires when the mouse dwells over a <see cref="T:System.Html.Element" />.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element on which to hook the event.
    /// </param>
    /// <param name="p_Delay" type="Number" integer="true">
    /// The delay during which the mouse must hover the element for the event to fire.
    /// </param>
    /// <param name="p_Handler" type="ElementEventHandler">
    /// The <see cref="T:System.Html.ElementEventHandler" /> that handles the event.
    /// </param>
    /// <field name="_m_Element" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_Delay" type="Number" integer="true">
    /// </field>
    /// <field name="_m_Handler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_Timeout" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    /// <field name="_m_MouseOverDomEventHandler" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_MouseOutDomEventHandler" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Delay > 0);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Handler);
    this._m_Element = p_Element;
    this._m_Delay = p_Delay;
    this._m_Handler = p_Handler;
    this._m_MouseOverDomEventHandler = ss.Delegate.create(this, this._element_OnMouseOver);
    this._m_Element.attachEvent('onmouseover', this._m_MouseOverDomEventHandler);
    this._m_MouseOutDomEventHandler = ss.Delegate.create(this, this._element_OnMouseOut);
    this._m_Element.attachEvent('onmouseout', this._m_MouseOutDomEventHandler);
}
Coveo.CNL.Web.Scripts.OnDwellEvent.prototype = {
    _m_Element: null,
    _m_Delay: 0,
    _m_Handler: null,
    _m_Timeout: null,
    _m_MouseOverDomEventHandler: null,
    _m_MouseOutDomEventHandler: null,
    
    dispose: function Coveo_CNL_Web_Scripts_OnDwellEvent$dispose() {
        /// <summary>
        /// Detaches the event handler.
        /// </summary>
        if (this._m_Timeout != null) {
            this._m_Timeout.cancel();
            this._m_Timeout = null;
        }
        if (this._m_MouseOverDomEventHandler != null) {
            this._m_Element.detachEvent('onmouseover', this._m_MouseOverDomEventHandler);
            this._m_MouseOverDomEventHandler = null;
        }
        if (this._m_MouseOutDomEventHandler != null) {
            this._m_Element.detachEvent('onmouseout', this._m_MouseOutDomEventHandler);
            this._m_MouseOutDomEventHandler = null;
        }
    },
    
    _fireRealHandler: function Coveo_CNL_Web_Scripts_OnDwellEvent$_fireRealHandler() {
        /// <summary>
        /// Called when the mouse has dwelt long enough over the element.
        /// </summary>
        this._m_Timeout = null;
        this._m_Handler.invoke();
    },
    
    _element_OnMouseOver: function Coveo_CNL_Web_Scripts_OnDwellEvent$_element_OnMouseOver() {
        if (window.event.fromElement != null && !this._m_Element.contains(window.event.fromElement)) {
            Coveo.CNL.Web.Scripts.CNLAssert.isNull(this._m_Timeout);
            this._m_Timeout = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._fireRealHandler), this._m_Delay);
        }
    },
    
    _element_OnMouseOut: function Coveo_CNL_Web_Scripts_OnDwellEvent$_element_OnMouseOut() {
        if (!this._m_Element.contains(window.event.toElement)) {
            if (this._m_Timeout != null) {
                this._m_Timeout.cancel();
                this._m_Timeout = null;
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.ElementPosition

Coveo.CNL.Web.Scripts.ElementPosition = function Coveo_CNL_Web_Scripts_ElementPosition(p_Left, p_Top) {
    /// <summary>
    /// Holds the position of an element.
    /// </summary>
    /// <param name="p_Left" type="Number" integer="true">
    /// The left position of the element.
    /// </param>
    /// <param name="p_Top" type="Number" integer="true">
    /// The top position of the element.
    /// </param>
    /// <field name="left" type="Number" integer="true">
    /// The left position of the element, in pixels.
    /// </field>
    /// <field name="top" type="Number" integer="true">
    /// The top position of the element, in pixels.
    /// </field>
    this.left = p_Left;
    this.top = p_Top;
}
Coveo.CNL.Web.Scripts.ElementPosition.prototype = {
    left: 0,
    top: 0
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.ElementBounds

Coveo.CNL.Web.Scripts.ElementBounds = function Coveo_CNL_Web_Scripts_ElementBounds(p_Left, p_Top, p_Right, p_Bottom) {
    /// <summary>
    /// Holds the bounds of an element.
    /// </summary>
    /// <param name="p_Left" type="Number" integer="true">
    /// The left position of the element.
    /// </param>
    /// <param name="p_Top" type="Number" integer="true">
    /// The top position of the element.
    /// </param>
    /// <param name="p_Right" type="Number" integer="true">
    /// The right position of the element.
    /// </param>
    /// <param name="p_Bottom" type="Number" integer="true">
    /// The bottom position of the element.
    /// </param>
    /// <field name="left" type="Number" integer="true">
    /// The left position of the element, in pixels.
    /// </field>
    /// <field name="top" type="Number" integer="true">
    /// The top position of the element, in pixels.
    /// </field>
    /// <field name="right" type="Number" integer="true">
    /// The right position of the element, in pixels.
    /// </field>
    /// <field name="bottom" type="Number" integer="true">
    /// The bottom position of the element, in pixels.
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Left >= 0);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Top >= 0);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Right >= p_Left);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Bottom >= p_Top);
    this.left = p_Left;
    this.top = p_Top;
    this.right = p_Right;
    this.bottom = p_Bottom;
}
Coveo.CNL.Web.Scripts.ElementBounds.prototype = {
    left: 0,
    top: 0,
    right: 0,
    bottom: 0,
    
    get_width: function Coveo_CNL_Web_Scripts_ElementBounds$get_width() {
        /// <summary>
        /// The width of the element.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return this.right - this.left;
    },
    
    get_height: function Coveo_CNL_Web_Scripts_ElementBounds$get_height() {
        /// <summary>
        /// The height of the element.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return this.bottom - this.top;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.BrowserHelper

Coveo.CNL.Web.Scripts.BrowserHelper = function Coveo_CNL_Web_Scripts_BrowserHelper() {
    /// <summary>
    /// Provides various general javascript utilities.
    /// </summary>
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('MSIE') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE6 = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE6() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 6.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('MSIE 6') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7 = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE7() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 7.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('MSIE 7') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isEmulatingIE7 = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isEmulatingIE7() {
    /// <summary>
    /// This property is true if the browser is emulating Internet Explorer 7.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8Compat() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9Compat();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8 = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE8() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 8.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('MSIE 8') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8Compat = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE8Compat() {
    /// <summary>
    /// True if the browser is Internet Explorer 8 in Compatibility Mode.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7() && window.navigator.userAgent.indexOf('Trident/4.0') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9 = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE9() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 9.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('MSIE 9') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9Compat = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE9Compat() {
    /// <summary>
    /// True if the browser is Internet Explorer 9 in Compatibility Mode.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7() && window.navigator.userAgent.indexOf('Trident/5.0') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7Plus = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE7Plus() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 7 or better.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8Plus = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE8Plus() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 8 or better.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9Plus = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIE9Plus() {
    /// <summary>
    /// This property is true if the browser is Internet Explorer 9 or better.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE9();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isIEWithHistoryFrame = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isIEWithHistoryFrame() {
    /// <summary>
    /// Gets whether the browser is IE using an IFRAME for managing the navigation history of partial postbacks.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE6() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isEmulatingIE7();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isFirefox = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isFirefox() {
    /// <summary>
    /// This property is true if the browser is Firefox.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('Firefox') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isChrome = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isChrome() {
    /// <summary>
    /// This property is true if the browser is Google Chrome.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('Chrome') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isSafari = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isSafari() {
    /// <summary>
    /// This property is true if the browser is Apple Safari.
    /// </summary>
    /// <value type="Boolean"></value>
    return window.navigator.userAgent.indexOf('Safari') !== -1;
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_isWebKit = function Coveo_CNL_Web_Scripts_BrowserHelper$get_isWebKit() {
    /// <summary>
    /// This property is true if the browser is based on WebKit rendering
    /// engine.
    /// </summary>
    /// <value type="Boolean"></value>
    return Coveo.CNL.Web.Scripts.BrowserHelper.get_isSafari() || Coveo.CNL.Web.Scripts.BrowserHelper.get_isChrome();
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode = function Coveo_CNL_Web_Scripts_BrowserHelper$get_standardMode() {
    /// <summary>
    /// This property is true if the current document is in standard mode.
    /// </summary>
    /// <value type="Boolean"></value>
    return eval('document.compatMode') !== 'BackCompat';
}
Coveo.CNL.Web.Scripts.BrowserHelper.get_quirksMode = function Coveo_CNL_Web_Scripts_BrowserHelper$get_quirksMode() {
    /// <summary>
    /// This property is true if the current document is in quirks mode.
    /// </summary>
    /// <value type="Boolean"></value>
    return !Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode();
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.ElementSize

Coveo.CNL.Web.Scripts.ElementSize = function Coveo_CNL_Web_Scripts_ElementSize(p_Width, p_Height) {
    /// <summary>
    /// Holds the size of an element.
    /// </summary>
    /// <param name="p_Width" type="Number" integer="true">
    /// The width of the element.
    /// </param>
    /// <param name="p_Height" type="Number" integer="true">
    /// The height of the element.
    /// </param>
    /// <field name="width" type="Number" integer="true">
    /// The width of the element, in pixels.
    /// </field>
    /// <field name="height" type="Number" integer="true">
    /// The heigh of the element, in pixels.
    /// </field>
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Width >= 0);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Height >= 0);
    this.width = p_Width;
    this.height = p_Height;
}
Coveo.CNL.Web.Scripts.ElementSize.prototype = {
    width: 0,
    height: 0
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.DOMUtilities

Coveo.CNL.Web.Scripts.DOMUtilities = function Coveo_CNL_Web_Scripts_DOMUtilities() {
    /// <summary>
    /// Provides various utilities for marshalling data with the server.
    /// </summary>
    /// <field name="_s_BusyCounter" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_s_BusyMarker" type="Object" domElement="true" static="true">
    /// </field>
}
Coveo.CNL.Web.Scripts.DOMUtilities.getWindowSize = function Coveo_CNL_Web_Scripts_DOMUtilities$getWindowSize() {
    /// <summary>
    /// Computes the size of the display window, in pixels.
    /// </summary>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementSize"></returns>
    var size;
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) {
        size = new Coveo.CNL.Web.Scripts.ElementSize(document.documentElement.clientWidth, document.documentElement.clientHeight);
    }
    else {
        size = new Coveo.CNL.Web.Scripts.ElementSize(document.body.clientWidth, document.body.clientHeight);
    }
    return size;
}
Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount = function Coveo_CNL_Web_Scripts_DOMUtilities$getScrollingAmount() {
    /// <summary>
    /// Computes the current scrolling amount of the window.
    /// </summary>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementSize"></returns>
    var x, y;
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) {
        x = document.documentElement.scrollLeft;
        y = document.documentElement.scrollTop;
    }
    else {
        x = document.body.scrollLeft;
        y = document.body.scrollTop;
    }
    return new Coveo.CNL.Web.Scripts.ElementSize(x, y);
}
Coveo.CNL.Web.Scripts.DOMUtilities.getElementPosition = function Coveo_CNL_Web_Scripts_DOMUtilities$getElementPosition(p_Element) {
    /// <summary>
    /// Computes the position of an element, in pixels, relative to the top of the document.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose position to compute.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementPosition"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    var left = 0;
    var top = 0;
    var rects = p_Element.getClientRects();
    var rect = rects.item(0);
    left = rect.left;
    top = rect.top;
    if (!Coveo.CNL.Web.Scripts.Utilities.equals(p_Element.tagName, 'html', true) && !Coveo.CNL.Web.Scripts.Utilities.equals(p_Element.tagName, 'body', true)) {
        var scroll = Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount();
        left += scroll.width;
        top += scroll.height;
    }
    return new Coveo.CNL.Web.Scripts.ElementPosition(left, top);
}
Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize = function Coveo_CNL_Web_Scripts_DOMUtilities$getElementSize(p_Element) {
    /// <summary>
    /// Computes the size of an element, in pixels.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose size to compute.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementSize"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    return new Coveo.CNL.Web.Scripts.ElementSize(p_Element.offsetWidth, p_Element.offsetHeight);
}
Coveo.CNL.Web.Scripts.DOMUtilities.setElementSize = function Coveo_CNL_Web_Scripts_DOMUtilities$setElementSize(p_Element, p_Size) {
    /// <summary>
    /// Sets the size of an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose size to set.
    /// </param>
    /// <param name="p_Size" type="Coveo.CNL.Web.Scripts.ElementSize">
    /// The new size of the element.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Size);
    p_Element.style.width = p_Size.width + 'px';
    p_Element.style.height = p_Size.height + 'px';
}
Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds = function Coveo_CNL_Web_Scripts_DOMUtilities$getElementBounds(p_Element) {
    /// <summary>
    /// Computes the bounds of an element, in pixels.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose bounds to compute.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementBounds"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    var pos = Coveo.CNL.Web.Scripts.DOMUtilities.getElementPosition(p_Element);
    var size = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Element);
    return new Coveo.CNL.Web.Scripts.ElementBounds(pos.left, pos.top, pos.left + size.width, pos.top + size.height);
}
Coveo.CNL.Web.Scripts.DOMUtilities.setElementBounds = function Coveo_CNL_Web_Scripts_DOMUtilities$setElementBounds(p_Element, p_Bounds) {
    /// <summary>
    /// Sets the bounds of an absolutely positioned element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose bounds to set.
    /// </param>
    /// <param name="p_Bounds" type="Coveo.CNL.Web.Scripts.ElementBounds">
    /// The new bounds of the element.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Bounds);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Element.style.position === 'absolute');
    p_Element.style.left = p_Bounds.left + 'px';
    p_Element.style.top = p_Bounds.top + 'px';
    p_Element.style.width = p_Bounds.get_width() + 'px';
    p_Element.style.height = p_Bounds.get_height() + 'px';
}
Coveo.CNL.Web.Scripts.DOMUtilities.getVisibleRectangle = function Coveo_CNL_Web_Scripts_DOMUtilities$getVisibleRectangle() {
    /// <summary>
    /// Retrieves the bounding of the region that is visible in the window (in pixels).
    /// </summary>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementBounds"></returns>
    var left, top;
    var scroll = Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount();
    left = scroll.width;
    top = scroll.height;
    var right, bottom;
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) {
        right = left + document.documentElement.clientWidth;
        bottom = top + document.documentElement.clientHeight;
    }
    else {
        right = left + document.body.clientWidth;
        bottom = top + document.body.clientHeight;
    }
    return new Coveo.CNL.Web.Scripts.ElementBounds(left, top, right, bottom);
}
Coveo.CNL.Web.Scripts.DOMUtilities.getIntersection = function Coveo_CNL_Web_Scripts_DOMUtilities$getIntersection(p_First, p_Second) {
    /// <summary>
    /// Computes the intersection of two rectangles.
    /// </summary>
    /// <param name="p_First" type="Coveo.CNL.Web.Scripts.ElementBounds">
    /// The first rectangle.
    /// </param>
    /// <param name="p_Second" type="Coveo.CNL.Web.Scripts.ElementBounds">
    /// The first rectangle.
    /// </param>
    /// <returns type="Coveo.CNL.Web.Scripts.ElementBounds"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_First);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Second);
    var left = Math.max(p_First.left, p_Second.left);
    var top = Math.max(p_First.top, p_Second.top);
    var right = Math.min(p_First.right, p_Second.right);
    var bottom = Math.min(p_First.bottom, p_Second.bottom);
    return new Coveo.CNL.Web.Scripts.ElementBounds(left, top, right, bottom);
}
Coveo.CNL.Web.Scripts.DOMUtilities.positionElement = function Coveo_CNL_Web_Scripts_DOMUtilities$positionElement(p_Element, p_Reference, p_Position) {
    /// <summary>
    /// Positions an element relative to another.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to position.
    /// </param>
    /// <param name="p_Reference" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to position relatively to.
    /// </param>
    /// <param name="p_Position" type="Coveo.CNL.Web.Scripts.PositionEnum">
    /// Where to place the element from the other.
    /// </param>
    var position1;
    var position2;
    switch (p_Position) {
        case Coveo.CNL.Web.Scripts.PositionEnum.leftBelow:
            position1 = 'Left';
            position2 = 'Below';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.leftAbove:
            position1 = 'Left';
            position2 = 'Above';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.aboveLeft:
            position1 = 'Above';
            position2 = 'Left';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.aboveRight:
            position1 = 'Above';
            position2 = 'Right';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.rightBelow:
            position1 = 'Right';
            position2 = 'Below';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.rightAbove:
            position1 = 'Right';
            position2 = 'Above';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.belowLeft:
            position1 = 'Below';
            position2 = 'Left';
            break;
        case Coveo.CNL.Web.Scripts.PositionEnum.belowRight:
            position1 = 'Below';
            position2 = 'Right';
            break;
        default:
            Coveo.CNL.Web.Scripts.CNLAssert.fail();
            position1 = 'Left';
            position2 = 'Below';
            break;
    }
    var left = 0;
    var top = 0;
    var reqLeft = 0;
    var reqTop = 0;
    var done = false;
    var attempts = 0;
    var osize = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Element);
    var rrect = Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(p_Reference);
    var vrect = Coveo.CNL.Web.Scripts.DOMUtilities.getVisibleRectangle();
    while (!done && attempts < 3) {
        if (position1 === 'Left') {
            left = rrect.left - osize.width;
        }
        else if (position1 === 'Right') {
            left = rrect.right - 1;
        }
        else if (position1 === 'Above') {
            top = rrect.top - osize.height;
        }
        else if (position1 === 'Below') {
            top = rrect.bottom - 1;
        }
        if (position2 === 'Left') {
            left = rrect.left;
        }
        else if (position2 === 'Right') {
            left = rrect.right - osize.width;
        }
        else if (position2 === 'Above') {
            top = rrect.bottom - osize.height;
        }
        else if (position2 === 'Below') {
            top = rrect.top;
        }
        if (attempts === 0) {
            reqLeft = left;
            reqTop = top;
        }
        done = true;
        var right = left + osize.width;
        var bottom = top + osize.height;
        if (left < vrect.left || right >= vrect.right) {
            if (position1 === 'Left') {
                position1 = 'Right';
            }
            else if (position1 === 'Right') {
                position1 = 'Left';
            }
            else if (position2 === 'Left') {
                position2 = 'Right';
            }
            else if (position2 === 'Right') {
                position2 = 'Left';
            }
            done = false;
        }
        if (top < vrect.top || bottom >= vrect.bottom) {
            if (position1 === 'Above') {
                position1 = 'Below';
            }
            else if (position1 === 'Below') {
                position1 = 'Above';
            }
            else if (position2 === 'Above') {
                position2 = 'Below';
            }
            else if (position2 === 'Below') {
                position2 = 'Above';
            }
            done = false;
        }
        ++attempts;
    }
    if (!done) {
        left = reqLeft;
        top = reqTop;
    }
    Coveo.CNL.Web.Scripts.DOMUtilities.setElementPosition(p_Element, new Coveo.CNL.Web.Scripts.ElementPosition(left, top));
}
Coveo.CNL.Web.Scripts.DOMUtilities.setElementPosition = function Coveo_CNL_Web_Scripts_DOMUtilities$setElementPosition(p_Element, p_Position) {
    /// <summary>
    /// Sets the position of an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to position.
    /// </param>
    /// <param name="p_Position" type="Coveo.CNL.Web.Scripts.ElementPosition">
    /// The position where to place the element.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Position);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Element.currentStyle.position === 'absolute');
    var offsetParent = p_Element.offsetParent;
    if (offsetParent != null && !Coveo.CNL.Web.Scripts.Utilities.equals(offsetParent.nodeName, 'body', true)) {
        var position = Coveo.CNL.Web.Scripts.DOMUtilities.getElementPosition(offsetParent);
        p_Element.style.left = p_Position.left - position.left + 'px';
        p_Element.style.top = p_Position.top - position.top + 'px';
    }
    else {
        p_Element.style.left = p_Position.left + 'px';
        p_Element.style.top = p_Position.top + 'px';
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.setFixedPosition = function Coveo_CNL_Web_Scripts_DOMUtilities$setFixedPosition(p_Element, p_Left, p_Top) {
    /// <summary>
    /// Configures an element so that it uses fixed positioning, even on IE6.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element to configure.
    /// </param>
    /// <param name="p_Left" type="Number" integer="true">
    /// The fixed left position of the element.
    /// </param>
    /// <param name="p_Top" type="Number" integer="true">
    /// The fixed top position of the element.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Left >= 0);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Top >= 0);
    if ((Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE7Plus() && Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) || !Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
        p_Element.style.position = 'fixed';
        p_Element.style.left = p_Left + 'px';
        p_Element.style.top = p_Top + 'px';
    }
    else {
        var doc = (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) ? 'documentElement' : 'body';
        p_Element.style.position = 'absolute';
        p_Element.style.setExpression('left', '(dummy = document.' + doc + '.scrollLeft + ' + p_Left + ') + \'px\'');
        p_Element.style.setExpression('top', '(dummy = document.' + doc + '.scrollTop + ' + p_Top + ') + \'px\'');
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.consumeRemainingHeight = function Coveo_CNL_Web_Scripts_DOMUtilities$consumeRemainingHeight(p_Parent, p_Header, p_Body, p_Footer, p_Continuous) {
    /// <summary>
    /// Arranges for a <see cref="T:System.Html.Element" /> to consume the remaining height
    /// left by a header and a footer inside a parent.
    /// </summary>
    /// <param name="p_Parent" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the parent.
    /// </param>
    /// <param name="p_Header" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the header.
    /// </param>
    /// <param name="p_Body" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the body.
    /// </param>
    /// <param name="p_Footer" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the footer.
    /// </param>
    /// <param name="p_Continuous" type="Boolean">
    /// Whether to continuously update the height.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Parent);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Body);
    Coveo.CNL.Web.Scripts.DOMUtilities._consumeRemainingHeightInternal(p_Parent, p_Header, p_Body, p_Footer, 0, 0, 0, p_Continuous);
}
Coveo.CNL.Web.Scripts.DOMUtilities.consumeHeightToWindowBottom = function Coveo_CNL_Web_Scripts_DOMUtilities$consumeHeightToWindowBottom(p_Element, p_Continuous) {
    /// <summary>
    /// Arranges for a <see cref="T:System.Html.Element" /> to consume the remaining height
    /// left by a header and a footer inside a parent.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to resize.
    /// </param>
    /// <param name="p_Continuous" type="Boolean">
    /// Whether to continuously update the height.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.DOMUtilities._consumeHeightToWindowBottomInternal(p_Element, 0, 0, p_Continuous);
}
Coveo.CNL.Web.Scripts.DOMUtilities.coverAllWindow = function Coveo_CNL_Web_Scripts_DOMUtilities$coverAllWindow(p_Element) {
    /// <summary>
    /// Configures an element so that it covers all the screen.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element to configure.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.DOMUtilities.setFixedPosition(p_Element, 0, 0);
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE() && !Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE8Plus() && !Coveo.CNL.Web.Scripts.BrowserHelper.get_isEmulatingIE7()) {
        var doc = (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode()) ? 'documentElement' : 'body';
        p_Element.style.setExpression('width', '(dummy = window.document.' + doc + '.clientWidth) + \'px\'');
        p_Element.style.setExpression('height', '(dummy = window.document.' + doc + '.clientHeight) + \'px\'');
    }
    else {
        p_Element.style.width = '100%';
        p_Element.style.height = '100%';
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity = function Coveo_CNL_Web_Scripts_DOMUtilities$setOpacity(p_Element, p_Opacity) {
    /// <summary>
    /// Sets the opacity of an element in a cross browser way.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element whose opacity to set.
    /// </param>
    /// <param name="p_Opacity" type="Number">
    /// The opacity of the element (from 0 to 1).
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_Opacity >= 0 && p_Opacity <= 1);
    if (Math.abs(p_Opacity - 1) > 0.1) {
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            p_Element.style.filter = 'alpha(opacity=' + (p_Opacity * 100).toFixed(0) + ')';
        }
        else {
            p_Element.style.opacity = p_Opacity.toString();
        }
    }
    else {
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
            p_Element.style.filter = '';
        }
        else {
            p_Element.style.opacity = '';
        }
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.scrollAllTheWayUp = function Coveo_CNL_Web_Scripts_DOMUtilities$scrollAllTheWayUp(p_MasterElemId) {
    /// <summary>
    /// Scrolls the browser window all the way up.
    /// </summary>
    /// <param name="p_MasterElemId" type="String">
    /// Master element in the DOM having the scrollbar (null for the whole page).
    /// </param>
    Coveo.CNL.Web.Scripts.DOMUtilities.scrollToHeight(p_MasterElemId, 0);
}
Coveo.CNL.Web.Scripts.DOMUtilities.scrollToHeight = function Coveo_CNL_Web_Scripts_DOMUtilities$scrollToHeight(p_MasterElemId, p_Height) {
    /// <summary>
    /// Scrolls the browser window to a specific height.
    /// </summary>
    /// <param name="p_MasterElemId" type="String">
    /// Master element in the DOM having the scrollbar (null for the whole page).
    /// </param>
    /// <param name="p_Height" type="Number" integer="true">
    /// The height we want to scroll.
    /// </param>
    if (p_MasterElemId == null) {
        if (Coveo.CNL.Web.Scripts.BrowserHelper.get_standardMode() && !Coveo.CNL.Web.Scripts.BrowserHelper.get_isWebKit()) {
            document.documentElement.scrollTop = p_Height;
        }
        else {
            document.body.scrollTop = p_Height;
        }
    }
    else {
        var masterElem = document.getElementById(p_MasterElemId);
        if (masterElem != null) {
            masterElem.scrollTop = p_Height;
        }
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.scrollIntoViewIfNotAlready = function Coveo_CNL_Web_Scripts_DOMUtilities$scrollIntoViewIfNotAlready(p_Element) {
    /// <summary>
    /// Scrolls an element into view if it's not already being displayed.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to scroll into view.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    var visible = Coveo.CNL.Web.Scripts.DOMUtilities.getVisibleRectangle();
    var bounds = Coveo.CNL.Web.Scripts.DOMUtilities.getElementBounds(p_Element);
    if (visible.left > bounds.left || visible.top > bounds.top || visible.right < bounds.right || visible.bottom < bounds.bottom) {
        p_Element.scrollIntoView();
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.resizeIFrameHeight = function Coveo_CNL_Web_Scripts_DOMUtilities$resizeIFrameHeight(p_IFrame, p_AdditionalHeight) {
    /// <summary>
    /// Resizes an iframe to it's content height.
    /// </summary>
    /// <param name="p_IFrame" type="Object" domElement="true">
    /// The iframe to resize.
    /// </param>
    /// <param name="p_AdditionalHeight" type="Number" integer="true">
    /// Additional height to provide for.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_IFrame);
    var height;
    if (!Coveo.CNL.Web.Scripts.Utilities.equals(p_IFrame.contentWindow.document.compatMode, 'BackCompat', true)) {
        height = p_IFrame.contentWindow.document.documentElement.scrollHeight;
    }
    else {
        height = p_IFrame.contentWindow.document.body.scrollHeight;
    }
    p_IFrame.style.height = (height + p_AdditionalHeight) + 'px';
}
Coveo.CNL.Web.Scripts.DOMUtilities.removeLinkAndStylesheet = function Coveo_CNL_Web_Scripts_DOMUtilities$removeLinkAndStylesheet(p_Link) {
    /// <summary>
    /// Removes a link element from the DOM, and removes it's associated stylesheet as well.
    /// </summary>
    /// <param name="p_Link" type="Object" domElement="true">
    /// The link element to remove.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Link);
    var stylesheets = window.document.styleSheets;
    for (var i = 0; i < stylesheets.length; ++i) {
        var stylesheet = stylesheets[i];
        var owner = stylesheet[(Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) ? 'owningElement' : 'ownerNode'];
        if (owner === p_Link) {
            stylesheet.disabled = true;
            break;
        }
    }
    p_Link.parentNode.removeChild(p_Link);
}
Coveo.CNL.Web.Scripts.DOMUtilities.setOperationPendingCursor = function Coveo_CNL_Web_Scripts_DOMUtilities$setOperationPendingCursor() {
    /// <summary>
    /// Changes the global mouse cursor to one that signals that an operation is pending.
    /// </summary>
    document.body.style.cursor = 'progress';
}
Coveo.CNL.Web.Scripts.DOMUtilities.removeOperationPendingCursor = function Coveo_CNL_Web_Scripts_DOMUtilities$removeOperationPendingCursor() {
    /// <summary>
    /// Removes the global mouse cursor set by <see cref="M:Coveo.CNL.Web.Scripts.DOMUtilities.SetOperationPendingCursor" />.
    /// </summary>
    document.body.style.cursor = '';
}
Coveo.CNL.Web.Scripts.DOMUtilities.incrementBusyCounter = function Coveo_CNL_Web_Scripts_DOMUtilities$incrementBusyCounter() {
    /// <summary>
    /// Increments the counter that registers if the browser is busy.
    /// </summary>
    if (++Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyCounter === 1) {
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker);
        Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker = document.createElement('div');
        Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker.id = 'CoveoBusyMarker';
        Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker.style.display = 'none';
        document.body.appendChild(Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker);
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.decrementBusyCounter = function Coveo_CNL_Web_Scripts_DOMUtilities$decrementBusyCounter() {
    /// <summary>
    /// Decrements the counter that registers if the browser is busy.
    /// </summary>
    Coveo.CNL.Web.Scripts.CNLAssert.check(Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyCounter > 0);
    if (--Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyCounter === 0) {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker);
        document.body.removeChild(Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker);
        Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker = null;
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex = function Coveo_CNL_Web_Scripts_DOMUtilities$getNextHighestZindex() {
    /// <summary>
    /// Gets the next highest Z-Index available.
    /// </summary>
    /// <returns type="Number" integer="true"></returns>
    var highestIndex = 0;
    var currentIndex = 0;
    var elements = document.getElementsByTagName('*');
    for (var i = 0; i < elements.length; ++i) {
        currentIndex = elements[i].currentStyle.zIndex;
        if (!isNaN(currentIndex)) {
            var current = parseInt(currentIndex);
            if (current < 16777271 && current > highestIndex) {
                highestIndex = current;
            }
        }
    }
    return (highestIndex + 1);
}
Coveo.CNL.Web.Scripts.DOMUtilities.changeEnableStateOfChildren = function Coveo_CNL_Web_Scripts_DOMUtilities$changeEnableStateOfChildren(p_Element, p_Disable, p_ResetValues) {
    /// <summary>
    /// Disable or enable all child nodes of an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for which to disable/enable it's children.
    /// </param>
    /// <param name="p_Disable" type="Boolean">
    /// <b>true</b> to disable the children,<b>false</b> to enable them.
    /// </param>
    /// <param name="p_ResetValues" type="Boolean">
    /// <b>true</b> to clear the child controls content (selction or value).
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    for (var childIndex = 0; childIndex < p_Element.childNodes.length; childIndex++) {
        var child = p_Element.childNodes[childIndex];
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(child);
        if (child.hasChildNodes()) {
            Coveo.CNL.Web.Scripts.DOMUtilities.changeEnableStateOfChildren(child, p_Disable, p_ResetValues);
        }
        try {
            child.disabled = p_Disable;
        }
        catch ($e1) {
        }
        if (p_ResetValues) {
            if (child.nodeName === 'OPTION' && (child).selected) {
                (child).selected = false;
            }
            else if (child.nodeName === 'INPUT' && ((child.getAttribute('type').toString().compareTo('text', true) === 0) || (child.getAttribute('type').toString().compareTo('password', true) === 0))) {
                (child).value = '';
            }
        }
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.setSelectedRange = function Coveo_CNL_Web_Scripts_DOMUtilities$setSelectedRange(p_TextBox, p_First, p_Last) {
    /// <summary>
    /// Sets the selected range of characters in a textbox.
    /// </summary>
    /// <param name="p_TextBox" type="Object" domElement="true">
    /// The textbox.
    /// </param>
    /// <param name="p_First" type="Number" integer="true">
    /// Index of the first character.
    /// </param>
    /// <param name="p_Last" type="Number" integer="true">
    /// Index of the character after the last one.
    /// </param>
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
        var range = p_TextBox.createTextRange();
        range.moveStart('character', p_First);
        range.moveEnd('character', p_Last - p_TextBox.value.length);
        range.select();
    }
    else {
        p_TextBox.setSelectionRange(p_First, p_Last);
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.getSelectionStart = function Coveo_CNL_Web_Scripts_DOMUtilities$getSelectionStart(p_TextBox) {
    /// <summary>
    /// Returns the start selection position of <paramref name="p_TextBox" />.
    /// </summary>
    /// <param name="p_TextBox" type="Object" domElement="true">
    /// The <see cref="T:System.Html.TextElement" />.
    /// </param>
    /// <returns type="Number" integer="true"></returns>
    var startPos = 0;
    if (Coveo.CNL.Web.Scripts.BrowserHelper.get_isIE()) {
        p_TextBox.focus();
        var range = document.selection.createRange();
        range.moveStart('character', -p_TextBox.value.length);
        startPos = range.text.length;
    }
    else {
        startPos = p_TextBox.selectionStart;
    }
    return startPos;
}
Coveo.CNL.Web.Scripts.DOMUtilities.moveCaretAtTheEnd = function Coveo_CNL_Web_Scripts_DOMUtilities$moveCaretAtTheEnd(p_TextBox) {
    /// <summary>
    /// Place the caret at the end of the text box. If text is larger than
    /// the text box, text is scrolled to show the end.
    /// </summary>
    /// <param name="p_TextBox" type="Object" domElement="true">
    /// The textbox.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_TextBox);
    Coveo.CNL.Web.Scripts.DOMUtilities.setSelectedRange(p_TextBox, p_TextBox.value.length, p_TextBox.value.length);
    if (p_TextBox.scrollWidth > p_TextBox.clientWidth) {
        p_TextBox.scrollLeft = p_TextBox.scrollWidth - p_TextBox.clientWidth;
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities.focusElement = function Coveo_CNL_Web_Scripts_DOMUtilities$focusElement(p_Element, p_DoNotScroll) {
    /// <summary>
    /// Place the focus on an element.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The element on which to focus.
    /// </param>
    /// <param name="p_DoNotScroll" type="Boolean">
    /// <b>true</b> to keep the current scroll of the page. <b>false</b> otherwise.
    /// </param>
    var currentScroll = Coveo.CNL.Web.Scripts.DOMUtilities.getScrollingAmount().height;
    p_Element.focus();
    if (p_DoNotScroll) {
        window.setTimeout(function() {
            Coveo.CNL.Web.Scripts.DOMUtilities.scrollToHeight(null, currentScroll);
        }, 10);
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities._consumeRemainingHeightInternal = function Coveo_CNL_Web_Scripts_DOMUtilities$_consumeRemainingHeightInternal(p_Parent, p_Header, p_Body, p_Footer, p_PreviousParentHeight, p_PreviousHeaderHeight, p_PreviousFooterHeight, p_Continuous) {
    /// <summary>
    /// Arranges for a <see cref="T:System.Html.Element" /> to consume the remaining height
    /// left by a header and a footer inside a parent.
    /// </summary>
    /// <param name="p_Parent" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the parent.
    /// </param>
    /// <param name="p_Header" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the header.
    /// </param>
    /// <param name="p_Body" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the body.
    /// </param>
    /// <param name="p_Footer" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> for the footer.
    /// </param>
    /// <param name="p_PreviousParentHeight" type="Number" integer="true">
    /// The previous height of the parent.
    /// </param>
    /// <param name="p_PreviousHeaderHeight" type="Number" integer="true">
    /// The previous height of the header.
    /// </param>
    /// <param name="p_PreviousFooterHeight" type="Number" integer="true">
    /// The previous height of the footer.
    /// </param>
    /// <param name="p_Continuous" type="Boolean">
    /// Whether to continuously update the height.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Parent);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Body);
    if (p_Parent.parentNode != null) {
        var parentHeight = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Parent).height;
        var headerHeight = (p_Header != null) ? Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Header).height : 0;
        var footerHeight = (p_Footer != null) ? Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Footer).height : 0;
        if (parentHeight !== p_PreviousParentHeight || headerHeight !== p_PreviousHeaderHeight || footerHeight !== p_PreviousFooterHeight) {
            p_Body.style.height = '25px';
            var borderHeight = p_Body.clientTop * 2;
            p_Body.style.display = 'none';
            parentHeight = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Parent).height;
            p_Body.style.height = Math.max(parentHeight - headerHeight - footerHeight - borderHeight, 0) + 'px';
            p_Body.style.display = 'block';
            parentHeight = Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(p_Parent).height;
        }
        if (p_Continuous) {
            window.setTimeout(function() {
                Coveo.CNL.Web.Scripts.DOMUtilities._consumeRemainingHeightInternal(p_Parent, p_Header, p_Body, p_Footer, parentHeight, headerHeight, footerHeight, p_Continuous);
            }, 500);
        }
    }
    else {
    }
}
Coveo.CNL.Web.Scripts.DOMUtilities._consumeHeightToWindowBottomInternal = function Coveo_CNL_Web_Scripts_DOMUtilities$_consumeHeightToWindowBottomInternal(p_Element, p_PreviousDocumentHeight, p_PreviousElementTop, p_Continuous) {
    /// <summary>
    /// Arranges for a <see cref="T:System.Html.Element" /> to consume the remaining
    /// visible height in the browser window.
    /// </summary>
    /// <param name="p_Element" type="Object" domElement="true">
    /// The <see cref="T:System.Html.Element" /> to resize.
    /// </param>
    /// <param name="p_PreviousDocumentHeight" type="Number" integer="true">
    /// The previous height of the document.
    /// </param>
    /// <param name="p_PreviousElementTop" type="Number" integer="true">
    /// The previous top location of the element.
    /// </param>
    /// <param name="p_Continuous" type="Boolean">
    /// Whether to continuously update the height.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Element);
    if (p_Element.parentNode != null) {
        var documentHeight = document.documentElement.clientHeight;
        var elementTop = Coveo.CNL.Web.Scripts.DOMUtilities.getElementPosition(p_Element).top;
        if (documentHeight !== p_PreviousDocumentHeight || elementTop !== p_PreviousElementTop) {
            p_Element.style.height = Math.max(documentHeight - elementTop, 0) + 'px';
        }
        for (var i = 0; i < document.documentElement.childNodes.length; i++) {
            if (document.documentElement.childNodes[i].tagName === 'HTML') {
                document.documentElement.childNodes[i].style.overflow = 'hidden';
                break;
            }
        }
        document.documentElement.style.overflow = 'hidden';
        if (p_Continuous) {
            window.setTimeout(function() {
                Coveo.CNL.Web.Scripts.DOMUtilities._consumeHeightToWindowBottomInternal(p_Element, documentHeight, elementTop, p_Continuous);
            }, 500);
        }
    }
    else {
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.MarshalUtilities

Coveo.CNL.Web.Scripts.MarshalUtilities = function Coveo_CNL_Web_Scripts_MarshalUtilities() {
    /// <summary>
    /// Provides various utilities for marshalling data with the server.
    /// </summary>
}
Coveo.CNL.Web.Scripts.MarshalUtilities.marshalValue = function Coveo_CNL_Web_Scripts_MarshalUtilities$marshalValue(p_Value) {
    /// <summary>
    /// Marshals a value to send it to the server.
    /// </summary>
    /// <param name="p_Value" type="Object">
    /// The value to marshal.
    /// </param>
    /// <returns type="String"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Value);
    return p_Value.toString();
}
Coveo.CNL.Web.Scripts.MarshalUtilities.unmarshalValue = function Coveo_CNL_Web_Scripts_MarshalUtilities$unmarshalValue(p_Type, p_Value) {
    /// <summary>
    /// Unmarshals a value sent by the server.
    /// </summary>
    /// <param name="p_Type" type="String">
    /// The type of the value to unmarshall.
    /// </param>
    /// <param name="p_Value" type="String">
    /// The string representation of the value.
    /// </param>
    /// <returns type="Object"></returns>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Type);
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_Value);
    var value;
    switch (p_Type.toLowerCase()) {
        case 'string':
            value = p_Value;
            break;
        case 'int32':
            value = parseInt(p_Value);
            break;
        case 'double':
            value = parseFloat(p_Value);
            break;
        case 'boolean':
            value = Boolean.parse(p_Value);
            break;
        case 'none':
            value = null;
            break;
        default:
            Coveo.CNL.Web.Scripts.CNLAssert.fail();
            value = null;
            break;
    }
    return value;
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.CNLAssert

Coveo.CNL.Web.Scripts.CNLAssert = function Coveo_CNL_Web_Scripts_CNLAssert() {
    /// <summary>
    /// Provides various assertions for client code.
    /// </summary>
}
Coveo.CNL.Web.Scripts.CNLAssert.fail = function Coveo_CNL_Web_Scripts_CNLAssert$fail() {
    /// <summary>
    /// Call when an assertion fails.
    /// </summary>
}
Coveo.CNL.Web.Scripts.CNLAssert.failWithMessage = function Coveo_CNL_Web_Scripts_CNLAssert$failWithMessage(p_Message) {
    /// <summary>
    /// Call when an assertion fails.
    /// </summary>
    /// <param name="p_Message" type="String">
    /// The message to display with the assert.
    /// </param>
}
Coveo.CNL.Web.Scripts.CNLAssert.check = function Coveo_CNL_Web_Scripts_CNLAssert$check(p_Condition) {
    /// <summary>
    /// Checks that a condition is true.
    /// </summary>
    /// <param name="p_Condition" type="Boolean">
    /// The condition to check.
    /// </param>
    if (!p_Condition) {
        Coveo.CNL.Web.Scripts.CNLAssert.fail();
    }
}
Coveo.CNL.Web.Scripts.CNLAssert.notNull = function Coveo_CNL_Web_Scripts_CNLAssert$notNull(p_Object) {
    /// <summary>
    /// Asserts that an object is not null.
    /// </summary>
    /// <param name="p_Object" type="Object">
    /// The object to check.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.check(!Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(p_Object));
}
Coveo.CNL.Web.Scripts.CNLAssert.isNull = function Coveo_CNL_Web_Scripts_CNLAssert$isNull(p_Object) {
    /// <summary>
    /// Asserts that an object is null.
    /// </summary>
    /// <param name="p_Object" type="Object">
    /// The object to check.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.check(Coveo.CNL.Web.Scripts.Utilities.isNullOrUndefined(p_Object));
}
Coveo.CNL.Web.Scripts.CNLAssert.notEmpty = function Coveo_CNL_Web_Scripts_CNLAssert$notEmpty(p_String) {
    /// <summary>
    /// Asserts that a string is not null and not empty.
    /// </summary>
    /// <param name="p_String" type="String">
    /// The string to check.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_String);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_String !== '');
}
Coveo.CNL.Web.Scripts.CNLAssert.isEmpty = function Coveo_CNL_Web_Scripts_CNLAssert$isEmpty(p_String) {
    /// <summary>
    /// Asserts that a string is not null and empty.
    /// </summary>
    /// <param name="p_String" type="String">
    /// The string to check.
    /// </param>
    Coveo.CNL.Web.Scripts.CNLAssert.notNull(p_String);
    Coveo.CNL.Web.Scripts.CNLAssert.check(p_String === '');
}


Type.registerNamespace('Coveo.CNL.Web.Scripts.Misc');

////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript

Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript = function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript() {
    /// <summary>
    /// Client side code for a textbox control who postbacks everytime the user stops typing.
    /// </summary>
    /// <field name="_postbacK_DELAY$1" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_m_KeyDownEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_KeyUpEventHandler$1" type="ElementEventHandler">
    /// </field>
    /// <field name="m_TextBox" type="Object" domElement="true">
    /// </field>
    /// <field name="m_PostbackTimeout" type="Coveo.CNL.Web.Scripts.Timeout">
    /// </field>
    Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript.prototype = {
    _m_KeyDownEventHandler$1: null,
    _m_KeyUpEventHandler$1: null,
    m_TextBox: null,
    m_PostbackTimeout: null,
    
    initialize: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$initialize() {
        Coveo.CNL.Web.Scripts.CNLAssert.notNull(this.m_TextBox);
        this._m_KeyDownEventHandler$1 = ss.Delegate.create(this, this._textBox_KeyDown$1);
        this._m_KeyUpEventHandler$1 = ss.Delegate.create(this, this._textBox_KeyUp$1);
        this.m_TextBox.attachEvent('onkeydown', this._m_KeyDownEventHandler$1);
        this.m_TextBox.attachEvent('onkeyup', this._m_KeyUpEventHandler$1);
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$tearDown() {
        if (this._m_KeyDownEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onkeydown', this._m_KeyDownEventHandler$1);
            this._m_KeyDownEventHandler$1 = null;
        }
        if (this._m_KeyUpEventHandler$1 != null) {
            this.m_TextBox.detachEvent('onkeyup', this._m_KeyUpEventHandler$1);
            this._m_KeyUpEventHandler$1 = null;
        }
        this.m_TextBox = null;
    },
    
    fireTextChanged: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$fireTextChanged(p_Text, p_Callback) {
        /// <param name="p_Text" type="String">
        /// </param>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// </param>
    },
    
    fireEscapePressed: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$fireEscapePressed() {
    },
    
    _textBox_KeyDown$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_textBox_KeyDown$1() {
        if (window.event.keyCode === 27) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            this._cancelPendingTimeout$1();
            this.fireEscapePressed();
        }
    },
    
    _textBox_KeyUp$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_textBox_KeyUp$1() {
        var keyCode = window.event.keyCode;
        if (keyCode === 13 || keyCode === 9) {
            this._cancelPendingTimeout$1();
            this._startTextChanged$1();
        }
        else if (keyCode === 16 || keyCode === 17 || keyCode === 19 || keyCode === 20 || keyCode === 27 || keyCode === 33 || keyCode === 34 || keyCode === 35 || keyCode === 36 || keyCode === 144 || keyCode === 145) {
        }
        else if (keyCode >= 37 && keyCode <= 40) {
        }
        else if (keyCode >= 112 && keyCode <= 123) {
        }
        else {
            this._cancelPendingTimeout$1();
            this._scheduleTextChanged$1();
        }
    },
    
    _scheduleTextChanged$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_scheduleTextChanged$1() {
        /// <summary>
        /// Schedules a TextChanged event.
        /// </summary>
        Coveo.CNL.Web.Scripts.CNLAssert.isNull(this.m_PostbackTimeout);
        this.m_PostbackTimeout = new Coveo.CNL.Web.Scripts.Timeout(ss.Delegate.create(this, this._startTextChanged$1), Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript._postbacK_DELAY$1);
    },
    
    _cancelPendingTimeout$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_cancelPendingTimeout$1() {
        /// <summary>
        /// Cancels any pending TextChanged event.
        /// </summary>
        if (this.m_PostbackTimeout != null) {
            this.m_PostbackTimeout.cancel();
            this.m_PostbackTimeout = null;
        }
    },
    
    _startTextChanged$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_startTextChanged$1() {
        /// <summary>
        /// Launches a TextChanged event on the server.
        /// </summary>
        this.m_PostbackTimeout = null;
        if (this.m_TextBox != null) {
            this.fireTextChanged(this.m_TextBox.value, ss.Delegate.create(this, this._textChangedCallback$1));
        }
    },
    
    _textChangedCallback$1: function Coveo_CNL_Web_Scripts_Misc_TextChangedEventScript$_textChangedCallback$1(p_Return) {
        /// <summary>
        /// Callback for when the server has handled the TextChanged event.
        /// </summary>
        /// <param name="p_Return" type="Object">
        /// The return of the call to the server.
        /// </param>
    }
}


////////////////////////////////////////////////////////////////////////////////
// Coveo.CNL.Web.Scripts.Misc.ToolTipScript

Coveo.CNL.Web.Scripts.Misc.ToolTipScript = function Coveo_CNL_Web_Scripts_Misc_ToolTipScript() {
    /// <summary>
    /// Client side code for the Tooltip control.
    /// </summary>
    /// <field name="m_HotSpot" type="Object" domElement="true">
    /// </field>
    /// <field name="m_PopupParent" type="Object" domElement="true">
    /// </field>
    /// <field name="m_Position" type="Coveo.CNL.Web.Scripts.PositionEnum">
    /// </field>
    /// <field name="m_MaxWidth" type="Number" integer="true">
    /// </field>
    /// <field name="m_ShowOnHover" type="Boolean">
    /// </field>
    /// <field name="m_ShowDelay" type="Number" integer="true">
    /// </field>
    /// <field name="m_HideDelay" type="Number" integer="true">
    /// </field>
    /// <field name="m_ShowOnClick" type="Boolean">
    /// </field>
    /// <field name="m_HideOnClick" type="Boolean">
    /// </field>
    /// <field name="m_FadeIn" type="Boolean">
    /// </field>
    /// <field name="m_HotSpotFocusStyle" type="String">
    /// </field>
    /// <field name="m_StyleBeforeFocus" type="String">
    /// </field>
    /// <field name="m_MakeTabable" type="Boolean">
    /// </field>
    /// <field name="_m_OnDwellEvent$2" type="Coveo.CNL.Web.Scripts.OnDwellEvent">
    /// </field>
    /// <field name="_m_OnLeaveManyEvent$2" type="Coveo.CNL.Web.Scripts.OnLeaveManyEvent">
    /// </field>
    /// <field name="_m_Popup$2" type="Object" domElement="true">
    /// </field>
    /// <field name="_m_PostShowProcesses$2" type="Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager">
    /// </field>
    /// <field name="_m_ToolTipClickDomEventHandler$2" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_HotSpotOnFocusEventHandler$2" type="ElementEventHandler">
    /// </field>
    /// <field name="_m_HotSpotOnBlurEventHandler$2" type="ElementEventHandler">
    /// </field>
    Coveo.CNL.Web.Scripts.Misc.ToolTipScript.initializeBase(this);
}
Coveo.CNL.Web.Scripts.Misc.ToolTipScript.prototype = {
    m_HotSpot: null,
    m_PopupParent: null,
    m_Position: 0,
    m_MaxWidth: 0,
    m_ShowOnHover: false,
    m_ShowDelay: 0,
    m_HideDelay: 0,
    m_ShowOnClick: false,
    m_HideOnClick: false,
    m_FadeIn: false,
    m_HotSpotFocusStyle: null,
    m_StyleBeforeFocus: null,
    m_MakeTabable: false,
    _m_OnDwellEvent$2: null,
    _m_OnLeaveManyEvent$2: null,
    _m_Popup$2: null,
    _m_PostShowProcesses$2: null,
    _m_ToolTipClickDomEventHandler$2: null,
    _m_HotSpotOnFocusEventHandler$2: null,
    _m_HotSpotOnBlurEventHandler$2: null,
    
    initialize: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$initialize() {
        this._registerProperEvents$2();
        if (this._hasHotSpotFocusStyle$2()) {
            this._m_HotSpotOnFocusEventHandler$2 = ss.Delegate.create(this, this._hotSpot_OnFocus$2);
            this._m_HotSpotOnBlurEventHandler$2 = ss.Delegate.create(this, this._hotSpot_OnBlur$2);
            this.m_HotSpot.attachEvent('onfocus', this._m_HotSpotOnFocusEventHandler$2);
            this.m_HotSpot.attachEvent('onblur', this._m_HotSpotOnBlurEventHandler$2);
        }
    },
    
    tearDown: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$tearDown() {
        this._getRidOfEverything$2();
        if (this._m_HotSpotOnFocusEventHandler$2 != null) {
            this.m_HotSpot.detachEvent('onfocus', this._m_HotSpotOnFocusEventHandler$2);
            this._m_HotSpotOnFocusEventHandler$2 = null;
        }
        if (this._m_HotSpotOnBlurEventHandler$2 != null) {
            this.m_HotSpot.detachEvent('onblur', this._m_HotSpotOnBlurEventHandler$2);
            this._m_HotSpotOnBlurEventHandler$2 = null;
        }
    },
    
    fetchToolTipContent: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$fetchToolTipContent(p_Callback) {
        /// <summary>
        /// Placeholder for the server call that fetches the tooltip.
        /// </summary>
        /// <param name="p_Callback" type="Coveo.CNL.Web.Scripts.Ajax.PostBackCallback">
        /// </param>
        Coveo.CNL.Web.Scripts.CNLAssert.fail();
    },
    
    _showToolTipIfNotVisible$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_showToolTipIfNotVisible$2() {
        /// <summary>
        /// Begins showing the tooltip.
        /// </summary>
        if (this._m_Popup$2 == null) {
            if (Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current() != null) {
                Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().blockTimer();
            }
            this.fetchToolTipContent(ss.Delegate.create(this, this._fetchToolTipCallback$2));
        }
    },
    
    _hideToolTipIfVisible$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hideToolTipIfVisible$2() {
        /// <summary>
        /// Hides the tooltip if it is visible.
        /// </summary>
        if (this._m_Popup$2 != null) {
            this._getRidOfEverything$2();
            this._m_Popup$2.parentNode.removeChild(this._m_Popup$2);
            this._m_Popup$2 = null;
            this._registerProperEvents$2();
            if (Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current() != null) {
                Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.get_current().unblockTimer();
            }
        }
    },
    
    _fetchToolTipCallback$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_fetchToolTipCallback$2(p_Return) {
        /// <summary>
        /// Handles the return value of the call to fetch the tooltip content.
        /// </summary>
        /// <param name="p_Return" type="Object">
        /// </param>
        this._getRidOfEverything$2();
        var content = p_Return;
        this._m_Popup$2 = document.createElement('div');
        this._m_Popup$2.appendChild(content);
        this._m_Popup$2.style.position = 'absolute';
        this._m_Popup$2.style.zIndex = Coveo.CNL.Web.Scripts.DOMUtilities.getNextHighestZindex();
        if (this.m_FadeIn) {
            Coveo.CNL.Web.Scripts.DOMUtilities.setOpacity(this._m_Popup$2, 0);
        }
        this.m_PopupParent.appendChild(this._m_Popup$2);
        if (this.m_MaxWidth !== 0 && Coveo.CNL.Web.Scripts.DOMUtilities.getElementSize(this._m_Popup$2).width > this.m_MaxWidth) {
            this._m_Popup$2.style.width = this.m_MaxWidth + 'px';
        }
        Coveo.CNL.Web.Scripts.DOMUtilities.positionElement(this._m_Popup$2, this.m_HotSpot, this.m_Position);
        this._registerProperEvents$2();
        if (this.m_FadeIn) {
            this._m_PostShowProcesses$2 = new Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager();
            this._m_PostShowProcesses$2.add(new Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect(this._m_Popup$2));
            this._m_PostShowProcesses$2.startAll(null);
        }
    },
    
    _registerProperEvents$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_registerProperEvents$2() {
        /// <summary>
        /// Registers the events depending on the state.
        /// </summary>
        if (this._m_Popup$2 == null) {
            if (this.m_ShowOnHover) {
                this._m_OnDwellEvent$2 = new Coveo.CNL.Web.Scripts.OnDwellEvent(this.m_HotSpot, this.m_ShowDelay, ss.Delegate.create(this, this._hotSpot_OnDwell$2));
            }
            if (this.m_ShowOnClick) {
                Coveo.CNL.Web.Scripts.Misc.ToolTipScript.callBaseMethod(this, 'initialize');
                this.addOnClickAttribute(this.m_HotSpot, ss.Delegate.create(this, this._hotSpot_OnClick$2), this.m_MakeTabable);
            }
        }
        else {
            if (this.m_ShowOnHover) {
                this._m_OnLeaveManyEvent$2 = new Coveo.CNL.Web.Scripts.OnLeaveManyEvent([ this.m_HotSpot, this.m_PopupParent, this._m_Popup$2 ], this.m_HideDelay, ss.Delegate.create(this, this._toolTip_OnLeave$2));
            }
            if (this.m_HideOnClick) {
                this._m_ToolTipClickDomEventHandler$2 = ss.Delegate.create(this, this._toolTip_OnClick$2);
                this._m_Popup$2.attachEvent('onclick', this._m_ToolTipClickDomEventHandler$2);
            }
            if (this.m_ShowOnClick) {
                Coveo.CNL.Web.Scripts.Misc.ToolTipScript.callBaseMethod(this, 'initialize');
                this.addOnClickAttribute(this.m_HotSpot, ss.Delegate.create(this, this._toolTip_OnClick$2), this.m_MakeTabable);
            }
        }
    },
    
    _getRidOfEverything$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_getRidOfEverything$2() {
        /// <summary>
        /// Unregisters all events, stops all async processes, etc.
        /// </summary>
        if (this._m_PostShowProcesses$2 != null) {
            this._m_PostShowProcesses$2.terminateAll();
            this._m_PostShowProcesses$2 = null;
        }
        if (this._m_OnDwellEvent$2 != null) {
            this._m_OnDwellEvent$2.dispose();
            this._m_OnDwellEvent$2 = null;
        }
        if (this._m_OnLeaveManyEvent$2 != null) {
            this._m_OnLeaveManyEvent$2.dispose();
            this._m_OnLeaveManyEvent$2 = null;
        }
        if (this.m_ShowOnClick) {
            Coveo.CNL.Web.Scripts.Misc.ToolTipScript.callBaseMethod(this, 'tearDown');
        }
        if (this._m_Popup$2 != null && this.m_HideOnClick) {
            if (this._m_ToolTipClickDomEventHandler$2 != null) {
                this._m_Popup$2.detachEvent('onclick', this._m_ToolTipClickDomEventHandler$2);
                this._m_ToolTipClickDomEventHandler$2 = null;
            }
        }
    },
    
    _hasHotSpotFocusStyle$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hasHotSpotFocusStyle$2() {
        /// <summary>
        /// Whether a focus style has been specified.
        /// </summary>
        /// <returns type="Boolean"></returns>
        return this.m_HotSpotFocusStyle != null && this.m_HotSpotFocusStyle !== '';
    },
    
    _hotSpot_OnDwell$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hotSpot_OnDwell$2() {
        this._showToolTipIfNotVisible$2();
    },
    
    _hotSpot_OnClick$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hotSpot_OnClick$2() {
        this._showToolTipIfNotVisible$2();
    },
    
    _hotSpot_OnFocus$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hotSpot_OnFocus$2() {
        this.m_StyleBeforeFocus = this.m_HotSpot.style.cssText;
        this.m_HotSpot.style.cssText += '; ' + this.m_HotSpotFocusStyle;
    },
    
    _hotSpot_OnBlur$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_hotSpot_OnBlur$2() {
        this.m_HotSpot.style.cssText = this.m_StyleBeforeFocus;
    },
    
    _toolTip_OnLeave$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_toolTip_OnLeave$2() {
        this._hideToolTipIfVisible$2();
    },
    
    _toolTip_OnClick$2: function Coveo_CNL_Web_Scripts_Misc_ToolTipScript$_toolTip_OnClick$2() {
        this._hideToolTipIfVisible$2();
    }
}


Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem.registerClass('Coveo.CNL.Web.Scripts.BetterControls.AutoCompleteItem', Object);
Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript.registerClass('Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript');
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript.registerClass('Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.BetterControls.TabControlScript.registerClass('Coveo.CNL.Web.Scripts.BetterControls.TabControlScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript.registerClass('Coveo.CNL.Web.Scripts.BetterControls.BetterButtonScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript.registerClass('Coveo.CNL.Web.Scripts.BetterControls.BetterLinkButtonScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Widgets.WidgetScript.registerClass('Coveo.CNL.Web.Scripts.Widgets.WidgetScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript.registerClass('Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess.registerClass('Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess');
Coveo.CNL.Web.Scripts.Ajax.ControlFlipper.registerClass('Coveo.CNL.Web.Scripts.Ajax.ControlFlipper', null, Coveo.CNL.Web.Scripts.Ajax.IContentFlipper);
Coveo.CNL.Web.Scripts.Ajax.TransitionEffect.registerClass('Coveo.CNL.Web.Scripts.Ajax.TransitionEffect', Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess);
Coveo.CNL.Web.Scripts.Ajax.CollapseTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.CollapseTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.AdjustTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.AdjustTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.Console.registerClass('Coveo.CNL.Web.Scripts.Ajax.Console');
Coveo.CNL.Web.Scripts.Ajax.Feedback.registerClass('Coveo.CNL.Web.Scripts.Ajax.Feedback', Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess);
Coveo.CNL.Web.Scripts.Ajax.BlankFeedback.registerClass('Coveo.CNL.Web.Scripts.Ajax.BlankFeedback', Coveo.CNL.Web.Scripts.Ajax.Feedback);
Coveo.CNL.Web.Scripts.Ajax.Bootstrap.registerClass('Coveo.CNL.Web.Scripts.Ajax.Bootstrap');
Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript.registerClass('Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript', Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess);
Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript.registerClass('Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Ajax.DropDownContentController.registerClass('Coveo.CNL.Web.Scripts.Ajax.DropDownContentController', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler.registerClass('Coveo.CNL.Web.Scripts.Ajax.DropDownMenuControler', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript.registerClass('Coveo.CNL.Web.Scripts.Ajax.PostbackOptionsScript');
Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack.registerClass('Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack', Coveo.CNL.Web.Scripts.Ajax.Feedback);
Coveo.CNL.Web.Scripts.Ajax.Profiler.registerClass('Coveo.CNL.Web.Scripts.Ajax.Profiler');
Coveo.CNL.Web.Scripts.Ajax.PercentTimer.registerClass('Coveo.CNL.Web.Scripts.Ajax.PercentTimer');
Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger.registerClass('Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.IdMappings.registerClass('Coveo.CNL.Web.Scripts.Ajax.IdMappings');
Coveo.CNL.Web.Scripts.Ajax.FadeInTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.FadeInTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect.registerClass('Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper.registerClass('Coveo.CNL.Web.Scripts.Ajax.ScriptLoaderWrapper', Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcess);
Coveo.CNL.Web.Scripts.Ajax.ModalBox.registerClass('Coveo.CNL.Web.Scripts.Ajax.ModalBox');
Coveo.CNL.Web.Scripts.Ajax.FlipTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.FlipTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager.registerClass('Coveo.CNL.Web.Scripts.Ajax.AsynchronousProcessManager');
Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.HExpandTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.HExpandTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.ExpandTransition.registerClass('Coveo.CNL.Web.Scripts.Ajax.ExpandTransition', Coveo.CNL.Web.Scripts.Ajax.TransitionEffect);
Coveo.CNL.Web.Scripts.Ajax.RegionFlipper.registerClass('Coveo.CNL.Web.Scripts.Ajax.RegionFlipper', null, Coveo.CNL.Web.Scripts.Ajax.IContentFlipper);
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.registerClass('Coveo.CNL.Web.Scripts.Ajax.PartialPostBack');
Coveo.CNL.Web.Scripts.Ajax._feedbackInfo.registerClass('Coveo.CNL.Web.Scripts.Ajax._feedbackInfo');
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript.registerClass('Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript');
Coveo.CNL.Web.Scripts.CookieUtilities.registerClass('Coveo.CNL.Web.Scripts.CookieUtilities');
Coveo.CNL.Web.Scripts.MouseCapture.registerClass('Coveo.CNL.Web.Scripts.MouseCapture');
Coveo.CNL.Web.Scripts.MulticastEventHandler.registerClass('Coveo.CNL.Web.Scripts.MulticastEventHandler');
Coveo.CNL.Web.Scripts.OnClickElsewhereEvent.registerClass('Coveo.CNL.Web.Scripts.OnClickElsewhereEvent');
Coveo.CNL.Web.Scripts.ScriptLoader.registerClass('Coveo.CNL.Web.Scripts.ScriptLoader', null, ss.IDisposable);
Coveo.CNL.Web.Scripts.StringDeserializer.registerClass('Coveo.CNL.Web.Scripts.StringDeserializer');
Coveo.CNL.Web.Scripts.Utilities.registerClass('Coveo.CNL.Web.Scripts.Utilities');
Coveo.CNL.Web.Scripts.TransferMargin.registerClass('Coveo.CNL.Web.Scripts.TransferMargin');
Coveo.CNL.Web.Scripts.Timeout.registerClass('Coveo.CNL.Web.Scripts.Timeout');
Coveo.CNL.Web.Scripts.OnLeaveManyEvent.registerClass('Coveo.CNL.Web.Scripts.OnLeaveManyEvent');
Coveo.CNL.Web.Scripts.OnDwellEvent.registerClass('Coveo.CNL.Web.Scripts.OnDwellEvent');
Coveo.CNL.Web.Scripts.ElementPosition.registerClass('Coveo.CNL.Web.Scripts.ElementPosition');
Coveo.CNL.Web.Scripts.ElementBounds.registerClass('Coveo.CNL.Web.Scripts.ElementBounds');
Coveo.CNL.Web.Scripts.BrowserHelper.registerClass('Coveo.CNL.Web.Scripts.BrowserHelper');
Coveo.CNL.Web.Scripts.ElementSize.registerClass('Coveo.CNL.Web.Scripts.ElementSize');
Coveo.CNL.Web.Scripts.DOMUtilities.registerClass('Coveo.CNL.Web.Scripts.DOMUtilities');
Coveo.CNL.Web.Scripts.MarshalUtilities.registerClass('Coveo.CNL.Web.Scripts.MarshalUtilities');
Coveo.CNL.Web.Scripts.CNLAssert.registerClass('Coveo.CNL.Web.Scripts.CNLAssert');
Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript.registerClass('Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript', Coveo.CNL.Web.Scripts.Ajax.AjaxObjectScript);
Coveo.CNL.Web.Scripts.Misc.ToolTipScript.registerClass('Coveo.CNL.Web.Scripts.Misc.ToolTipScript', Coveo.CNL.Web.Scripts.Ajax.AjaxTabableObjectScript);
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._m_DebugMode$1 = false;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_BACKSPACE$1 = 8;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_TAB$1 = 9;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_ENTER$1 = 13;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_ESCAPE$1 = 27;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_UP$1 = 38;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_RIGHT$1 = 39;
Coveo.CNL.Web.Scripts.BetterControls.BetterTextBoxScript._jS_DOWN$1 = 40;
Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._accepT_ALL_CLASS$1 = 'coveo_widget_zone';
Coveo.CNL.Web.Scripts.Widgets.WidgetZoneScript._s_Zones$1 = {};
Coveo.CNL.Web.Scripts.Ajax.CollapseTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.AdjustTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.Console._s_Console = null;
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._forwarD_QUERY_STRING_OPTION = 'ForwardQueryString';
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._caN_ADD_HTTP_HEADERS_OPTION = 'CanAddHttpHeaders';
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._displaY_ERRORS_IN_WHOLE_PAGE_OPTION = 'DisplayErrorsInWholePage';
Coveo.CNL.Web.Scripts.Ajax.Bootstrap._s_Request = null;
Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript._initiaL_DELAY$1 = 500;
Coveo.CNL.Web.Scripts.Ajax.AjaxProgressScript._polL_DELAY$1 = 500;
Coveo.CNL.Web.Scripts.Ajax.ProcessingFeedBack._framE_DELAY$2 = 750;
Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Current = null;
Coveo.CNL.Web.Scripts.Ajax.Profiler._s_Results = null;
Coveo.CNL.Web.Scripts.Ajax.Profiler._s_CloseLink = null;
Coveo.CNL.Web.Scripts.Ajax.UpdateDebugger._displaY_DELAY$2 = 3000;
Coveo.CNL.Web.Scripts.Ajax.FlipFadeTransition._framE_DELAY$2 = 25;
Coveo.CNL.Web.Scripts.Ajax.Feedback._initiaL_DELAY$1 = 25;
Coveo.CNL.Web.Scripts.Ajax.FadeInTransition._framE_DELAY$2 = 20;
Coveo.CNL.Web.Scripts.Ajax.GradualFadeInEffect._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.FadeFlipTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.HAdjustTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.HCollapseTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.HExpandTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.ExpandTransition._framE_DELAY$2 = 7;
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.partiaL_POSTBACK_MARKER = 'Coveo-Partial-Postback';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.bootstraP_MARKER = 'Coveo-Bootstrap';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.historY_STATE_MARKER = 'Coveo-HState';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.nO_CONTROL_DATA_MARKER = 'Coveo-No-Control-Data';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_TARGET = '__EVENTTARGET';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_EVENT_ARGUMENT = '__EVENTARGUMENT';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE = '__VIEWSTATE';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_VIEW_STATE_ENCRYPTED = '__VIEWSTATEENCRYPTED';
Coveo.CNL.Web.Scripts.Ajax.PartialPostBack.forM_REQUEST_DIGEST = '__REQUESTDIGEST';
Coveo.CNL.Web.Scripts.Ajax.AjaxManagerScript._s_Instance = null;
Coveo.CNL.Web.Scripts.StringDeserializer.SEPARATOR = '!';
Coveo.CNL.Web.Scripts.StringDeserializer.escapE_CHARACTER = '~';
Coveo.CNL.Web.Scripts.StringDeserializer.versioN_MARKER = '_d';
Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyCounter = 0;
Coveo.CNL.Web.Scripts.DOMUtilities._s_BusyMarker = null;
Coveo.CNL.Web.Scripts.Misc.TextChangedEventScript._postbacK_DELAY$1 = 250;
;
};
_coveoDefineJQuery();