// Name:        MicrosoftAjax.debug.js

// Assembly:    System.Web.Extensions

// Version:     3.5.0.0

// FileVersion: 3.5.30729.196

//-----------------------------------------------------------------------

// Copyright (C) Microsoft Corporation. All rights reserved.

//-----------------------------------------------------------------------

// MicrosoftAjax.js

// Microsoft AJAX Framework.

 

Function.__typeName = 'Function';

Function.__class = true;

Function.createCallback = function Function$createCallback(method, context) {

    /// <summary locid="M:J#Function.createCallback" />

    /// <param name="method" type="Function"></param>

    /// <param name="context" mayBeNull="true"></param>

    /// <returns type="Function"></returns>

    var e = Function._validateParams(arguments, [

        {name: "method", type: Function},

        {name: "context", mayBeNull: true}

    ]);

    if (e) throw e;

    return function() {

        var l = arguments.length;

        if (l > 0) {

            var args = [];

            for (var i = 0; i < l; i++) {

                args[i] = arguments[i];

            }

            args[l] = context;

            return method.apply(this, args);

        }

        return method.call(this, context);

    }

}

Function.createDelegate = function Function$createDelegate(instance, method) {

    /// <summary locid="M:J#Function.createDelegate" />

    /// <param name="instance" mayBeNull="true"></param>

    /// <param name="method" type="Function"></param>

    /// <returns type="Function"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance", mayBeNull: true},

        {name: "method", type: Function}

    ]);

    if (e) throw e;

    return function() {

        return method.apply(instance, arguments);

    }

}

Function.emptyFunction = Function.emptyMethod = function Function$emptyMethod() {

    /// <summary locid="M:J#Function.emptyMethod" />

    if (arguments.length !== 0) throw Error.parameterCount();

}

Function._validateParams = function Function$_validateParams(params, expectedParams) {

    var e;

    e = Function._validateParameterCount(params, expectedParams);

    if (e) {

        e.popStackFrame();

        return e;

    }

    for (var i=0; i < params.length; i++) {

        var expectedParam = expectedParams[Math.min(i, expectedParams.length - 1)];

        var paramName = expectedParam.name;

        if (expectedParam.parameterArray) {

            paramName += "[" + (i - expectedParams.length + 1) + "]";

        }

        e = Function._validateParameter(params[i], expectedParam, paramName);

        if (e) {

            e.popStackFrame();

            return e;

        }

    }

    return null;

}

Function._validateParameterCount = function Function$_validateParameterCount(params, expectedParams) {

    var maxParams = expectedParams.length;

    var minParams = 0;

    for (var i=0; i < expectedParams.length; i++) {

        if (expectedParams[i].parameterArray) {

            maxParams = Number.MAX_VALUE;

        }

        else if (!expectedParams[i].optional) {

            minParams++;

        }

    }

    if (params.length < minParams || params.length > maxParams) {

        var e = Error.parameterCount();

        e.popStackFrame();

        return e;

    }

    return null;

}

Function._validateParameter = function Function$_validateParameter(param, expectedParam, paramName) {

    var e;

    var expectedType = expectedParam.type;

    var expectedInteger = !!expectedParam.integer;

    var expectedDomElement = !!expectedParam.domElement;

    var mayBeNull = !!expectedParam.mayBeNull;

    e = Function._validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName);

    if (e) {

        e.popStackFrame();

        return e;

    }

    var expectedElementType = expectedParam.elementType;

    var elementMayBeNull = !!expectedParam.elementMayBeNull;

    if (expectedType === Array && typeof(param) !== "undefined" && param !== null &&

        (expectedElementType || !elementMayBeNull)) {

        var expectedElementInteger = !!expectedParam.elementInteger;

        var expectedElementDomElement = !!expectedParam.elementDomElement;

        for (var i=0; i < param.length; i++) {

            var elem = param[i];

            e = Function._validateParameterType(elem, expectedElementType,

                expectedElementInteger, expectedElementDomElement, elementMayBeNull,

                paramName + "[" + i + "]");

            if (e) {

                e.popStackFrame();

                return e;

            }

        }

    }

    return null;

}

Function._validateParameterType = function Function$_validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName) {

    var e;

    if (typeof(param) === "undefined") {

        if (mayBeNull) {

            return null;

        }

        else {

            e = Error.argumentUndefined(paramName);

            e.popStackFrame();

            return e;

        }

    }

    if (param === null) {

        if (mayBeNull) {

            return null;

        }

        else {

            e = Error.argumentNull(paramName);

            e.popStackFrame();

            return e;

        }

    }

    if (expectedType && expectedType.__enum) {

        if (typeof(param) !== 'number') {

            e = Error.argumentType(paramName, Object.getType(param), expectedType);

            e.popStackFrame();

            return e;

        }

        if ((param % 1) === 0) {

            var values = expectedType.prototype;

            if (!expectedType.__flags || (param === 0)) {

                for (var i in values) {

                    if (values[i] === param) return null;

                }

            }

            else {

                var v = param;

                for (var i in values) {

                    var vali = values[i];

                    if (vali === 0) continue;

                    if ((vali & param) === vali) {

                        v -= vali;

                    }

                    if (v === 0) return null;

                }

            }

        }

        e = Error.argumentOutOfRange(paramName, param, String.format(Sys.Res.enumInvalidValue, param, expectedType.getName()));

        e.popStackFrame();

        return e;

    }

    if (expectedDomElement) {

        var val;

        if (typeof(param.nodeType) !== 'number') {

            var doc = param.ownerDocument || param.document || param;

            if (doc != param) {

                var w = doc.defaultView || doc.parentWindow;

                val = (w != param) && !(w.document && param.document && (w.document === param.document));

            }

            else {

                val = (typeof(doc.body) === 'undefined');

            }

        }

        else {

            val = (param.nodeType === 3);

        }

        if (val) {

            e = Error.argument(paramName, Sys.Res.argumentDomElement);

            e.popStackFrame();

            return e;

        }

    }

    if (expectedType && !expectedType.isInstanceOfType(param)) {

        e = Error.argumentType(paramName, Object.getType(param), expectedType);

        e.popStackFrame();

        return e;

    }

    if (expectedType === Number && expectedInteger) {

        if ((param % 1) !== 0) {

            e = Error.argumentOutOfRange(paramName, param, Sys.Res.argumentInteger);

            e.popStackFrame();

            return e;

        }

    }

    return null;

}

 

Error.__typeName = 'Error';

Error.__class = true;

Error.create = function Error$create(message, errorInfo) {

    /// <summary locid="M:J#Error.create" />

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="errorInfo" optional="true" mayBeNull="true"></param>

    /// <returns type="Error"></returns>

    var e = Function._validateParams(arguments, [

        {name: "message", type: String, mayBeNull: true, optional: true},

        {name: "errorInfo", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var e = new Error(message);

    e.message = message;

    if (errorInfo) {

        for (var v in errorInfo) {

            e[v] = errorInfo[v];

        }

    }

    e.popStackFrame();

    return e;

}

Error.argument = function Error$argument(paramName, message) {

    /// <summary locid="M:J#Error.argument" />

    /// <param name="paramName" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "paramName", type: String, mayBeNull: true, optional: true},

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ArgumentException: " + (message ? message : Sys.Res.argument);

    if (paramName) {

        displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

    }

    var e = Error.create(displayMessage, { name: "Sys.ArgumentException", paramName: paramName });

    e.popStackFrame();

    return e;

}

Error.argumentNull = function Error$argumentNull(paramName, message) {

    /// <summary locid="M:J#Error.argumentNull" />

    /// <param name="paramName" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "paramName", type: String, mayBeNull: true, optional: true},

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ArgumentNullException: " + (message ? message : Sys.Res.argumentNull);

    if (paramName) {

        displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

    }

    var e = Error.create(displayMessage, { name: "Sys.ArgumentNullException", paramName: paramName });

    e.popStackFrame();

    return e;

}

Error.argumentOutOfRange = function Error$argumentOutOfRange(paramName, actualValue, message) {

    /// <summary locid="M:J#Error.argumentOutOfRange" />

    /// <param name="paramName" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="actualValue" optional="true" mayBeNull="true"></param>

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "paramName", type: String, mayBeNull: true, optional: true},

        {name: "actualValue", mayBeNull: true, optional: true},

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ArgumentOutOfRangeException: " + (message ? message : Sys.Res.argumentOutOfRange);

    if (paramName) {

        displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

    }

    if (typeof(actualValue) !== "undefined" && actualValue !== null) {

        displayMessage += "\n" + String.format(Sys.Res.actualValue, actualValue);

    }

    var e = Error.create(displayMessage, {

        name: "Sys.ArgumentOutOfRangeException",

        paramName: paramName,

        actualValue: actualValue

    });

    e.popStackFrame();

    return e;

}

Error.argumentType = function Error$argumentType(paramName, actualType, expectedType, message) {

    /// <summary locid="M:J#Error.argumentType" />

    /// <param name="paramName" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="actualType" type="Type" optional="true" mayBeNull="true"></param>

    /// <param name="expectedType" type="Type" optional="true" mayBeNull="true"></param>

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "paramName", type: String, mayBeNull: true, optional: true},

        {name: "actualType", type: Type, mayBeNull: true, optional: true},

        {name: "expectedType", type: Type, mayBeNull: true, optional: true},

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ArgumentTypeException: ";

    if (message) {

        displayMessage += message;

    }

    else if (actualType && expectedType) {

        displayMessage +=

            String.format(Sys.Res.argumentTypeWithTypes, actualType.getName(), expectedType.getName());

    }

    else {

        displayMessage += Sys.Res.argumentType;

    }

    if (paramName) {

        displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

    }

    var e = Error.create(displayMessage, {

        name: "Sys.ArgumentTypeException",

        paramName: paramName,

        actualType: actualType,

        expectedType: expectedType

    });

    e.popStackFrame();

    return e;

}

Error.argumentUndefined = function Error$argumentUndefined(paramName, message) {

    /// <summary locid="M:J#Error.argumentUndefined" />

    /// <param name="paramName" type="String" optional="true" mayBeNull="true"></param>

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "paramName", type: String, mayBeNull: true, optional: true},

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ArgumentUndefinedException: " + (message ? message : Sys.Res.argumentUndefined);

    if (paramName) {

        displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

    }

    var e = Error.create(displayMessage, { name: "Sys.ArgumentUndefinedException", paramName: paramName });

    e.popStackFrame();

    return e;

}

Error.format = function Error$format(message) {

    /// <summary locid="M:J#Error.format" />

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.FormatException: " + (message ? message : Sys.Res.format);

    var e = Error.create(displayMessage, {name: 'Sys.FormatException'});

    e.popStackFrame();

    return e;

}

Error.invalidOperation = function Error$invalidOperation(message) {

    /// <summary locid="M:J#Error.invalidOperation" />

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.InvalidOperationException: " + (message ? message : Sys.Res.invalidOperation);

    var e = Error.create(displayMessage, {name: 'Sys.InvalidOperationException'});

    e.popStackFrame();

    return e;

}

Error.notImplemented = function Error$notImplemented(message) {

    /// <summary locid="M:J#Error.notImplemented" />

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.NotImplementedException: " + (message ? message : Sys.Res.notImplemented);

    var e = Error.create(displayMessage, {name: 'Sys.NotImplementedException'});

    e.popStackFrame();

    return e;

}

Error.parameterCount = function Error$parameterCount(message) {

    /// <summary locid="M:J#Error.parameterCount" />

    /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "message", type: String, mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var displayMessage = "Sys.ParameterCountException: " + (message ? message : Sys.Res.parameterCount);

    var e = Error.create(displayMessage, {name: 'Sys.ParameterCountException'});

    e.popStackFrame();

    return e;

}

Error.prototype.popStackFrame = function Error$popStackFrame() {

    /// <summary locid="M:J#checkParam" />

    if (arguments.length !== 0) throw Error.parameterCount();

    if (typeof(this.stack) === "undefined" || this.stack === null ||

        typeof(this.fileName) === "undefined" || this.fileName === null ||

        typeof(this.lineNumber) === "undefined" || this.lineNumber === null) {

        return;

    }

    var stackFrames = this.stack.split("\n");

    var currentFrame = stackFrames[0];

    var pattern = this.fileName + ":" + this.lineNumber;

    while(typeof(currentFrame) !== "undefined" &&

          currentFrame !== null &&

          currentFrame.indexOf(pattern) === -1) {

        stackFrames.shift();

        currentFrame = stackFrames[0];

    }

    var nextFrame = stackFrames[1];

    if (typeof(nextFrame) === "undefined" || nextFrame === null) {

        return;

    }

    var nextFrameParts = nextFrame.match(/@(.*):(\d+)$/);

    if (typeof(nextFrameParts) === "undefined" || nextFrameParts === null) {

        return;

    }

    this.fileName = nextFrameParts[1];

    this.lineNumber = parseInt(nextFrameParts[2]);

    stackFrames.shift();

    this.stack = stackFrames.join("\n");

}

 

Object.__typeName = 'Object';

Object.__class = true;

Object.getType = function Object$getType(instance) {

    /// <summary locid="M:J#Object.getType" />

    /// <param name="instance"></param>

    /// <returns type="Type"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance"}

    ]);

    if (e) throw e;

    var ctor = instance.constructor;

    if (!ctor || (typeof(ctor) !== "function") || !ctor.__typeName || (ctor.__typeName === 'Object')) {

        return Object;

    }

    return ctor;

}

Object.getTypeName = function Object$getTypeName(instance) {

    /// <summary locid="M:J#Object.getTypeName" />

    /// <param name="instance"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance"}

    ]);

    if (e) throw e;

    return Object.getType(instance).getName();

}

 

String.__typeName = 'String';

String.__class = true;

String.prototype.endsWith = function String$endsWith(suffix) {

    /// <summary locid="M:J#String.endsWith" />

    /// <param name="suffix" type="String"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "suffix", type: String}

    ]);

    if (e) throw e;

    return (this.substr(this.length - suffix.length) === suffix);

}

String.prototype.startsWith = function String$startsWith(prefix) {

    /// <summary locid="M:J#String.startsWith" />

    /// <param name="prefix" type="String"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "prefix", type: String}

    ]);

    if (e) throw e;

    return (this.substr(0, prefix.length) === prefix);

}

String.prototype.trim = function String$trim() {

    /// <summary locid="M:J#String.trim" />

    /// <returns type="String"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return this.replace(/^\s+|\s+$/g, '');

}

String.prototype.trimEnd = function String$trimEnd() {

    /// <summary locid="M:J#String.trimEnd" />

    /// <returns type="String"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return this.replace(/\s+$/, '');

}

String.prototype.trimStart = function String$trimStart() {

    /// <summary locid="M:J#String.trimStart" />

    /// <returns type="String"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return this.replace(/^\s+/, '');

}

String.format = function String$format(format, args) {

    /// <summary locid="M:J#String.format" />

    /// <param name="format" type="String"></param>

    /// <param name="args" parameterArray="true" mayBeNull="true"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String},

        {name: "args", mayBeNull: true, parameterArray: true}

    ]);

    if (e) throw e;

    return String._toFormattedString(false, arguments);

}

String.localeFormat = function String$localeFormat(format, args) {

    /// <summary locid="M:J#String.localeFormat" />

    /// <param name="format" type="String"></param>

    /// <param name="args" parameterArray="true" mayBeNull="true"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String},

        {name: "args", mayBeNull: true, parameterArray: true}

    ]);

    if (e) throw e;

    return String._toFormattedString(true, arguments);

}

String._toFormattedString = function String$_toFormattedString(useLocale, args) {

    var result = '';

    var format = args[0];

    for (var i=0;;) {

        var open = format.indexOf('{', i);

        var close = format.indexOf('}', i);

        if ((open < 0) && (close < 0)) {

            result += format.slice(i);

            break;

        }

        if ((close > 0) && ((close < open) || (open < 0))) {

            if (format.charAt(close + 1) !== '}') {

                throw Error.argument('format', Sys.Res.stringFormatBraceMismatch);

            }

            result += format.slice(i, close + 1);

            i = close + 2;

            continue;

        }

        result += format.slice(i, open);

        i = open + 1;

        if (format.charAt(i) === '{') {

            result += '{';

            i++;

            continue;

        }

        if (close < 0) throw Error.argument('format', Sys.Res.stringFormatBraceMismatch);

        var brace = format.substring(i, close);

        var colonIndex = brace.indexOf(':');

        var argNumber = parseInt((colonIndex < 0)? brace : brace.substring(0, colonIndex), 10) + 1;

        if (isNaN(argNumber)) throw Error.argument('format', Sys.Res.stringFormatInvalid);

        var argFormat = (colonIndex < 0)? '' : brace.substring(colonIndex + 1);

        var arg = args[argNumber];

        if (typeof(arg) === "undefined" || arg === null) {

            arg = '';

        }

        if (arg.toFormattedString) {

            result += arg.toFormattedString(argFormat);

        }

        else if (useLocale && arg.localeFormat) {

            result += arg.localeFormat(argFormat);

        }

        else if (arg.format) {

            result += arg.format(argFormat);

        }

        else

            result += arg.toString();

        i = close + 1;

    }

    return result;

}

 

Boolean.__typeName = 'Boolean';

Boolean.__class = true;

Boolean.parse = function Boolean$parse(value) {

    /// <summary locid="M:J#Boolean.parse" />

    /// <param name="value" type="String"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String}

    ]);

    if (e) throw e;

    var v = value.trim().toLowerCase();

    if (v === 'false') return false;

    if (v === 'true') return true;

    throw Error.argumentOutOfRange('value', value, Sys.Res.boolTrueOrFalse);

}

 

Date.__typeName = 'Date';

Date.__class = true;

Date._appendPreOrPostMatch = function Date$_appendPreOrPostMatch(preMatch, strBuilder) {

    var quoteCount = 0;

    var escaped = false;

    for (var i = 0, il = preMatch.length; i < il; i++) {

        var c = preMatch.charAt(i);

        switch (c) {

        case '\'':

            if (escaped) strBuilder.append("'");

            else quoteCount++;

            escaped = false;

            break;

        case '\\':

            if (escaped) strBuilder.append("\\");

            escaped = !escaped;

            break;

        default:

            strBuilder.append(c);

            escaped = false;

            break;

        }

    }

    return quoteCount;

}

Date._expandFormat = function Date$_expandFormat(dtf, format) {

    if (!format) {

        format = "F";

    }

    if (format.length === 1) {

        switch (format) {

        case "d":

            return dtf.ShortDatePattern;

        case "D":

            return dtf.LongDatePattern;

        case "t":

            return dtf.ShortTimePattern;

        case "T":

            return dtf.LongTimePattern;

        case "F":

            return dtf.FullDateTimePattern;

        case "M": case "m":

            return dtf.MonthDayPattern;

        case "s":

            return dtf.SortableDateTimePattern;

        case "Y": case "y":

            return dtf.YearMonthPattern;

        default:

            throw Error.format(Sys.Res.formatInvalidString);

        }

    }

    return format;

}

Date._expandYear = function Date$_expandYear(dtf, year) {

    if (year < 100) {

        var curr = new Date().getFullYear();

        year += curr - (curr % 100);

        if (year > dtf.Calendar.TwoDigitYearMax) {

            return year - 100;

        }

    }

    return year;

}

Date._getParseRegExp = function Date$_getParseRegExp(dtf, format) {

    if (!dtf._parseRegExp) {

        dtf._parseRegExp = {};

    }

    else if (dtf._parseRegExp[format]) {

        return dtf._parseRegExp[format];

    }

    var expFormat = Date._expandFormat(dtf, format);

    expFormat = expFormat.replace(/([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, "\\\\$1");

    var regexp = new Sys.StringBuilder("^");

    var groups = [];

    var index = 0;

    var quoteCount = 0;

    var tokenRegExp = Date._getTokenRegExp();

    var match;

    while ((match = tokenRegExp.exec(expFormat)) !== null) {

        var preMatch = expFormat.slice(index, match.index);

        index = tokenRegExp.lastIndex;

        quoteCount += Date._appendPreOrPostMatch(preMatch, regexp);

        if ((quoteCount%2) === 1) {

            regexp.append(match[0]);

            continue;

        }

        switch (match[0]) {

            case 'dddd': case 'ddd':

            case 'MMMM': case 'MMM':

                regexp.append("(\\D+)");

                break;

            case 'tt': case 't':

                regexp.append("(\\D*)");

                break;

            case 'yyyy':

                regexp.append("(\\d{4})");

                break;

            case 'fff':

                regexp.append("(\\d{3})");

                break;

            case 'ff':

                regexp.append("(\\d{2})");

                break;

            case 'f':

                regexp.append("(\\d)");

                break;

            case 'dd': case 'd':

            case 'MM': case 'M':

            case 'yy': case 'y':

            case 'HH': case 'H':

            case 'hh': case 'h':

            case 'mm': case 'm':

            case 'ss': case 's':

                regexp.append("(\\d\\d?)");

                break;

            case 'zzz':

                regexp.append("([+-]?\\d\\d?:\\d{2})");

                break;

            case 'zz': case 'z':

                regexp.append("([+-]?\\d\\d?)");

                break;

        }

        Array.add(groups, match[0]);

    }

    Date._appendPreOrPostMatch(expFormat.slice(index), regexp);

    regexp.append("$");

    var regexpStr = regexp.toString().replace(/\s+/g, "\\s+");

    var parseRegExp = {'regExp': regexpStr, 'groups': groups};

    dtf._parseRegExp[format] = parseRegExp;

    return parseRegExp;

}

Date._getTokenRegExp = function Date$_getTokenRegExp() {

    return /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;

}

Date.parseLocale = function Date$parseLocale(value, formats) {

    /// <summary locid="M:J#Date.parseLocale" />

    /// <param name="value" type="String"></param>

    /// <param name="formats" parameterArray="true" optional="true" mayBeNull="true"></param>

    /// <returns type="Date"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String},

        {name: "formats", mayBeNull: true, optional: true, parameterArray: true}

    ]);

    if (e) throw e;

    return Date._parse(value, Sys.CultureInfo.CurrentCulture, arguments);

}

Date.parseInvariant = function Date$parseInvariant(value, formats) {

    /// <summary locid="M:J#Date.parseInvariant" />

    /// <param name="value" type="String"></param>

    /// <param name="formats" parameterArray="true" optional="true" mayBeNull="true"></param>

    /// <returns type="Date"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String},

        {name: "formats", mayBeNull: true, optional: true, parameterArray: true}

    ]);

    if (e) throw e;

    return Date._parse(value, Sys.CultureInfo.InvariantCulture, arguments);

}

Date._parse = function Date$_parse(value, cultureInfo, args) {

    var custom = false;

    for (var i = 1, il = args.length; i < il; i++) {

        var format = args[i];

        if (format) {

            custom = true;

            var date = Date._parseExact(value, format, cultureInfo);

            if (date) return date;

        }

    }

    if (! custom) {

        var formats = cultureInfo._getDateTimeFormats();

        for (var i = 0, il = formats.length; i < il; i++) {

            var date = Date._parseExact(value, formats[i], cultureInfo);

            if (date) return date;

        }

    }

    return null;

}

Date._parseExact = function Date$_parseExact(value, format, cultureInfo) {

    value = value.trim();

    var dtf = cultureInfo.dateTimeFormat;

    var parseInfo = Date._getParseRegExp(dtf, format);

    var match = new RegExp(parseInfo.regExp).exec(value);

    if (match === null) return null;

    

    var groups = parseInfo.groups;

    var year = null, month = null, date = null, weekDay = null;

    var hour = 0, min = 0, sec = 0, msec = 0, tzMinOffset = null;

    var pmHour = false;

    for (var j = 0, jl = groups.length; j < jl; j++) {

        var matchGroup = match[j+1];

        if (matchGroup) {

            switch (groups[j]) {

                case 'dd': case 'd':

                    date = parseInt(matchGroup, 10);

                    if ((date < 1) || (date > 31)) return null;

                    break;

                case 'MMMM':

                    month = cultureInfo._getMonthIndex(matchGroup);

                    if ((month < 0) || (month > 11)) return null;

                    break;

                case 'MMM':

                    month = cultureInfo._getAbbrMonthIndex(matchGroup);

                    if ((month < 0) || (month > 11)) return null;

                    break;

                case 'M': case 'MM':

                    var month = parseInt(matchGroup, 10) - 1;

                    if ((month < 0) || (month > 11)) return null;

                    break;

                case 'y': case 'yy':

                    year = Date._expandYear(dtf,parseInt(matchGroup, 10));

                    if ((year < 0) || (year > 9999)) return null;

                    break;

                case 'yyyy':

                    year = parseInt(matchGroup, 10);

                    if ((year < 0) || (year > 9999)) return null;

                    break;

                case 'h': case 'hh':

                    hour = parseInt(matchGroup, 10);

                    if (hour === 12) hour = 0;

                    if ((hour < 0) || (hour > 11)) return null;

                    break;

                case 'H': case 'HH':

                    hour = parseInt(matchGroup, 10);

                    if ((hour < 0) || (hour > 23)) return null;

                    break;

                case 'm': case 'mm':

                    min = parseInt(matchGroup, 10);

                    if ((min < 0) || (min > 59)) return null;

                    break;

                case 's': case 'ss':

                    sec = parseInt(matchGroup, 10);

                    if ((sec < 0) || (sec > 59)) return null;

                    break;

                case 'tt': case 't':

                    var upperToken = matchGroup.toUpperCase();

                    pmHour = (upperToken === dtf.PMDesignator.toUpperCase());

                    if (!pmHour && (upperToken !== dtf.AMDesignator.toUpperCase())) return null;

                    break;

                case 'f':

                    msec = parseInt(matchGroup, 10) * 100;

                    if ((msec < 0) || (msec > 999)) return null;

                    break;

                case 'ff':

                    msec = parseInt(matchGroup, 10) * 10;

                    if ((msec < 0) || (msec > 999)) return null;

                    break;

                case 'fff':

                    msec = parseInt(matchGroup, 10);

                    if ((msec < 0) || (msec > 999)) return null;

                    break;

                case 'dddd':

                    weekDay = cultureInfo._getDayIndex(matchGroup);

                    if ((weekDay < 0) || (weekDay > 6)) return null;

                    break;

                case 'ddd':

                    weekDay = cultureInfo._getAbbrDayIndex(matchGroup);

                    if ((weekDay < 0) || (weekDay > 6)) return null;

                    break;

                case 'zzz':

                    var offsets = matchGroup.split(/:/);

                    if (offsets.length !== 2) return null;

                    var hourOffset = parseInt(offsets[0], 10);

                    if ((hourOffset < -12) || (hourOffset > 13)) return null;

                    var minOffset = parseInt(offsets[1], 10);

                    if ((minOffset < 0) || (minOffset > 59)) return null;

                    tzMinOffset = (hourOffset * 60) + (matchGroup.startsWith('-')? -minOffset : minOffset);

                    break;

                case 'z': case 'zz':

                    var hourOffset = parseInt(matchGroup, 10);

                    if ((hourOffset < -12) || (hourOffset > 13)) return null;

                    tzMinOffset = hourOffset * 60;

                    break;

            }

        }

    }

    var result = new Date();

    if (year === null) {

        year = result.getFullYear();

    }

    if (month === null) {

        month = result.getMonth();

    }

    if (date === null) {

        date = result.getDate();

    }

    result.setFullYear(year, month, date);

    if (result.getDate() !== date) return null;

    if ((weekDay !== null) && (result.getDay() !== weekDay)) {

        return null;

    }

    if (pmHour && (hour < 12)) {

        hour += 12;

    }

    result.setHours(hour, min, sec, msec);

    if (tzMinOffset !== null) {

        var adjustedMin = result.getMinutes() - (tzMinOffset + result.getTimezoneOffset());

        result.setHours(result.getHours() + parseInt(adjustedMin/60, 10), adjustedMin%60);

    }

    return result;

}

Date.prototype.format = function Date$format(format) {

    /// <summary locid="M:J#Date.format" />

    /// <param name="format" type="String"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String}

    ]);

    if (e) throw e;

    return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);

}

Date.prototype.localeFormat = function Date$localeFormat(format) {

    /// <summary locid="M:J#Date.localeFormat" />

    /// <param name="format" type="String"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String}

    ]);

    if (e) throw e;

    return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);

}

Date.prototype._toFormattedString = function Date$_toFormattedString(format, cultureInfo) {

    if (!format || (format.length === 0) || (format === 'i')) {

        if (cultureInfo && (cultureInfo.name.length > 0)) {

            return this.toLocaleString();

        }

        else {

            return this.toString();

        }

    }

    var dtf = cultureInfo.dateTimeFormat;

    format = Date._expandFormat(dtf, format);

    var ret = new Sys.StringBuilder();

    var hour;

    function addLeadingZero(num) {

        if (num < 10) {

            return '0' + num;

        }

        return num.toString();

    }

    function addLeadingZeros(num) {

        if (num < 10) {

            return '00' + num;

        }

        if (num < 100) {

            return '0' + num;

        }

        return num.toString();

    }

    var quoteCount = 0;

    var tokenRegExp = Date._getTokenRegExp();

    for (;;) {

        var index = tokenRegExp.lastIndex;

        var ar = tokenRegExp.exec(format);

        var preMatch = format.slice(index, ar ? ar.index : format.length);

        quoteCount += Date._appendPreOrPostMatch(preMatch, ret);

        if (!ar) break;

        if ((quoteCount%2) === 1) {

            ret.append(ar[0]);

            continue;

        }

        switch (ar[0]) {

        case "dddd":

            ret.append(dtf.DayNames[this.getDay()]);

            break;

        case "ddd":

            ret.append(dtf.AbbreviatedDayNames[this.getDay()]);

            break;

        case "dd":

            ret.append(addLeadingZero(this.getDate()));

            break;

        case "d":

            ret.append(this.getDate());

            break;

        case "MMMM":

            ret.append(dtf.MonthNames[this.getMonth()]);

            break;

        case "MMM":

            ret.append(dtf.AbbreviatedMonthNames[this.getMonth()]);

            break;

        case "MM":

            ret.append(addLeadingZero(this.getMonth() + 1));

            break;

        case "M":

            ret.append(this.getMonth() + 1);

            break;

        case "yyyy":

            ret.append(this.getFullYear());

            break;

        case "yy":

            ret.append(addLeadingZero(this.getFullYear() % 100));

            break;

        case "y":

            ret.append(this.getFullYear() % 100);

            break;

        case "hh":

            hour = this.getHours() % 12;

            if (hour === 0) hour = 12;

            ret.append(addLeadingZero(hour));

            break;

        case "h":

            hour = this.getHours() % 12;

            if (hour === 0) hour = 12;

            ret.append(hour);

            break;

        case "HH":

            ret.append(addLeadingZero(this.getHours()));

            break;

        case "H":

            ret.append(this.getHours());

            break;

        case "mm":

            ret.append(addLeadingZero(this.getMinutes()));

            break;

        case "m":

            ret.append(this.getMinutes());

            break;

        case "ss":

            ret.append(addLeadingZero(this.getSeconds()));

            break;

        case "s":

            ret.append(this.getSeconds());

            break;

        case "tt":

            ret.append((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator);

            break;

        case "t":

            ret.append(((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator).charAt(0));

            break;

        case "f":

            ret.append(addLeadingZeros(this.getMilliseconds()).charAt(0));

            break;

        case "ff":

            ret.append(addLeadingZeros(this.getMilliseconds()).substr(0, 2));

            break;

        case "fff":

            ret.append(addLeadingZeros(this.getMilliseconds()));

            break;

        case "z":

            hour = this.getTimezoneOffset() / 60;

            ret.append(((hour <= 0) ? '+' : '-') + Math.floor(Math.abs(hour)));

            break;

        case "zz":

            hour = this.getTimezoneOffset() / 60;

            ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour))));

            break;

        case "zzz":

            hour = this.getTimezoneOffset() / 60;

            ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour))) +

                dtf.TimeSeparator + addLeadingZero(Math.abs(this.getTimezoneOffset() % 60)));

            break;

        }

    }

    return ret.toString();

}

 

Number.__typeName = 'Number';

Number.__class = true;

Number.parseLocale = function Number$parseLocale(value) {

    /// <summary locid="M:J#Number.parseLocale" />

    /// <param name="value" type="String"></param>

    /// <returns type="Number"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String}

    ]);

    if (e) throw e;

    return Number._parse(value, Sys.CultureInfo.CurrentCulture);

}

Number.parseInvariant = function Number$parseInvariant(value) {

    /// <summary locid="M:J#Number.parseInvariant" />

    /// <param name="value" type="String"></param>

    /// <returns type="Number"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String}

    ]);

    if (e) throw e;

    return Number._parse(value, Sys.CultureInfo.InvariantCulture);

}

Number._parse = function Number$_parse(value, cultureInfo) {

    value = value.trim();

    

    if (value.match(/^[+-]?infinity$/i)) {

        return parseFloat(value);

    }

    if (value.match(/^0x[a-f0-9]+$/i)) {

        return parseInt(value);

    }

    var numFormat = cultureInfo.numberFormat;

    var signInfo = Number._parseNumberNegativePattern(value, numFormat, numFormat.NumberNegativePattern);

    var sign = signInfo[0];

    var num = signInfo[1];

    

    if ((sign === '') && (numFormat.NumberNegativePattern !== 1)) {

        signInfo = Number._parseNumberNegativePattern(value, numFormat, 1);

        sign = signInfo[0];

        num = signInfo[1];

    }

    if (sign === '') sign = '+';

    

    var exponent;

    var intAndFraction;

    var exponentPos = num.indexOf('e');

    if (exponentPos < 0) exponentPos = num.indexOf('E');

    if (exponentPos < 0) {

        intAndFraction = num;

        exponent = null;

    }

    else {

        intAndFraction = num.substr(0, exponentPos);

        exponent = num.substr(exponentPos + 1);

    }

    

    var integer;

    var fraction;

    var decimalPos = intAndFraction.indexOf(numFormat.NumberDecimalSeparator);

    if (decimalPos < 0) {

        integer = intAndFraction;

        fraction = null;

    }

    else {

        integer = intAndFraction.substr(0, decimalPos);

        fraction = intAndFraction.substr(decimalPos + numFormat.NumberDecimalSeparator.length);

    }

    

    integer = integer.split(numFormat.NumberGroupSeparator).join('');

    var altNumGroupSeparator = numFormat.NumberGroupSeparator.replace(/\u00A0/g, " ");

    if (numFormat.NumberGroupSeparator !== altNumGroupSeparator) {

        integer = integer.split(altNumGroupSeparator).join('');

    }

    

    var p = sign + integer;

    if (fraction !== null) {

        p += '.' + fraction;

    }

    if (exponent !== null) {

        var expSignInfo = Number._parseNumberNegativePattern(exponent, numFormat, 1);

        if (expSignInfo[0] === '') {

            expSignInfo[0] = '+';

        }

        p += 'e' + expSignInfo[0] + expSignInfo[1];

    }

    if (p.match(/^[+-]?\d*\.?\d*(e[+-]?\d+)?$/)) {

        return parseFloat(p);

    }

    return Number.NaN;

}

Number._parseNumberNegativePattern = function Number$_parseNumberNegativePattern(value, numFormat, numberNegativePattern) {

    var neg = numFormat.NegativeSign;

    var pos = numFormat.PositiveSign;    

    switch (numberNegativePattern) {

        case 4: 

            neg = ' ' + neg;

            pos = ' ' + pos;

        case 3: 

            if (value.endsWith(neg)) {

                return ['-', value.substr(0, value.length - neg.length)];

            }

            else if (value.endsWith(pos)) {

                return ['+', value.substr(0, value.length - pos.length)];

            }

            break;

        case 2: 

            neg += ' ';

            pos += ' ';

        case 1: 

            if (value.startsWith(neg)) {

                return ['-', value.substr(neg.length)];

            }

            else if (value.startsWith(pos)) {

                return ['+', value.substr(pos.length)];

            }

            break;

        case 0: 

            if (value.startsWith('(') && value.endsWith(')')) {

                return ['-', value.substr(1, value.length - 2)];

            }

            break;

    }

    return ['', value];

}

Number.prototype.format = function Number$format(format) {

    /// <summary locid="M:J#Number.format" />

    /// <param name="format" type="String"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String}

    ]);

    if (e) throw e;

    return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);

}

Number.prototype.localeFormat = function Number$localeFormat(format) {

    /// <summary locid="M:J#Number.localeFormat" />

    /// <param name="format" type="String"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "format", type: String}

    ]);

    if (e) throw e;

    return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);

}

Number.prototype._toFormattedString = function Number$_toFormattedString(format, cultureInfo) {

    if (!format || (format.length === 0) || (format === 'i')) {

        if (cultureInfo && (cultureInfo.name.length > 0)) {

            return this.toLocaleString();

        }

        else {

            return this.toString();

        }

    }

    

    var _percentPositivePattern = ["n %", "n%", "%n" ];

    var _percentNegativePattern = ["-n %", "-n%", "-%n"];

    var _numberNegativePattern = ["(n)","-n","- n","n-","n -"];

    var _currencyPositivePattern = ["$n","n$","$ n","n $"];

    var _currencyNegativePattern = ["($n)","-$n","$-n","$n-","(n$)","-n$","n-$","n$-","-n $","-$ n","n $-","$ n-","$ -n","n- $","($ n)","(n $)"];

    function zeroPad(str, count, left) {

        for (var l=str.length; l < count; l++) {

            str = (left ? ('0' + str) : (str + '0'));

        }

        return str;

    }

    

    function expandNumber(number, precision, groupSizes, sep, decimalChar) {

        

        var curSize = groupSizes[0];

        var curGroupIndex = 1;

        var factor = Math.pow(10, precision);

        var rounded = (Math.round(number * factor) / factor);

        if (!isFinite(rounded)) {

            rounded = number;

        }

        number = rounded;

        

        var numberString = number.toString();

        var right = "";

        var exponent;

        

        

        var split = numberString.split(/e/i);

        numberString = split[0];

        exponent = (split.length > 1 ? parseInt(split[1]) : 0);

        split = numberString.split('.');

        numberString = split[0];

        right = split.length > 1 ? split[1] : "";

        

        var l;

        if (exponent > 0) {

            right = zeroPad(right, exponent, false);

            numberString += right.slice(0, exponent);

            right = right.substr(exponent);

        }

        else if (exponent < 0) {

            exponent = -exponent;

            numberString = zeroPad(numberString, exponent+1, true);

            right = numberString.slice(-exponent, numberString.length) + right;

            numberString = numberString.slice(0, -exponent);

        }

        if (precision > 0) {

            if (right.length > precision) {

                right = right.slice(0, precision);

            }

            else {

                right = zeroPad(right, precision, false);

            }

            right = decimalChar + right;

        }

        else { 

            right = "";

        }

        var stringIndex = numberString.length-1;

        var ret = "";

        while (stringIndex >= 0) {

            if (curSize === 0 || curSize > stringIndex) {

                if (ret.length > 0)

                    return numberString.slice(0, stringIndex + 1) + sep + ret + right;

                else

                    return numberString.slice(0, stringIndex + 1) + right;

            }

            if (ret.length > 0)

                ret = numberString.slice(stringIndex - curSize + 1, stringIndex+1) + sep + ret;

            else

                ret = numberString.slice(stringIndex - curSize + 1, stringIndex+1);

            stringIndex -= curSize;

            if (curGroupIndex < groupSizes.length) {

                curSize = groupSizes[curGroupIndex];

                curGroupIndex++;

            }

        }

        return numberString.slice(0, stringIndex + 1) + sep + ret + right;

    }

    var nf = cultureInfo.numberFormat;

    var number = Math.abs(this);

    if (!format)

        format = "D";

    var precision = -1;

    if (format.length > 1) precision = parseInt(format.slice(1), 10);

    var pattern;

    switch (format.charAt(0)) {

    case "d":

    case "D":

        pattern = 'n';

        if (precision !== -1) {

            number = zeroPad(""+number, precision, true);

        }

        if (this < 0) number = -number;

        break;

    case "c":

    case "C":

        if (this < 0) pattern = _currencyNegativePattern[nf.CurrencyNegativePattern];

        else pattern = _currencyPositivePattern[nf.CurrencyPositivePattern];

        if (precision === -1) precision = nf.CurrencyDecimalDigits;

        number = expandNumber(Math.abs(this), precision, nf.CurrencyGroupSizes, nf.CurrencyGroupSeparator, nf.CurrencyDecimalSeparator);

        break;

    case "n":

    case "N":

        if (this < 0) pattern = _numberNegativePattern[nf.NumberNegativePattern];

        else pattern = 'n';

        if (precision === -1) precision = nf.NumberDecimalDigits;

        number = expandNumber(Math.abs(this), precision, nf.NumberGroupSizes, nf.NumberGroupSeparator, nf.NumberDecimalSeparator);

        break;

    case "p":

    case "P":

        if (this < 0) pattern = _percentNegativePattern[nf.PercentNegativePattern];

        else pattern = _percentPositivePattern[nf.PercentPositivePattern];

        if (precision === -1) precision = nf.PercentDecimalDigits;

        number = expandNumber(Math.abs(this) * 100, precision, nf.PercentGroupSizes, nf.PercentGroupSeparator, nf.PercentDecimalSeparator);

        break;

    default:

        throw Error.format(Sys.Res.formatBadFormatSpecifier);

    }

    var regex = /n|\$|-|%/g;

    var ret = "";

    for (;;) {

        var index = regex.lastIndex;

        var ar = regex.exec(pattern);

        ret += pattern.slice(index, ar ? ar.index : pattern.length);

        if (!ar)

            break;

        switch (ar[0]) {

        case "n":

            ret += number;

            break;

        case "$":

            ret += nf.CurrencySymbol;

            break;

        case "-":

            ret += nf.NegativeSign;

            break;

        case "%":

            ret += nf.PercentSymbol;

            break;

        }

    }

    return ret;

}

 

RegExp.__typeName = 'RegExp';

RegExp.__class = true;

 

Array.__typeName = 'Array';

Array.__class = true;

Array.add = Array.enqueue = function Array$enqueue(array, item) {

    /// <summary locid="M:J#Array.enqueue" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="item" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "item", mayBeNull: true}

    ]);

    if (e) throw e;

    array[array.length] = item;

}

Array.addRange = function Array$addRange(array, items) {

    /// <summary locid="M:J#Array.addRange" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="items" type="Array" elementMayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "items", type: Array, elementMayBeNull: true}

    ]);

    if (e) throw e;

    array.push.apply(array, items);

}

Array.clear = function Array$clear(array) {

    /// <summary locid="M:J#Array.clear" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true}

    ]);

    if (e) throw e;

    array.length = 0;

}

Array.clone = function Array$clone(array) {

    /// <summary locid="M:J#Array.clone" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <returns type="Array" elementMayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true}

    ]);

    if (e) throw e;

    if (array.length === 1) {

        return [array[0]];

    }

    else {

        return Array.apply(null, array);

    }

}

Array.contains = function Array$contains(array, item) {

    /// <summary locid="M:J#Array.contains" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="item" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "item", mayBeNull: true}

    ]);

    if (e) throw e;

    return (Array.indexOf(array, item) >= 0);

}

Array.dequeue = function Array$dequeue(array) {

    /// <summary locid="M:J#Array.dequeue" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <returns mayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true}

    ]);

    if (e) throw e;

    return array.shift();

}

Array.forEach = function Array$forEach(array, method, instance) {

    /// <summary locid="M:J#Array.forEach" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="method" type="Function"></param>

    /// <param name="instance" optional="true" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "method", type: Function},

        {name: "instance", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    for (var i = 0, l = array.length; i < l; i++) {

        var elt = array[i];

        if (typeof(elt) !== 'undefined') method.call(instance, elt, i, array);

    }

}

Array.indexOf = function Array$indexOf(array, item, start) {

    /// <summary locid="M:J#Array.indexOf" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="item" optional="true" mayBeNull="true"></param>

    /// <param name="start" optional="true" mayBeNull="true"></param>

    /// <returns type="Number"></returns>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "item", mayBeNull: true, optional: true},

        {name: "start", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    if (typeof(item) === "undefined") return -1;

    var length = array.length;

    if (length !== 0) {

        start = start - 0;

        if (isNaN(start)) {

            start = 0;

        }

        else {

            if (isFinite(start)) {

                start = start - (start % 1);

            }

            if (start < 0) {

                start = Math.max(0, length + start);

            }

        }

        for (var i = start; i < length; i++) {

            if ((typeof(array[i]) !== "undefined") && (array[i] === item)) {

                return i;

            }

        }

    }

    return -1;

}

Array.insert = function Array$insert(array, index, item) {

    /// <summary locid="M:J#Array.insert" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="index" mayBeNull="true"></param>

    /// <param name="item" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "index", mayBeNull: true},

        {name: "item", mayBeNull: true}

    ]);

    if (e) throw e;

    array.splice(index, 0, item);

}

Array.parse = function Array$parse(value) {

    /// <summary locid="M:J#Array.parse" />

    /// <param name="value" type="String" mayBeNull="true"></param>

    /// <returns type="Array" elementMayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String, mayBeNull: true}

    ]);

    if (e) throw e;

    if (!value) return [];

    var v = eval(value);

    if (!Array.isInstanceOfType(v)) throw Error.argument('value', Sys.Res.arrayParseBadFormat);

    return v;

}

Array.remove = function Array$remove(array, item) {

    /// <summary locid="M:J#Array.remove" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="item" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "item", mayBeNull: true}

    ]);

    if (e) throw e;

    var index = Array.indexOf(array, item);

    if (index >= 0) {

        array.splice(index, 1);

    }

    return (index >= 0);

}

Array.removeAt = function Array$removeAt(array, index) {

    /// <summary locid="M:J#Array.removeAt" />

    /// <param name="array" type="Array" elementMayBeNull="true"></param>

    /// <param name="index" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "array", type: Array, elementMayBeNull: true},

        {name: "index", mayBeNull: true}

    ]);

    if (e) throw e;

    array.splice(index, 1);

}

 

if (!window) this.window = this;

window.Type = Function;

Type.__fullyQualifiedIdentifierRegExp = new RegExp("^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]([^ \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*[^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\])?$", "i");

Type.__identifierRegExp = new RegExp("^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\][^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*$", "i");

Type.prototype.callBaseMethod = function Type$callBaseMethod(instance, name, baseArguments) {

    /// <summary locid="M:J#Type.callBaseMethod" />

    /// <param name="instance"></param>

    /// <param name="name" type="String"></param>

    /// <param name="baseArguments" type="Array" optional="true" mayBeNull="true" elementMayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance"},

        {name: "name", type: String},

        {name: "baseArguments", type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}

    ]);

    if (e) throw e;

    var baseMethod = this.getBaseMethod(instance, name);

    if (!baseMethod) throw Error.invalidOperation(String.format(Sys.Res.methodNotFound, name));

    if (!baseArguments) {

        return baseMethod.apply(instance);

    }

    else {

        return baseMethod.apply(instance, baseArguments);

    }

}

Type.prototype.getBaseMethod = function Type$getBaseMethod(instance, name) {

    /// <summary locid="M:J#Type.getBaseMethod" />

    /// <param name="instance"></param>

    /// <param name="name" type="String"></param>

    /// <returns type="Function" mayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance"},

        {name: "name", type: String}

    ]);

    if (e) throw e;

    if (!this.isInstanceOfType(instance)) throw Error.argumentType('instance', Object.getType(instance), this);

    var baseType = this.getBaseType();

    if (baseType) {

        var baseMethod = baseType.prototype[name];

        return (baseMethod instanceof Function) ? baseMethod : null;

    }

    return null;

}

Type.prototype.getBaseType = function Type$getBaseType() {

    /// <summary locid="M:J#Type.getBaseType" />

    /// <returns type="Type" mayBeNull="true"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return (typeof(this.__baseType) === "undefined") ? null : this.__baseType;

}

Type.prototype.getInterfaces = function Type$getInterfaces() {

    /// <summary locid="M:J#Type.getInterfaces" />

    /// <returns type="Array" elementType="Type" mayBeNull="false" elementMayBeNull="false"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    var result = [];

    var type = this;

    while(type) {

        var interfaces = type.__interfaces;

        if (interfaces) {

            for (var i = 0, l = interfaces.length; i < l; i++) {

                var interfaceType = interfaces[i];

                if (!Array.contains(result, interfaceType)) {

                    result[result.length] = interfaceType;

                }

            }

        }

        type = type.__baseType;

    }

    return result;

}

Type.prototype.getName = function Type$getName() {

    /// <summary locid="M:J#Type.getName" />

    /// <returns type="String"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return (typeof(this.__typeName) === "undefined") ? "" : this.__typeName;

}

Type.prototype.implementsInterface = function Type$implementsInterface(interfaceType) {

    /// <summary locid="M:J#Type.implementsInterface" />

    /// <param name="interfaceType" type="Type"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "interfaceType", type: Type}

    ]);

    if (e) throw e;

    this.resolveInheritance();

    var interfaceName = interfaceType.getName();

    var cache = this.__interfaceCache;

    if (cache) {

        var cacheEntry = cache[interfaceName];

        if (typeof(cacheEntry) !== 'undefined') return cacheEntry;

    }

    else {

        cache = this.__interfaceCache = {};

    }

    var baseType = this;

    while (baseType) {

        var interfaces = baseType.__interfaces;

        if (interfaces) {

            if (Array.indexOf(interfaces, interfaceType) !== -1) {

                return cache[interfaceName] = true;

            }

        }

        baseType = baseType.__baseType;

    }

    return cache[interfaceName] = false;

}

Type.prototype.inheritsFrom = function Type$inheritsFrom(parentType) {

    /// <summary locid="M:J#Type.inheritsFrom" />

    /// <param name="parentType" type="Type"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "parentType", type: Type}

    ]);

    if (e) throw e;

    this.resolveInheritance();

    var baseType = this.__baseType;

    while (baseType) {

        if (baseType === parentType) {

            return true;

        }

        baseType = baseType.__baseType;

    }

    return false;

}

Type.prototype.initializeBase = function Type$initializeBase(instance, baseArguments) {

    /// <summary locid="M:J#Type.initializeBase" />

    /// <param name="instance"></param>

    /// <param name="baseArguments" type="Array" optional="true" mayBeNull="true" elementMayBeNull="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance"},

        {name: "baseArguments", type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}

    ]);

    if (e) throw e;

    if (!this.isInstanceOfType(instance)) throw Error.argumentType('instance', Object.getType(instance), this);

    this.resolveInheritance();

    if (this.__baseType) {

        if (!baseArguments) {

            this.__baseType.apply(instance);

        }

        else {

            this.__baseType.apply(instance, baseArguments);

        }

    }

    return instance;

}

Type.prototype.isImplementedBy = function Type$isImplementedBy(instance) {

    /// <summary locid="M:J#Type.isImplementedBy" />

    /// <param name="instance" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance", mayBeNull: true}

    ]);

    if (e) throw e;

    if (typeof(instance) === "undefined" || instance === null) return false;

    var instanceType = Object.getType(instance);

    return !!(instanceType.implementsInterface && instanceType.implementsInterface(this));

}

Type.prototype.isInstanceOfType = function Type$isInstanceOfType(instance) {

    /// <summary locid="M:J#Type.isInstanceOfType" />

    /// <param name="instance" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "instance", mayBeNull: true}

    ]);

    if (e) throw e;

    if (typeof(instance) === "undefined" || instance === null) return false;

    if (instance instanceof this) return true;

    var instanceType = Object.getType(instance);

    return !!(instanceType === this) ||

           (instanceType.inheritsFrom && instanceType.inheritsFrom(this)) ||

           (instanceType.implementsInterface && instanceType.implementsInterface(this));

}

Type.prototype.registerClass = function Type$registerClass(typeName, baseType, interfaceTypes) {

    /// <summary locid="M:J#Type.registerClass" />

    /// <param name="typeName" type="String"></param>

    /// <param name="baseType" type="Type" optional="true" mayBeNull="true"></param>

    /// <param name="interfaceTypes" parameterArray="true" type="Type"></param>

    /// <returns type="Type"></returns>

    var e = Function._validateParams(arguments, [

        {name: "typeName", type: String},

        {name: "baseType", type: Type, mayBeNull: true, optional: true},

        {name: "interfaceTypes", type: Type, parameterArray: true}

    ]);

    if (e) throw e;

    if (!Type.__fullyQualifiedIdentifierRegExp.test(typeName)) throw Error.argument('typeName', Sys.Res.notATypeName);

    var parsedName;

    try {

        parsedName = eval(typeName);

    }

    catch(e) {

        throw Error.argument('typeName', Sys.Res.argumentTypeName);

    }

    if (parsedName !== this) throw Error.argument('typeName', Sys.Res.badTypeName);

    if (Sys.__registeredTypes[typeName]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, typeName));

    if ((arguments.length > 1) && (typeof(baseType) === 'undefined')) throw Error.argumentUndefined('baseType');

    if (baseType && !baseType.__class) throw Error.argument('baseType', Sys.Res.baseNotAClass);

    this.prototype.constructor = this;

    this.__typeName = typeName;

    this.__class = true;

    if (baseType) {

        this.__baseType = baseType;

        this.__basePrototypePending = true;

    }

    Sys.__upperCaseTypes[typeName.toUpperCase()] = this;

    if (interfaceTypes) {

        this.__interfaces = [];

        this.resolveInheritance();

        for (var i = 2, l = arguments.length; i < l; i++) {

            var interfaceType = arguments[i];

            if (!interfaceType.__interface) throw Error.argument('interfaceTypes[' + (i - 2) + ']', Sys.Res.notAnInterface);

            for (var methodName in interfaceType.prototype) {

                var method = interfaceType.prototype[methodName];

                if (!this.prototype[methodName]) {

                    this.prototype[methodName] = method;

                }

            }

            this.__interfaces.push(interfaceType);

        }

    }

    Sys.__registeredTypes[typeName] = true;

    return this;

}

Type.prototype.registerInterface = function Type$registerInterface(typeName) {

    /// <summary locid="M:J#Type.registerInterface" />

    /// <param name="typeName" type="String"></param>

    /// <returns type="Type"></returns>

    var e = Function._validateParams(arguments, [

        {name: "typeName", type: String}

    ]);

    if (e) throw e;

    if (!Type.__fullyQualifiedIdentifierRegExp.test(typeName)) throw Error.argument('typeName', Sys.Res.notATypeName);

    var parsedName;

    try {

        parsedName = eval(typeName);

    }

    catch(e) {

        throw Error.argument('typeName', Sys.Res.argumentTypeName);

    }

    if (parsedName !== this) throw Error.argument('typeName', Sys.Res.badTypeName);

    if (Sys.__registeredTypes[typeName]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, typeName));

    Sys.__upperCaseTypes[typeName.toUpperCase()] = this;

    this.prototype.constructor = this;

    this.__typeName = typeName;

    this.__interface = true;

    Sys.__registeredTypes[typeName] = true;

    return this;

}

Type.prototype.resolveInheritance = function Type$resolveInheritance() {

    /// <summary locid="M:J#Type.resolveInheritance" />

    if (arguments.length !== 0) throw Error.parameterCount();

    if (this.__basePrototypePending) {

        var baseType = this.__baseType;

        baseType.resolveInheritance();

        for (var memberName in baseType.prototype) {

            var memberValue = baseType.prototype[memberName];

            if (!this.prototype[memberName]) {

                this.prototype[memberName] = memberValue;

            }

        }

        delete this.__basePrototypePending;

    }

}

Type.getRootNamespaces = function Type$getRootNamespaces() {

    /// <summary locid="M:J#Type.getRootNamespaces" />

    /// <returns type="Array"></returns>

    if (arguments.length !== 0) throw Error.parameterCount();

    return Array.clone(Sys.__rootNamespaces);

}

Type.isClass = function Type$isClass(type) {

    /// <summary locid="M:J#Type.isClass" />

    /// <param name="type" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "type", mayBeNull: true}

    ]);

    if (e) throw e;

    if ((typeof(type) === 'undefined') || (type === null)) return false;

    return !!type.__class;

}

Type.isInterface = function Type$isInterface(type) {

    /// <summary locid="M:J#Type.isInterface" />

    /// <param name="type" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "type", mayBeNull: true}

    ]);

    if (e) throw e;

    if ((typeof(type) === 'undefined') || (type === null)) return false;

    return !!type.__interface;

}

Type.isNamespace = function Type$isNamespace(object) {

    /// <summary locid="M:J#Type.isNamespace" />

    /// <param name="object" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "object", mayBeNull: true}

    ]);

    if (e) throw e;

    if ((typeof(object) === 'undefined') || (object === null)) return false;

    return !!object.__namespace;

}

Type.parse = function Type$parse(typeName, ns) {

    /// <summary locid="M:J#Type.parse" />

    /// <param name="typeName" type="String" mayBeNull="true"></param>

    /// <param name="ns" optional="true" mayBeNull="true"></param>

    /// <returns type="Type" mayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "typeName", type: String, mayBeNull: true},

        {name: "ns", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    var fn;

    if (ns) {

        fn = Sys.__upperCaseTypes[ns.getName().toUpperCase() + '.' + typeName.toUpperCase()];

        return fn || null;

    }

    if (!typeName) return null;

    if (!Type.__htClasses) {

        Type.__htClasses = {};

    }

    fn = Type.__htClasses[typeName];

    if (!fn) {

        fn = eval(typeName);

        if (typeof(fn) !== 'function') throw Error.argument('typeName', Sys.Res.notATypeName);

        Type.__htClasses[typeName] = fn;

    }

    return fn;

}

Type.registerNamespace = function Type$registerNamespace(namespacePath) {

    /// <summary locid="M:J#Type.registerNamespace" />

    /// <param name="namespacePath" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "namespacePath", type: String}

    ]);

    if (e) throw e;

    if (!Type.__fullyQualifiedIdentifierRegExp.test(namespacePath)) throw Error.argument('namespacePath', Sys.Res.invalidNameSpace);

    var rootObject = window;

    var namespaceParts = namespacePath.split('.');

    for (var i = 0; i < namespaceParts.length; i++) {

        var currentPart = namespaceParts[i];

        var ns = rootObject[currentPart];

        if (ns && !ns.__namespace) {

            throw Error.invalidOperation(String.format(Sys.Res.namespaceContainsObject, namespaceParts.splice(0, i + 1).join('.')));

        }

        if (!ns) {

            ns = rootObject[currentPart] = {

                __namespace: true,

                __typeName: namespaceParts.slice(0, i + 1).join('.')

            };

            if (i === 0) {

                Sys.__rootNamespaces[Sys.__rootNamespaces.length] = ns;

            }

            var parsedName;

            try {

                parsedName = eval(ns.__typeName);

            }

            catch(e) {

                parsedName = null;

            }

            if (parsedName !== ns) {

                delete rootObject[currentPart];

                throw Error.argument('namespacePath', Sys.Res.invalidNameSpace);

            }

            ns.getName = function ns$getName() {return this.__typeName;}

        }

        rootObject = ns;

    }

}

window.Sys = {

    __namespace: true,

    __typeName: "Sys",

    getName: function() {return "Sys";},

    __upperCaseTypes: {}

};

Sys.__rootNamespaces = [Sys];

Sys.__registeredTypes = {};

 

Sys.IDisposable = function Sys$IDisposable() {

    throw Error.notImplemented();

}

    function Sys$IDisposable$dispose() {

        throw Error.notImplemented();

    }

Sys.IDisposable.prototype = {

    dispose: Sys$IDisposable$dispose

}

Sys.IDisposable.registerInterface('Sys.IDisposable');

 

Sys.StringBuilder = function Sys$StringBuilder(initialText) {

    /// <summary locid="M:J#Sys.StringBuilder.#ctor" />

    /// <param name="initialText" optional="true" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "initialText", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    this._parts = (typeof(initialText) !== 'undefined' && initialText !== null && initialText !== '') ?

        [initialText.toString()] : [];

    this._value = {};

    this._len = 0;

}

    function Sys$StringBuilder$append(text) {

        /// <summary locid="M:J#Sys.StringBuilder.append" />

        /// <param name="text" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "text", mayBeNull: true}

        ]);

        if (e) throw e;

        this._parts[this._parts.length] = text;

    }

    function Sys$StringBuilder$appendLine(text) {

        /// <summary locid="M:J#Sys.StringBuilder.appendLine" />

        /// <param name="text" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "text", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        this._parts[this._parts.length] =

            ((typeof(text) === 'undefined') || (text === null) || (text === '')) ?

            '\r\n' : text + '\r\n';

    }

    function Sys$StringBuilder$clear() {

        /// <summary locid="M:J#Sys.StringBuilder.clear" />

        if (arguments.length !== 0) throw Error.parameterCount();

        this._parts = [];

        this._value = {};

        this._len = 0;

    }

    function Sys$StringBuilder$isEmpty() {

        /// <summary locid="M:J#Sys.StringBuilder.isEmpty" />

        /// <returns type="Boolean"></returns>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._parts.length === 0) return true;

        return this.toString() === '';

    }

    function Sys$StringBuilder$toString(separator) {

        /// <summary locid="M:J#Sys.StringBuilder.toString" />

        /// <param name="separator" type="String" optional="true" mayBeNull="true"></param>

        /// <returns type="String"></returns>

        var e = Function._validateParams(arguments, [

            {name: "separator", type: String, mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        separator = separator || '';

        var parts = this._parts;

        if (this._len !== parts.length) {

            this._value = {};

            this._len = parts.length;

        }

        var val = this._value;

        if (typeof(val[separator]) === 'undefined') {

            if (separator !== '') {

                for (var i = 0; i < parts.length;) {

                    if ((typeof(parts[i]) === 'undefined') || (parts[i] === '') || (parts[i] === null)) {

                        parts.splice(i, 1);

                    }

                    else {

                        i++;

                    }

                }

            }

            val[separator] = this._parts.join(separator);

        }

        return val[separator];

    }

Sys.StringBuilder.prototype = {

    append: Sys$StringBuilder$append,

    appendLine: Sys$StringBuilder$appendLine,

    clear: Sys$StringBuilder$clear,

    isEmpty: Sys$StringBuilder$isEmpty,

    toString: Sys$StringBuilder$toString

}

Sys.StringBuilder.registerClass('Sys.StringBuilder');

 

if (!window.XMLHttpRequest) {

    window.XMLHttpRequest = function window$XMLHttpRequest() {

        var progIDs = [ 'Msxml2.XMLHTTP.3.0', 'Msxml2.XMLHTTP' ];

        for (var i = 0, l = progIDs.length; i < l; i++) {

            try {

                return new ActiveXObject(progIDs[i]);

            }

            catch (ex) {

            }

        }

        return null;

    }

}

 

Sys.Browser = {};

Sys.Browser.InternetExplorer = {};

Sys.Browser.Firefox = {};

Sys.Browser.Safari = {};

Sys.Browser.Opera = {};

Sys.Browser.agent = null;

Sys.Browser.hasDebuggerStatement = false;

Sys.Browser.name = navigator.appName;

Sys.Browser.version = parseFloat(navigator.appVersion);

Sys.Browser.documentMode = 0;

if (navigator.userAgent.indexOf(' MSIE ') > -1) {

    Sys.Browser.agent = Sys.Browser.InternetExplorer;

    Sys.Browser.version = parseFloat(navigator.userAgent.match(/MSIE (\d+\.\d+)/)[1]);

    if (Sys.Browser.version >= 8) {

        if (document.documentMode >= 7) {

            Sys.Browser.documentMode = document.documentMode;    

        }

    }

    Sys.Browser.hasDebuggerStatement = true;

}

else if (navigator.userAgent.indexOf(' Firefox/') > -1) {

    Sys.Browser.agent = Sys.Browser.Firefox;

    Sys.Browser.version = parseFloat(navigator.userAgent.match(/ Firefox\/(\d+\.\d+)/)[1]);

    Sys.Browser.name = 'Firefox';

    Sys.Browser.hasDebuggerStatement = true;

}

else if (navigator.userAgent.indexOf(' AppleWebKit/') > -1) {

    Sys.Browser.agent = Sys.Browser.Safari;

    Sys.Browser.version = parseFloat(navigator.userAgent.match(/ AppleWebKit\/(\d+(\.\d+)?)/)[1]);

    Sys.Browser.name = 'Safari';

}

else if (navigator.userAgent.indexOf('Opera/') > -1) {

    Sys.Browser.agent = Sys.Browser.Opera;

}

Type.registerNamespace('Sys.UI');

 

Sys._Debug = function Sys$_Debug() {

    /// <summary locid="M:J#Sys.Debug.#ctor" />

    /// <field name="isDebug" type="Boolean" locid="F:J#Sys.Debug.isDebug"></field>

    if (arguments.length !== 0) throw Error.parameterCount();

}

    function Sys$_Debug$_appendConsole(text) {

        if ((typeof(Debug) !== 'undefined') && Debug.writeln) {

            Debug.writeln(text);

        }

        if (window.console && window.console.log) {

            window.console.log(text);

        }

        if (window.opera) {

            window.opera.postError(text);

        }

        if (window.debugService) {

            window.debugService.trace(text);

        }

    }

    function Sys$_Debug$_appendTrace(text) {

        var traceElement = document.getElementById('TraceConsole');

        if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {

            traceElement.value += text + '\n';

        }

    }

    function Sys$_Debug$assert(condition, message, displayCaller) {

        /// <summary locid="M:J#Sys.Debug.assert" />

        /// <param name="condition" type="Boolean"></param>

        /// <param name="message" type="String" optional="true" mayBeNull="true"></param>

        /// <param name="displayCaller" type="Boolean" optional="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "condition", type: Boolean},

            {name: "message", type: String, mayBeNull: true, optional: true},

            {name: "displayCaller", type: Boolean, optional: true}

        ]);

        if (e) throw e;

        if (!condition) {

            message = (displayCaller && this.assert.caller) ?

                String.format(Sys.Res.assertFailedCaller, message, this.assert.caller) :

                String.format(Sys.Res.assertFailed, message);

            if (confirm(String.format(Sys.Res.breakIntoDebugger, message))) {

                this.fail(message);

            }

        }

    }

    function Sys$_Debug$clearTrace() {

        /// <summary locid="M:J#Sys.Debug.clearTrace" />

        if (arguments.length !== 0) throw Error.parameterCount();

        var traceElement = document.getElementById('TraceConsole');

        if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {

            traceElement.value = '';

        }

    }

    function Sys$_Debug$fail(message) {

        /// <summary locid="M:J#Sys.Debug.fail" />

        /// <param name="message" type="String" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "message", type: String, mayBeNull: true}

        ]);

        if (e) throw e;

        this._appendConsole(message);

        if (Sys.Browser.hasDebuggerStatement) {

            eval('debugger');

        }

    }

    function Sys$_Debug$trace(text) {

        /// <summary locid="M:J#Sys.Debug.trace" />

        /// <param name="text"></param>

        var e = Function._validateParams(arguments, [

            {name: "text"}

        ]);

        if (e) throw e;

        this._appendConsole(text);

        this._appendTrace(text);

    }

    function Sys$_Debug$traceDump(object, name) {

        /// <summary locid="M:J#Sys.Debug.traceDump" />

        /// <param name="object" mayBeNull="true"></param>

        /// <param name="name" type="String" mayBeNull="true" optional="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "object", mayBeNull: true},

            {name: "name", type: String, mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        var text = this._traceDump(object, name, true);

    }

    function Sys$_Debug$_traceDump(object, name, recursive, indentationPadding, loopArray) {

        name = name? name : 'traceDump';

        indentationPadding = indentationPadding? indentationPadding : '';

        if (object === null) {

            this.trace(indentationPadding + name + ': null');

            return;

        }

        switch(typeof(object)) {

            case 'undefined':

                this.trace(indentationPadding + name + ': Undefined');

                break;

            case 'number': case 'string': case 'boolean':

                this.trace(indentationPadding + name + ': ' + object);

                break;

            default:

                if (Date.isInstanceOfType(object) || RegExp.isInstanceOfType(object)) {

                    this.trace(indentationPadding + name + ': ' + object.toString());

                    break;

                }

                if (!loopArray) {

                    loopArray = [];

                }

                else if (Array.contains(loopArray, object)) {

                    this.trace(indentationPadding + name + ': ...');

                    return;

                }

                Array.add(loopArray, object);

                if ((object == window) || (object === document) ||

                    (window.HTMLElement && (object instanceof HTMLElement)) ||

                    (typeof(object.nodeName) === 'string')) {

                    var tag = object.tagName? object.tagName : 'DomElement';

                    if (object.id) {

                        tag += ' - ' + object.id;

                    }

                    this.trace(indentationPadding + name + ' {' +  tag + '}');

                }

                else {

                    var typeName = Object.getTypeName(object);

                    this.trace(indentationPadding + name + (typeof(typeName) === 'string' ? ' {' + typeName + '}' : ''));

                    if ((indentationPadding === '') || recursive) {

                        indentationPadding += "    ";

                        var i, length, properties, p, v;

                        if (Array.isInstanceOfType(object)) {

                            length = object.length;

                            for (i = 0; i < length; i++) {

                                this._traceDump(object[i], '[' + i + ']', recursive, indentationPadding, loopArray);

                            }

                        }

                        else {

                            for (p in object) {

                                v = object[p];

                                if (!Function.isInstanceOfType(v)) {

                                    this._traceDump(v, p, recursive, indentationPadding, loopArray);

                                }

                            }

                        }

                    }

                }

                Array.remove(loopArray, object);

        }

    }

Sys._Debug.prototype = {

    _appendConsole: Sys$_Debug$_appendConsole,

    _appendTrace: Sys$_Debug$_appendTrace,

    assert: Sys$_Debug$assert,

    clearTrace: Sys$_Debug$clearTrace,

    fail: Sys$_Debug$fail,

    trace: Sys$_Debug$trace,

    traceDump: Sys$_Debug$traceDump,

    _traceDump: Sys$_Debug$_traceDump

}

Sys._Debug.registerClass('Sys._Debug');

Sys.Debug = new Sys._Debug();

    Sys.Debug.isDebug = true;

 

function Sys$Enum$parse(value, ignoreCase) {

    /// <summary locid="M:J#Sys.Enum.parse" />

    /// <param name="value" type="String"></param>

    /// <param name="ignoreCase" type="Boolean" optional="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", type: String},

        {name: "ignoreCase", type: Boolean, optional: true}

    ]);

    if (e) throw e;

    var values, parsed, val;

    if (ignoreCase) {

        values = this.__lowerCaseValues;

        if (!values) {

            this.__lowerCaseValues = values = {};

            var prototype = this.prototype;

            for (var name in prototype) {

                values[name.toLowerCase()] = prototype[name];

            }

        }

    }

    else {

        values = this.prototype;

    }

    if (!this.__flags) {

        val = (ignoreCase ? value.toLowerCase() : value);

        parsed = values[val.trim()];

        if (typeof(parsed) !== 'number') throw Error.argument('value', String.format(Sys.Res.enumInvalidValue, value, this.__typeName));

        return parsed;

    }

    else {

        var parts = (ignoreCase ? value.toLowerCase() : value).split(',');

        var v = 0;

        for (var i = parts.length - 1; i >= 0; i--) {

            var part = parts[i].trim();

            parsed = values[part];

            if (typeof(parsed) !== 'number') throw Error.argument('value', String.format(Sys.Res.enumInvalidValue, value.split(',')[i].trim(), this.__typeName));

            v |= parsed;

        }

        return v;

    }

}

function Sys$Enum$toString(value) {

    /// <summary locid="M:J#Sys.Enum.toString" />

    /// <param name="value" optional="true" mayBeNull="true"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "value", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    if ((typeof(value) === 'undefined') || (value === null)) return this.__string;

    if ((typeof(value) != 'number') || ((value % 1) !== 0)) throw Error.argumentType('value', Object.getType(value), this);

    var values = this.prototype;

    var i;

    if (!this.__flags || (value === 0)) {

        for (i in values) {

            if (values[i] === value) {

                return i;

            }

        }

    }

    else {

        var sorted = this.__sortedValues;

        if (!sorted) {

            sorted = [];

            for (i in values) {

                sorted[sorted.length] = {key: i, value: values[i]};

            }

            sorted.sort(function(a, b) {

                return a.value - b.value;

            });

            this.__sortedValues = sorted;

        }

        var parts = [];

        var v = value;

        for (i = sorted.length - 1; i >= 0; i--) {

            var kvp = sorted[i];

            var vali = kvp.value;

            if (vali === 0) continue;

            if ((vali & value) === vali) {

                parts[parts.length] = kvp.key;

                v -= vali;

                if (v === 0) break;

            }

        }

        if (parts.length && v === 0) return parts.reverse().join(', ');

    }

    throw Error.argumentOutOfRange('value', value, String.format(Sys.Res.enumInvalidValue, value, this.__typeName));

}

Type.prototype.registerEnum = function Type$registerEnum(name, flags) {

    /// <summary locid="M:J#Sys.UI.LineType.#ctor" />

    /// <param name="name" type="String"></param>

    /// <param name="flags" type="Boolean" optional="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "name", type: String},

        {name: "flags", type: Boolean, optional: true}

    ]);

    if (e) throw e;

    if (!Type.__fullyQualifiedIdentifierRegExp.test(name)) throw Error.argument('name', Sys.Res.notATypeName);

    var parsedName;

    try {

        parsedName = eval(name);

    }

    catch(e) {

        throw Error.argument('name', Sys.Res.argumentTypeName);

    }

    if (parsedName !== this) throw Error.argument('name', Sys.Res.badTypeName);

    if (Sys.__registeredTypes[name]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, name));

    for (var i in this.prototype) {

        var val = this.prototype[i];

        if (!Type.__identifierRegExp.test(i)) throw Error.invalidOperation(String.format(Sys.Res.enumInvalidValueName, i));

        if (typeof(val) !== 'number' || (val % 1) !== 0) throw Error.invalidOperation(Sys.Res.enumValueNotInteger);

        if (typeof(this[i]) !== 'undefined') throw Error.invalidOperation(String.format(Sys.Res.enumReservedName, i));

    }

    Sys.__upperCaseTypes[name.toUpperCase()] = this;

    for (var i in this.prototype) {

        this[i] = this.prototype[i];

    }

    this.__typeName = name;

    this.parse = Sys$Enum$parse;

    this.__string = this.toString();

    this.toString = Sys$Enum$toString;

    this.__flags = flags;

    this.__enum = true;

    Sys.__registeredTypes[name] = true;

}

Type.isEnum = function Type$isEnum(type) {

    /// <summary locid="M:J#Type.isEnum" />

    /// <param name="type" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "type", mayBeNull: true}

    ]);

    if (e) throw e;

    if ((typeof(type) === 'undefined') || (type === null)) return false;

    return !!type.__enum;

}

Type.isFlags = function Type$isFlags(type) {

    /// <summary locid="M:J#Type.isFlags" />

    /// <param name="type" mayBeNull="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "type", mayBeNull: true}

    ]);

    if (e) throw e;

    if ((typeof(type) === 'undefined') || (type === null)) return false;

    return !!type.__flags;

}

 

Sys.EventHandlerList = function Sys$EventHandlerList() {

    /// <summary locid="M:J#Sys.EventHandlerList.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    this._list = {};

}

    function Sys$EventHandlerList$addHandler(id, handler) {

        /// <summary locid="M:J#Sys.EventHandlerList.addHandler" />

        /// <param name="id" type="String"></param>

        /// <param name="handler" type="Function"></param>

        var e = Function._validateParams(arguments, [

            {name: "id", type: String},

            {name: "handler", type: Function}

        ]);

        if (e) throw e;

        Array.add(this._getEvent(id, true), handler);

    }

    function Sys$EventHandlerList$removeHandler(id, handler) {

        /// <summary locid="M:J#Sys.EventHandlerList.removeHandler" />

        /// <param name="id" type="String"></param>

        /// <param name="handler" type="Function"></param>

        var e = Function._validateParams(arguments, [

            {name: "id", type: String},

            {name: "handler", type: Function}

        ]);

        if (e) throw e;

        var evt = this._getEvent(id);

        if (!evt) return;

        Array.remove(evt, handler);

    }

    function Sys$EventHandlerList$getHandler(id) {

        /// <summary locid="M:J#Sys.EventHandlerList.getHandler" />

        /// <param name="id" type="String"></param>

        /// <returns type="Function"></returns>

        var e = Function._validateParams(arguments, [

            {name: "id", type: String}

        ]);

        if (e) throw e;

        var evt = this._getEvent(id);

        if (!evt || (evt.length === 0)) return null;

        evt = Array.clone(evt);

        return function(source, args) {

            for (var i = 0, l = evt.length; i < l; i++) {

                evt[i](source, args);

            }

        };

    }

    function Sys$EventHandlerList$_getEvent(id, create) {

        if (!this._list[id]) {

            if (!create) return null;

            this._list[id] = [];

        }

        return this._list[id];

    }

Sys.EventHandlerList.prototype = {

    addHandler: Sys$EventHandlerList$addHandler,

    removeHandler: Sys$EventHandlerList$removeHandler,

    getHandler: Sys$EventHandlerList$getHandler,

    _getEvent: Sys$EventHandlerList$_getEvent

}

Sys.EventHandlerList.registerClass('Sys.EventHandlerList');

 

Sys.EventArgs = function Sys$EventArgs() {

    /// <summary locid="M:J#Sys.EventArgs.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

}

Sys.EventArgs.registerClass('Sys.EventArgs');

Sys.EventArgs.Empty = new Sys.EventArgs();

 

Sys.CancelEventArgs = function Sys$CancelEventArgs() {

    /// <summary locid="M:J#Sys.CancelEventArgs.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys.CancelEventArgs.initializeBase(this);

    this._cancel = false;

}

    function Sys$CancelEventArgs$get_cancel() {

        /// <value type="Boolean" locid="P:J#Sys.CancelEventArgs.cancel"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._cancel;

    }

    function Sys$CancelEventArgs$set_cancel(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);

        if (e) throw e;

        this._cancel = value;

    }

Sys.CancelEventArgs.prototype = {

    get_cancel: Sys$CancelEventArgs$get_cancel,

    set_cancel: Sys$CancelEventArgs$set_cancel

}

Sys.CancelEventArgs.registerClass('Sys.CancelEventArgs', Sys.EventArgs);

 

Sys.INotifyPropertyChange = function Sys$INotifyPropertyChange() {

    /// <summary locid="M:J#Sys.INotifyPropertyChange.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

    function Sys$INotifyPropertyChange$add_propertyChanged(handler) {

    /// <summary locid="E:J#Sys.INotifyPropertyChange.propertyChanged" />

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$INotifyPropertyChange$remove_propertyChanged(handler) {

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        throw Error.notImplemented();

    }

Sys.INotifyPropertyChange.prototype = {

    add_propertyChanged: Sys$INotifyPropertyChange$add_propertyChanged,

    remove_propertyChanged: Sys$INotifyPropertyChange$remove_propertyChanged

}

Sys.INotifyPropertyChange.registerInterface('Sys.INotifyPropertyChange');

 

Sys.PropertyChangedEventArgs = function Sys$PropertyChangedEventArgs(propertyName) {

    /// <summary locid="M:J#Sys.PropertyChangedEventArgs.#ctor" />

    /// <param name="propertyName" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "propertyName", type: String}

    ]);

    if (e) throw e;

    Sys.PropertyChangedEventArgs.initializeBase(this);

    this._propertyName = propertyName;

}

 

    function Sys$PropertyChangedEventArgs$get_propertyName() {

        /// <value type="String" locid="P:J#Sys.PropertyChangedEventArgs.propertyName"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._propertyName;

    }

Sys.PropertyChangedEventArgs.prototype = {

    get_propertyName: Sys$PropertyChangedEventArgs$get_propertyName

}

Sys.PropertyChangedEventArgs.registerClass('Sys.PropertyChangedEventArgs', Sys.EventArgs);

 

Sys.INotifyDisposing = function Sys$INotifyDisposing() {

    /// <summary locid="M:J#Sys.INotifyDisposing.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

    function Sys$INotifyDisposing$add_disposing(handler) {

    /// <summary locid="E:J#Sys.INotifyDisposing.disposing" />

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$INotifyDisposing$remove_disposing(handler) {

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        throw Error.notImplemented();

    }

Sys.INotifyDisposing.prototype = {

    add_disposing: Sys$INotifyDisposing$add_disposing,

    remove_disposing: Sys$INotifyDisposing$remove_disposing

}

Sys.INotifyDisposing.registerInterface("Sys.INotifyDisposing");

 

Sys.Component = function Sys$Component() {

    /// <summary locid="M:J#Sys.Component.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    if (Sys.Application) Sys.Application.registerDisposableObject(this);

}

    function Sys$Component$get_events() {

        /// <value type="Sys.EventHandlerList" locid="P:J#Sys.Component.events"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._events) {

            this._events = new Sys.EventHandlerList();

        }

        return this._events;

    }

    function Sys$Component$get_id() {

        /// <value type="String" locid="P:J#Sys.Component.id"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._id;

    }

    function Sys$Component$set_id(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        if (this._idSet) throw Error.invalidOperation(Sys.Res.componentCantSetIdTwice);

        this._idSet = true;

        var oldId = this.get_id();

        if (oldId && Sys.Application.findComponent(oldId)) throw Error.invalidOperation(Sys.Res.componentCantSetIdAfterAddedToApp);

        this._id = value;

    }

    function Sys$Component$get_isInitialized() {

        /// <value type="Boolean" locid="P:J#Sys.Component.isInitialized"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._initialized;

    }

    function Sys$Component$get_isUpdating() {

        /// <value type="Boolean" locid="P:J#Sys.Component.isUpdating"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._updating;

    }

    function Sys$Component$add_disposing(handler) {

        /// <summary locid="E:J#Sys.Component.disposing" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().addHandler("disposing", handler);

    }

    function Sys$Component$remove_disposing(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("disposing", handler);

    }

    function Sys$Component$add_propertyChanged(handler) {

        /// <summary locid="E:J#Sys.Component.propertyChanged" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().addHandler("propertyChanged", handler);

    }

    function Sys$Component$remove_propertyChanged(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("propertyChanged", handler);

    }

    function Sys$Component$beginUpdate() {

        this._updating = true;

    }

    function Sys$Component$dispose() {

        if (this._events) {

            var handler = this._events.getHandler("disposing");

            if (handler) {

                handler(this, Sys.EventArgs.Empty);

            }

        }

        delete this._events;

        Sys.Application.unregisterDisposableObject(this);

        Sys.Application.removeComponent(this);

    }

    function Sys$Component$endUpdate() {

        this._updating = false;

        if (!this._initialized) this.initialize();

        this.updated();

    }

    function Sys$Component$initialize() {

        this._initialized = true;

    }

    function Sys$Component$raisePropertyChanged(propertyName) {

        /// <summary locid="M:J#Sys.Component.raisePropertyChanged" />

        /// <param name="propertyName" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "propertyName", type: String}

        ]);

        if (e) throw e;

        if (!this._events) return;

        var handler = this._events.getHandler("propertyChanged");

        if (handler) {

            handler(this, new Sys.PropertyChangedEventArgs(propertyName));

        }

    }

    function Sys$Component$updated() {

    }

Sys.Component.prototype = {

    _id: null,

    _idSet: false,

    _initialized: false,

    _updating: false,

    get_events: Sys$Component$get_events,

    get_id: Sys$Component$get_id,

    set_id: Sys$Component$set_id,

    get_isInitialized: Sys$Component$get_isInitialized,

    get_isUpdating: Sys$Component$get_isUpdating,

    add_disposing: Sys$Component$add_disposing,

    remove_disposing: Sys$Component$remove_disposing,

    add_propertyChanged: Sys$Component$add_propertyChanged,

    remove_propertyChanged: Sys$Component$remove_propertyChanged,

    beginUpdate: Sys$Component$beginUpdate,

    dispose: Sys$Component$dispose,

    endUpdate: Sys$Component$endUpdate,

    initialize: Sys$Component$initialize,

    raisePropertyChanged: Sys$Component$raisePropertyChanged,

    updated: Sys$Component$updated

}

Sys.Component.registerClass('Sys.Component', null, Sys.IDisposable, Sys.INotifyPropertyChange, Sys.INotifyDisposing);

function Sys$Component$_setProperties(target, properties) {

    /// <summary locid="M:J#Sys.Component._setProperties" />

    /// <param name="target"></param>

    /// <param name="properties"></param>

    var e = Function._validateParams(arguments, [

        {name: "target"},

        {name: "properties"}

    ]);

    if (e) throw e;

    var current;

    var targetType = Object.getType(target);

    var isObject = (targetType === Object) || (targetType === Sys.UI.DomElement);

    var isComponent = Sys.Component.isInstanceOfType(target) && !target.get_isUpdating();

    if (isComponent) target.beginUpdate();

    for (var name in properties) {

        var val = properties[name];

        var getter = isObject ? null : target["get_" + name];

        if (isObject || typeof(getter) !== 'function') {

            var targetVal = target[name];

            if (!isObject && typeof(targetVal) === 'undefined') throw Error.invalidOperation(String.format(Sys.Res.propertyUndefined, name));

            if (!val || (typeof(val) !== 'object') || (isObject && !targetVal)) {

                target[name] = val;

            }

            else {

                Sys$Component$_setProperties(targetVal, val);

            }

        }

        else {

            var setter = target["set_" + name];

            if (typeof(setter) === 'function') {

                setter.apply(target, [val]);

            }

            else if (val instanceof Array) {

                current = getter.apply(target);

                if (!(current instanceof Array)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNotAnArray, name));

                for (var i = 0, j = current.length, l= val.length; i < l; i++, j++) {

                    current[j] = val[i];

                }

            }

            else if ((typeof(val) === 'object') && (Object.getType(val) === Object)) {

                current = getter.apply(target);

                if ((typeof(current) === 'undefined') || (current === null)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNullOrUndefined, name));

                Sys$Component$_setProperties(current, val);

            }

            else {

                throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name));

            }

        }

    }

    if (isComponent) target.endUpdate();

}

function Sys$Component$_setReferences(component, references) {

    for (var name in references) {

        var setter = component["set_" + name];

        var reference = $find(references[name]);

        if (typeof(setter) !== 'function') throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name));

        if (!reference) throw Error.invalidOperation(String.format(Sys.Res.referenceNotFound, references[name]));

        setter.apply(component, [reference]);

    }

}

var $create = Sys.Component.create = function Sys$Component$create(type, properties, events, references, element) {

    /// <summary locid="M:J#Sys.Component.create" />

    /// <param name="type" type="Type"></param>

    /// <param name="properties" optional="true" mayBeNull="true"></param>

    /// <param name="events" optional="true" mayBeNull="true"></param>

    /// <param name="references" optional="true" mayBeNull="true"></param>

    /// <param name="element" domElement="true" optional="true" mayBeNull="true"></param>

    /// <returns type="Sys.UI.Component"></returns>

    var e = Function._validateParams(arguments, [

        {name: "type", type: Type},

        {name: "properties", mayBeNull: true, optional: true},

        {name: "events", mayBeNull: true, optional: true},

        {name: "references", mayBeNull: true, optional: true},

        {name: "element", mayBeNull: true, domElement: true, optional: true}

    ]);

    if (e) throw e;

    if (!type.inheritsFrom(Sys.Component)) {

        throw Error.argument('type', String.format(Sys.Res.createNotComponent, type.getName()));

    }

    if (type.inheritsFrom(Sys.UI.Behavior) || type.inheritsFrom(Sys.UI.Control)) {

        if (!element) throw Error.argument('element', Sys.Res.createNoDom);

    }

    else if (element) throw Error.argument('element', Sys.Res.createComponentOnDom);

    var component = (element ? new type(element): new type());

    var app = Sys.Application;

    var creatingComponents = app.get_isCreatingComponents();

    component.beginUpdate();

    if (properties) {

        Sys$Component$_setProperties(component, properties);

    }

    if (events) {

        for (var name in events) {

            if (!(component["add_" + name] instanceof Function)) throw new Error.invalidOperation(String.format(Sys.Res.undefinedEvent, name));

            if (!(events[name] instanceof Function)) throw new Error.invalidOperation(Sys.Res.eventHandlerNotFunction);

            component["add_" + name](events[name]);

        }

    }

    if (component.get_id()) {

        app.addComponent(component);

    }

    if (creatingComponents) {

        app._createdComponents[app._createdComponents.length] = component;

        if (references) {

            app._addComponentToSecondPass(component, references);

        }

        else {

            component.endUpdate();

        }

    }

    else {

        if (references) {

            Sys$Component$_setReferences(component, references);

        }

        component.endUpdate();

    }

    return component;

}

 

Sys.UI.MouseButton = function Sys$UI$MouseButton() {

    /// <summary locid="M:J#Sys.UI.MouseButton.#ctor" />

    /// <field name="leftButton" type="Number" integer="true" static="true" locid="F:J#Sys.UI.MouseButton.leftButton"></field>

    /// <field name="middleButton" type="Number" integer="true" static="true" locid="F:J#Sys.UI.MouseButton.middleButton"></field>

    /// <field name="rightButton" type="Number" integer="true" static="true" locid="F:J#Sys.UI.MouseButton.rightButton"></field>

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

Sys.UI.MouseButton.prototype = {

    leftButton: 0,

    middleButton: 1,

    rightButton: 2

}

Sys.UI.MouseButton.registerEnum("Sys.UI.MouseButton");

 

Sys.UI.Key = function Sys$UI$Key() {

    /// <summary locid="M:J#Sys.UI.Key.#ctor" />

    /// <field name="backspace" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.backspace"></field>

    /// <field name="tab" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.tab"></field>

    /// <field name="enter" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.enter"></field>

    /// <field name="esc" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.esc"></field>

    /// <field name="space" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.space"></field>

    /// <field name="pageUp" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.pageUp"></field>

    /// <field name="pageDown" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.pageDown"></field>

    /// <field name="end" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.end"></field>

    /// <field name="home" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.home"></field>

    /// <field name="left" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.left"></field>

    /// <field name="up" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.up"></field>

    /// <field name="right" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.right"></field>

    /// <field name="down" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.down"></field>

    /// <field name="del" type="Number" integer="true" static="true" locid="F:J#Sys.UI.Key.del"></field>

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

Sys.UI.Key.prototype = {

    backspace: 8,

    tab: 9,

    enter: 13,

    esc: 27,

    space: 32,

    pageUp: 33,

    pageDown: 34,

    end: 35,

    home: 36,

    left: 37,

    up: 38,

    right: 39,

    down: 40,

    del: 127

}

Sys.UI.Key.registerEnum("Sys.UI.Key");

 

Sys.UI.Point = function Sys$UI$Point(x, y) {

    /// <summary locid="M:J#Sys.UI.Point.#ctor" />

    /// <param name="x" type="Number" integer="true"></param>

    /// <param name="y" type="Number" integer="true"></param>

    /// <field name="x" type="Number" integer="true" locid="F:J#Sys.UI.Point.x"></field>

    /// <field name="y" type="Number" integer="true" locid="F:J#Sys.UI.Point.y"></field>

    var e = Function._validateParams(arguments, [

        {name: "x", type: Number, integer: true},

        {name: "y", type: Number, integer: true}

    ]);

    if (e) throw e;

    this.x = x;

    this.y = y;

}

Sys.UI.Point.registerClass('Sys.UI.Point');

 

Sys.UI.Bounds = function Sys$UI$Bounds(x, y, width, height) {

    /// <summary locid="M:J#Sys.UI.Bounds.#ctor" />

    /// <param name="x" type="Number" integer="true"></param>

    /// <param name="y" type="Number" integer="true"></param>

    /// <param name="height" type="Number" integer="true"></param>

    /// <param name="width" type="Number" integer="true"></param>

    /// <field name="x" type="Number" integer="true" locid="F:J#Sys.UI.Bounds.x"></field>

    /// <field name="y" type="Number" integer="true" locid="F:J#Sys.UI.Bounds.y"></field>

    /// <field name="height" type="Number" integer="true" locid="F:J#Sys.UI.Bounds.height"></field>

    /// <field name="width" type="Number" integer="true" locid="F:J#Sys.UI.Bounds.width"></field>

    var e = Function._validateParams(arguments, [

        {name: "x", type: Number, integer: true},

        {name: "y", type: Number, integer: true},

        {name: "height", type: Number, integer: true},

        {name: "width", type: Number, integer: true}

    ]);

    if (e) throw e;

    this.x = x;

    this.y = y;

    this.height = height;

    this.width = width;

}

Sys.UI.Bounds.registerClass('Sys.UI.Bounds');

 

Sys.UI.DomEvent = function Sys$UI$DomEvent(eventObject) {

    /// <summary locid="M:J#Sys.UI.DomEvent.#ctor" />

    /// <param name="eventObject"></param>

    /// <field name="altKey" type="Boolean" locid="F:J#Sys.UI.DomEvent.altKey"></field>

    /// <field name="button" type="Sys.UI.MouseButton" locid="F:J#Sys.UI.DomEvent.button"></field>

    /// <field name="charCode" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.charCode"></field>

    /// <field name="clientX" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.clientX"></field>

    /// <field name="clientY" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.clientY"></field>

    /// <field name="ctrlKey" type="Boolean" locid="F:J#Sys.UI.DomEvent.ctrlKey"></field>

    /// <field name="keyCode" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.keyCode"></field>

    /// <field name="offsetX" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.offsetX"></field>

    /// <field name="offsetY" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.offsetY"></field>

    /// <field name="screenX" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.screenX"></field>

    /// <field name="screenY" type="Number" integer="true" locid="F:J#Sys.UI.DomEvent.screenY"></field>

    /// <field name="shiftKey" type="Boolean" locid="F:J#Sys.UI.DomEvent.shiftKey"></field>

    /// <field name="target" locid="F:J#Sys.UI.DomEvent.target"></field>

    /// <field name="type" type="String" locid="F:J#Sys.UI.DomEvent.type"></field>

    var e = Function._validateParams(arguments, [

        {name: "eventObject"}

    ]);

    if (e) throw e;

    var e = eventObject;

    var etype = this.type = e.type.toLowerCase();

    this.rawEvent = e;

    this.altKey = e.altKey;

    if (typeof(e.button) !== 'undefined') {

        this.button = (typeof(e.which) !== 'undefined') ? e.button :

            (e.button === 4) ? Sys.UI.MouseButton.middleButton :

            (e.button === 2) ? Sys.UI.MouseButton.rightButton :

            Sys.UI.MouseButton.leftButton;

    }

    if (etype === 'keypress') {

        this.charCode = e.charCode || e.keyCode;

    }

    else if (e.keyCode && (e.keyCode === 46)) {

        this.keyCode = 127;

    }

    else {

        this.keyCode = e.keyCode;

    }

    this.clientX = e.clientX;

    this.clientY = e.clientY;

    this.ctrlKey = e.ctrlKey;

    this.target = e.target ? e.target : e.srcElement;

    if (!etype.startsWith('key')) {

        if ((typeof(e.offsetX) !== 'undefined') && (typeof(e.offsetY) !== 'undefined')) {

            this.offsetX = e.offsetX;

            this.offsetY = e.offsetY;

        }

        else if (this.target && (this.target.nodeType !== 3) && (typeof(e.clientX) === 'number')) {

            var loc = Sys.UI.DomElement.getLocation(this.target);

            var w = Sys.UI.DomElement._getWindow(this.target);

            this.offsetX = (w.pageXOffset || 0) + e.clientX - loc.x;

            this.offsetY = (w.pageYOffset || 0) + e.clientY - loc.y;

        }

    }

    this.screenX = e.screenX;

    this.screenY = e.screenY;

    this.shiftKey = e.shiftKey;

}

    function Sys$UI$DomEvent$preventDefault() {

        /// <summary locid="M:J#Sys.UI.DomEvent.preventDefault" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this.rawEvent.preventDefault) {

            this.rawEvent.preventDefault();

        }

        else if (window.event) {

            this.rawEvent.returnValue = false;

        }

    }

    function Sys$UI$DomEvent$stopPropagation() {

        /// <summary locid="M:J#Sys.UI.DomEvent.stopPropagation" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this.rawEvent.stopPropagation) {

            this.rawEvent.stopPropagation();

        }

        else if (window.event) {

            this.rawEvent.cancelBubble = true;

        }

    }

Sys.UI.DomEvent.prototype = {

    preventDefault: Sys$UI$DomEvent$preventDefault,

    stopPropagation: Sys$UI$DomEvent$stopPropagation

}

Sys.UI.DomEvent.registerClass('Sys.UI.DomEvent');

var $addHandler = Sys.UI.DomEvent.addHandler = function Sys$UI$DomEvent$addHandler(element, eventName, handler) {

    /// <summary locid="M:J#Sys.UI.DomEvent.addHandler" />

    /// <param name="element"></param>

    /// <param name="eventName" type="String"></param>

    /// <param name="handler" type="Function"></param>

    var e = Function._validateParams(arguments, [

        {name: "element"},

        {name: "eventName", type: String},

        {name: "handler", type: Function}

    ]);

    if (e) throw e;

    Sys.UI.DomEvent._ensureDomNode(element);

    if (eventName === "error") throw Error.invalidOperation(Sys.Res.addHandlerCantBeUsedForError);

    if (!element._events) {

        element._events = {};

    }

    var eventCache = element._events[eventName];

    if (!eventCache) {

        element._events[eventName] = eventCache = [];

    }

    var browserHandler;

    if (element.addEventListener) {

        browserHandler = function(e) {

            return handler.call(element, new Sys.UI.DomEvent(e));

        }

        element.addEventListener(eventName, browserHandler, false);

    }

    else if (element.attachEvent) {

        browserHandler = function() {

            var e = {};

            try {e = Sys.UI.DomElement._getWindow(element).event} catch(ex) {}

            return handler.call(element, new Sys.UI.DomEvent(e));

        }

        element.attachEvent('on' + eventName, browserHandler);

    }

    eventCache[eventCache.length] = {handler: handler, browserHandler: browserHandler};

}

var $addHandlers = Sys.UI.DomEvent.addHandlers = function Sys$UI$DomEvent$addHandlers(element, events, handlerOwner) {

    /// <summary locid="M:J#Sys.UI.DomEvent.addHandlers" />

    /// <param name="element"></param>

    /// <param name="events" type="Object"></param>

    /// <param name="handlerOwner" optional="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "element"},

        {name: "events", type: Object},

        {name: "handlerOwner", optional: true}

    ]);

    if (e) throw e;

    Sys.UI.DomEvent._ensureDomNode(element);

    for (var name in events) {

        var handler = events[name];

        if (typeof(handler) !== 'function') throw Error.invalidOperation(Sys.Res.cantAddNonFunctionhandler);

        if (handlerOwner) {

            handler = Function.createDelegate(handlerOwner, handler);

        }

        $addHandler(element, name, handler);

    }

}

var $clearHandlers = Sys.UI.DomEvent.clearHandlers = function Sys$UI$DomEvent$clearHandlers(element) {

    /// <summary locid="M:J#Sys.UI.DomEvent.clearHandlers" />

    /// <param name="element"></param>

    var e = Function._validateParams(arguments, [

        {name: "element"}

    ]);

    if (e) throw e;

    Sys.UI.DomEvent._ensureDomNode(element);

    if (element._events) {

        var cache = element._events;

        for (var name in cache) {

            var handlers = cache[name];

            for (var i = handlers.length - 1; i >= 0; i--) {

                $removeHandler(element, name, handlers[i].handler);

            }

        }

        element._events = null;

    }

}

var $removeHandler = Sys.UI.DomEvent.removeHandler = function Sys$UI$DomEvent$removeHandler(element, eventName, handler) {

    /// <summary locid="M:J#Sys.UI.DomEvent.removeHandler" />

    /// <param name="element"></param>

    /// <param name="eventName" type="String"></param>

    /// <param name="handler" type="Function"></param>

    var e = Function._validateParams(arguments, [

        {name: "element"},

        {name: "eventName", type: String},

        {name: "handler", type: Function}

    ]);

    if (e) throw e;

    Sys.UI.DomEvent._ensureDomNode(element);

    var browserHandler = null;

    if ((typeof(element._events) !== 'object') || (element._events == null)) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);

    var cache = element._events[eventName];

    if (!(cache instanceof Array)) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);

    for (var i = 0, l = cache.length; i < l; i++) {

        if (cache[i].handler === handler) {

            browserHandler = cache[i].browserHandler;

            break;

        }

    }

    if (typeof(browserHandler) !== 'function') throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);

    if (element.removeEventListener) {

        element.removeEventListener(eventName, browserHandler, false);

    }

    else if (element.detachEvent) {

        element.detachEvent('on' + eventName, browserHandler);

    }

    cache.splice(i, 1);

}

Sys.UI.DomEvent._ensureDomNode = function Sys$UI$DomEvent$_ensureDomNode(element) {

    if (element.tagName && (element.tagName.toUpperCase() === "SCRIPT")) return;

    

    var doc = element.ownerDocument || element.document || element;

    if ((typeof(element.document) !== 'object') && (element != doc) && (typeof(element.nodeType) !== 'number')) {

        throw Error.argument("element", Sys.Res.argumentDomNode);

    }

}

 

Sys.UI.DomElement = function Sys$UI$DomElement() {

    /// <summary locid="M:J#Sys.UI.DomElement.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

Sys.UI.DomElement.registerClass('Sys.UI.DomElement');

Sys.UI.DomElement.addCssClass = function Sys$UI$DomElement$addCssClass(element, className) {

    /// <summary locid="M:J#Sys.UI.DomElement.addCssClass" />

    /// <param name="element" domElement="true"></param>

    /// <param name="className" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "className", type: String}

    ]);

    if (e) throw e;

    if (!Sys.UI.DomElement.containsCssClass(element, className)) {

        if (element.className === '') {

            element.className = className;

        }

        else {

            element.className += ' ' + className;

        }

    }

}

Sys.UI.DomElement.containsCssClass = function Sys$UI$DomElement$containsCssClass(element, className) {

    /// <summary locid="M:J#Sys.UI.DomElement.containsCssClass" />

    /// <param name="element" domElement="true"></param>

    /// <param name="className" type="String"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "className", type: String}

    ]);

    if (e) throw e;

    return Array.contains(element.className.split(' '), className);

}

Sys.UI.DomElement.getBounds = function Sys$UI$DomElement$getBounds(element) {

    /// <summary locid="M:J#Sys.UI.DomElement.getBounds" />

    /// <param name="element" domElement="true"></param>

    /// <returns type="Sys.UI.Bounds"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    var offset = Sys.UI.DomElement.getLocation(element);

    return new Sys.UI.Bounds(offset.x, offset.y, element.offsetWidth || 0, element.offsetHeight || 0);

}

var $get = Sys.UI.DomElement.getElementById = function Sys$UI$DomElement$getElementById(id, element) {

    /// <summary locid="M:J#Sys.UI.DomElement.getElementById" />

    /// <param name="id" type="String"></param>

    /// <param name="element" domElement="true" optional="true" mayBeNull="true"></param>

    /// <returns domElement="true" mayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "id", type: String},

        {name: "element", mayBeNull: true, domElement: true, optional: true}

    ]);

    if (e) throw e;

    if (!element) return document.getElementById(id);

    if (element.getElementById) return element.getElementById(id);

    var nodeQueue = [];

    var childNodes = element.childNodes;

    for (var i = 0; i < childNodes.length; i++) {

        var node = childNodes[i];

        if (node.nodeType == 1) {

            nodeQueue[nodeQueue.length] = node;

        }

    }

    while (nodeQueue.length) {

        node = nodeQueue.shift();

        if (node.id == id) {

            return node;

        }

        childNodes = node.childNodes;

        for (i = 0; i < childNodes.length; i++) {

            node = childNodes[i];

            if (node.nodeType == 1) {

                nodeQueue[nodeQueue.length] = node;

            }

        }

    }

    return null;

}

switch(Sys.Browser.agent) {

    case Sys.Browser.InternetExplorer:

        Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {

            /// <summary locid="M:J#Sys.UI.DomElement.getLocation" />

            /// <param name="element" domElement="true"></param>

            /// <returns type="Sys.UI.Point"></returns>

            var e = Function._validateParams(arguments, [

                {name: "element", domElement: true}

            ]);

            if (e) throw e;

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

            var clientRect = element.getBoundingClientRect();

            if (!clientRect) {

                return new Sys.UI.Point(0,0);

            }

            var documentElement = element.ownerDocument.documentElement;

            var offsetX = clientRect.left - 2 + documentElement.scrollLeft,

                offsetY = clientRect.top - 2 + documentElement.scrollTop;

            

            try {

                var f = element.ownerDocument.parentWindow.frameElement || null;

                if (f) {

                    var offset = (f.frameBorder === "0" || f.frameBorder === "no") ? 2 : 0;

                    offsetX += offset;

                    offsetY += offset;

                }

            }

            catch(ex) {

            }    

            

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

        }

        break;

    case Sys.Browser.Safari:

        Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {

            /// <summary locid="M:J#Sys.UI.DomElement.getLocation" />

            /// <param name="element" domElement="true"></param>

            /// <returns type="Sys.UI.Point"></returns>

            var e = Function._validateParams(arguments, [

                {name: "element", domElement: true}

            ]);

            if (e) throw e;

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

            var offsetX = 0;

            var offsetY = 0;

            var previous = null;

            var previousStyle = null;

            var currentStyle;

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

                currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);

                var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;

                if ((parent.offsetLeft || parent.offsetTop) &&

                    ((tagName !== "BODY") || (!previousStyle || previousStyle.position !== "absolute"))) {

                    offsetX += parent.offsetLeft;

                    offsetY += parent.offsetTop;

                }

            }

            currentStyle = Sys.UI.DomElement._getCurrentStyle(element);

            var elementPosition = currentStyle ? currentStyle.position : null;

            if (!elementPosition || (elementPosition !== "absolute")) {

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

                    tagName = parent.tagName ? parent.tagName.toUpperCase() : null;

                    if ((tagName !== "BODY") && (tagName !== "HTML") && (parent.scrollLeft || parent.scrollTop)) {

                        offsetX -= (parent.scrollLeft || 0);

                        offsetY -= (parent.scrollTop || 0);

                    }

                    currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);

                    var parentPosition = currentStyle ? currentStyle.position : null;

                    if (parentPosition && (parentPosition === "absolute")) break;

                }

            }

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

        }

        break;

    case Sys.Browser.Opera:

        Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {

            /// <summary locid="M:J#Sys.UI.DomElement.getLocation" />

            /// <param name="element" domElement="true"></param>

            /// <returns type="Sys.UI.Point"></returns>

            var e = Function._validateParams(arguments, [

                {name: "element", domElement: true}

            ]);

            if (e) throw e;

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

            var offsetX = 0;

            var offsetY = 0;

            var previous = null;

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

                var tagName = parent.tagName;

                offsetX += parent.offsetLeft || 0;

                offsetY += parent.offsetTop || 0;

            }

            var elementPosition = element.style.position;

            var elementPositioned = elementPosition && (elementPosition !== "static");

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

                tagName = parent.tagName ? parent.tagName.toUpperCase() : null;

                if ((tagName !== "BODY") && (tagName !== "HTML") && (parent.scrollLeft || parent.scrollTop) &&

                    ((elementPositioned &&

                    ((parent.style.overflow === "scroll") || (parent.style.overflow === "auto"))))) {

                    offsetX -= (parent.scrollLeft || 0);

                    offsetY -= (parent.scrollTop || 0);

                }

                var parentPosition = (parent && parent.style) ? parent.style.position : null;

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

            }

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

        }

        break;

    default:

        Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {

            /// <summary locid="M:J#Sys.UI.DomElement.getLocation" />

            /// <param name="element" domElement="true"></param>

            /// <returns type="Sys.UI.Point"></returns>

            var e = Function._validateParams(arguments, [

                {name: "element", domElement: true}

            ]);

            if (e) throw e;

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

            var offsetX = 0;

            var offsetY = 0;

            var previous = null;

            var previousStyle = null;

            var currentStyle = null;

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

                var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;

                currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);

                if ((parent.offsetLeft || parent.offsetTop) &&

                    !((tagName === "BODY") &&

                    (!previousStyle || previousStyle.position !== "absolute"))) {

                    offsetX += parent.offsetLeft;

                    offsetY += parent.offsetTop;

                }

                if (previous !== null && currentStyle) {

                    if ((tagName !== "TABLE") && (tagName !== "TD") && (tagName !== "HTML")) {

                        offsetX += parseInt(currentStyle.borderLeftWidth) || 0;

                        offsetY += parseInt(currentStyle.borderTopWidth) || 0;

                    }

                    if (tagName === "TABLE" &&

                        (currentStyle.position === "relative" || currentStyle.position === "absolute")) {

                        offsetX += parseInt(currentStyle.marginLeft) || 0;

                        offsetY += parseInt(currentStyle.marginTop) || 0;

                    }

                }

            }

            currentStyle = Sys.UI.DomElement._getCurrentStyle(element);

            var elementPosition = currentStyle ? currentStyle.position : null;

            if (!elementPosition || (elementPosition !== "absolute")) {

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

                    tagName = parent.tagName ? parent.tagName.toUpperCase() : null;

                    if ((tagName !== "BODY") && (tagName !== "HTML") && (parent.scrollLeft || parent.scrollTop)) {

                        offsetX -= (parent.scrollLeft || 0);

                        offsetY -= (parent.scrollTop || 0);

                        currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);

                        if (currentStyle) {

                            offsetX += parseInt(currentStyle.borderLeftWidth) || 0;

                            offsetY += parseInt(currentStyle.borderTopWidth) || 0;

                        }

                    }

                }

            }

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

        }

        break;

}

Sys.UI.DomElement.removeCssClass = function Sys$UI$DomElement$removeCssClass(element, className) {

    /// <summary locid="M:J#Sys.UI.DomElement.removeCssClass" />

    /// <param name="element" domElement="true"></param>

    /// <param name="className" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "className", type: String}

    ]);

    if (e) throw e;

    var currentClassName = ' ' + element.className + ' ';

    var index = currentClassName.indexOf(' ' + className + ' ');

    if (index >= 0) {

        element.className = (currentClassName.substr(0, index) + ' ' +

            currentClassName.substring(index + className.length + 1, currentClassName.length)).trim();

    }

}

Sys.UI.DomElement.setLocation = function Sys$UI$DomElement$setLocation(element, x, y) {

    /// <summary locid="M:J#Sys.UI.DomElement.setLocation" />

    /// <param name="element" domElement="true"></param>

    /// <param name="x" type="Number" integer="true"></param>

    /// <param name="y" type="Number" integer="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "x", type: Number, integer: true},

        {name: "y", type: Number, integer: true}

    ]);

    if (e) throw e;

    var style = element.style;

    style.position = 'absolute';

    style.left = x + "px";

    style.top = y + "px";

}

Sys.UI.DomElement.toggleCssClass = function Sys$UI$DomElement$toggleCssClass(element, className) {

    /// <summary locid="M:J#Sys.UI.DomElement.toggleCssClass" />

    /// <param name="element" domElement="true"></param>

    /// <param name="className" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "className", type: String}

    ]);

    if (e) throw e;

    if (Sys.UI.DomElement.containsCssClass(element, className)) {

        Sys.UI.DomElement.removeCssClass(element, className);

    }

    else {

        Sys.UI.DomElement.addCssClass(element, className);

    }

}

Sys.UI.DomElement.getVisibilityMode = function Sys$UI$DomElement$getVisibilityMode(element) {

    /// <summary locid="M:J#Sys.UI.DomElement.getVisibilityMode" />

    /// <param name="element" domElement="true"></param>

    /// <returns type="Sys.UI.VisibilityMode"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    return (element._visibilityMode === Sys.UI.VisibilityMode.hide) ?

        Sys.UI.VisibilityMode.hide :

        Sys.UI.VisibilityMode.collapse;

}

Sys.UI.DomElement.setVisibilityMode = function Sys$UI$DomElement$setVisibilityMode(element, value) {

    /// <summary locid="M:J#Sys.UI.DomElement.setVisibilityMode" />

    /// <param name="element" domElement="true"></param>

    /// <param name="value" type="Sys.UI.VisibilityMode"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "value", type: Sys.UI.VisibilityMode}

    ]);

    if (e) throw e;

    Sys.UI.DomElement._ensureOldDisplayMode(element);

    if (element._visibilityMode !== value) {

        element._visibilityMode = value;

        if (Sys.UI.DomElement.getVisible(element) === false) {

            if (element._visibilityMode === Sys.UI.VisibilityMode.hide) {

                element.style.display = element._oldDisplayMode;

            }

            else {

                element.style.display = 'none';

            }

        }

        element._visibilityMode = value;

    }

}

Sys.UI.DomElement.getVisible = function Sys$UI$DomElement$getVisible(element) {

    /// <summary locid="M:J#Sys.UI.DomElement.getVisible" />

    /// <param name="element" domElement="true"></param>

    /// <returns type="Boolean"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);

    if (!style) return true;

    return (style.visibility !== 'hidden') && (style.display !== 'none');

}

Sys.UI.DomElement.setVisible = function Sys$UI$DomElement$setVisible(element, value) {

    /// <summary locid="M:J#Sys.UI.DomElement.setVisible" />

    /// <param name="element" domElement="true"></param>

    /// <param name="value" type="Boolean"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "value", type: Boolean}

    ]);

    if (e) throw e;

    if (value !== Sys.UI.DomElement.getVisible(element)) {

        Sys.UI.DomElement._ensureOldDisplayMode(element);

        element.style.visibility = value ? 'visible' : 'hidden';

        if (value || (element._visibilityMode === Sys.UI.VisibilityMode.hide)) {

            element.style.display = element._oldDisplayMode;

        }

        else {

            element.style.display = 'none';

        }

    }

}

Sys.UI.DomElement._ensureOldDisplayMode = function Sys$UI$DomElement$_ensureOldDisplayMode(element) {

    if (!element._oldDisplayMode) {

        var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);

        element._oldDisplayMode = style ? style.display : null;

        if (!element._oldDisplayMode || element._oldDisplayMode === 'none') {

            switch(element.tagName.toUpperCase()) {

                case 'DIV': case 'P': case 'ADDRESS': case 'BLOCKQUOTE': case 'BODY': case 'COL':

                case 'COLGROUP': case 'DD': case 'DL': case 'DT': case 'FIELDSET': case 'FORM':

                case 'H1': case 'H2': case 'H3': case 'H4': case 'H5': case 'H6': case 'HR':

                case 'IFRAME': case 'LEGEND': case 'OL': case 'PRE': case 'TABLE': case 'TD':

                case 'TH': case 'TR': case 'UL':

                    element._oldDisplayMode = 'block';

                    break;

                case 'LI':

                    element._oldDisplayMode = 'list-item';

                    break;

                default:

                    element._oldDisplayMode = 'inline';

            }

        }

    }

}

Sys.UI.DomElement._getWindow = function Sys$UI$DomElement$_getWindow(element) {

    var doc = element.ownerDocument || element.document || element;

    return doc.defaultView || doc.parentWindow;

}

Sys.UI.DomElement._getCurrentStyle = function Sys$UI$DomElement$_getCurrentStyle(element) {

    if (element.nodeType === 3) return null;

    var w = Sys.UI.DomElement._getWindow(element);

    if (element.documentElement) element = element.documentElement;

    var computedStyle = (w && (element !== w) && w.getComputedStyle) ?

        w.getComputedStyle(element, null) :

        element.currentStyle || element.style;

    if (!computedStyle && (Sys.Browser.agent === Sys.Browser.Safari) && element.style) {

        var oldDisplay = element.style.display;

        var oldPosition = element.style.position;

        element.style.position = 'absolute';

        element.style.display = 'block';

        var style = w.getComputedStyle(element, null);

        element.style.display = oldDisplay;

        element.style.position = oldPosition;

        computedStyle = {};

        for (var n in style) {

            computedStyle[n] = style[n];

        }

        computedStyle.display = 'none';

    }

    return computedStyle;

}

 

Sys.IContainer = function Sys$IContainer() {

    throw Error.notImplemented();

}

    function Sys$IContainer$addComponent(component) {

        /// <summary locid="M:J#Sys.IContainer.addComponent" />

        /// <param name="component" type="Sys.Component"></param>

        var e = Function._validateParams(arguments, [

            {name: "component", type: Sys.Component}

        ]);

        if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$IContainer$removeComponent(component) {

        /// <summary locid="M:J#Sys.IContainer.removeComponent" />

        /// <param name="component" type="Sys.Component"></param>

        var e = Function._validateParams(arguments, [

            {name: "component", type: Sys.Component}

        ]);

        if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$IContainer$findComponent(id) {

        /// <summary locid="M:J#Sys.IContainer.findComponent" />

        /// <param name="id" type="String"></param>

        /// <returns type="Sys.Component"></returns>

        var e = Function._validateParams(arguments, [

            {name: "id", type: String}

        ]);

        if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$IContainer$getComponents() {

        /// <summary locid="M:J#Sys.IContainer.getComponents" />

        /// <returns type="Array" elementType="Sys.Component"></returns>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

Sys.IContainer.prototype = {

    addComponent: Sys$IContainer$addComponent,

    removeComponent: Sys$IContainer$removeComponent,

    findComponent: Sys$IContainer$findComponent,

    getComponents: Sys$IContainer$getComponents

}

Sys.IContainer.registerInterface("Sys.IContainer");

 

Sys._ScriptLoader = function Sys$_ScriptLoader() {

    this._scriptsToLoad = null;

    this._sessions = [];

    this._scriptLoadedDelegate = Function.createDelegate(this, this._scriptLoadedHandler);

}

    function Sys$_ScriptLoader$dispose() {

        this._stopSession();

        this._loading = false;

        if(this._events) {

            delete this._events;

        }

        this._sessions = null;

        this._currentSession = null;

        this._scriptLoadedDelegate = null;        

    }

    function Sys$_ScriptLoader$loadScripts(scriptTimeout, allScriptsLoadedCallback, scriptLoadFailedCallback, scriptLoadTimeoutCallback) {

        /// <summary locid="M:J#Sys._ScriptLoader.loadScripts" />

        /// <param name="scriptTimeout" type="Number" integer="true"></param>

        /// <param name="allScriptsLoadedCallback" type="Function" mayBeNull="true"></param>

        /// <param name="scriptLoadFailedCallback" type="Function" mayBeNull="true"></param>

        /// <param name="scriptLoadTimeoutCallback" type="Function" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "scriptTimeout", type: Number, integer: true},

            {name: "allScriptsLoadedCallback", type: Function, mayBeNull: true},

            {name: "scriptLoadFailedCallback", type: Function, mayBeNull: true},

            {name: "scriptLoadTimeoutCallback", type: Function, mayBeNull: true}

        ]);

        if (e) throw e;

        var session = {

            allScriptsLoadedCallback: allScriptsLoadedCallback,

            scriptLoadFailedCallback: scriptLoadFailedCallback,

            scriptLoadTimeoutCallback: scriptLoadTimeoutCallback,

            scriptsToLoad: this._scriptsToLoad,

            scriptTimeout: scriptTimeout };

        this._scriptsToLoad = null;

        this._sessions[this._sessions.length] = session;

        

        if (!this._loading) {

            this._nextSession();

        }

    }

    function Sys$_ScriptLoader$notifyScriptLoaded() {

        /// <summary locid="M:J#Sys._ScriptLoader.notifyScriptLoaded" />

        if (arguments.length !== 0) throw Error.parameterCount();

        

        if(!this._loading) {

            return;

        }

        this._currentTask._notified++;

        

        if(Sys.Browser.agent === Sys.Browser.Safari) {           

            if(this._currentTask._notified === 1) {

                window.setTimeout(Function.createDelegate(this, function() {

                    this._scriptLoadedHandler(this._currentTask.get_scriptElement(), true);

                }), 0);

            }

        }

    }

    function Sys$_ScriptLoader$queueCustomScriptTag(scriptAttributes) {

        /// <summary locid="M:J#Sys._ScriptLoader.queueCustomScriptTag" />

        /// <param name="scriptAttributes" mayBeNull="false"></param>

        var e = Function._validateParams(arguments, [

            {name: "scriptAttributes"}

        ]);

        if (e) throw e;

        if(!this._scriptsToLoad) {

            this._scriptsToLoad = [];

        }

        Array.add(this._scriptsToLoad, scriptAttributes);

    }

    function Sys$_ScriptLoader$queueScriptBlock(scriptContent) {

        /// <summary locid="M:J#Sys._ScriptLoader.queueScriptBlock" />

        /// <param name="scriptContent" type="String" mayBeNull="false"></param>

        var e = Function._validateParams(arguments, [

            {name: "scriptContent", type: String}

        ]);

        if (e) throw e;

        if(!this._scriptsToLoad) {

            this._scriptsToLoad = [];

        }

        Array.add(this._scriptsToLoad, {text: scriptContent});

    }

    function Sys$_ScriptLoader$queueScriptReference(scriptUrl) {

        /// <summary locid="M:J#Sys._ScriptLoader.queueScriptReference" />

        /// <param name="scriptUrl" type="String" mayBeNull="false"></param>

        var e = Function._validateParams(arguments, [

            {name: "scriptUrl", type: String}

        ]);

        if (e) throw e;

        if(!this._scriptsToLoad) {

            this._scriptsToLoad = [];

        }

        Array.add(this._scriptsToLoad, {src: scriptUrl});

    }

    function Sys$_ScriptLoader$_createScriptElement(queuedScript) {

        var scriptElement = document.createElement('script');

        scriptElement.type = 'text/javascript';

        for (var attr in queuedScript) {

            scriptElement[attr] = queuedScript[attr];

        }

        

        return scriptElement;

    }

    function Sys$_ScriptLoader$_loadScriptsInternal() {

        var session = this._currentSession;

        if (session.scriptsToLoad && session.scriptsToLoad.length > 0) {

            var nextScript = Array.dequeue(session.scriptsToLoad);

            var scriptElement = this._createScriptElement(nextScript);

            

            if (scriptElement.text && Sys.Browser.agent === Sys.Browser.Safari) {

                scriptElement.innerHTML = scriptElement.text;

                delete scriptElement.text;

            }            

            if (typeof(nextScript.src) === "string") {

                this._currentTask = new Sys._ScriptLoaderTask(scriptElement, this._scriptLoadedDelegate);

                this._currentTask.execute();

            }

            else {

                var headElements = document.getElementsByTagName('head');

                if (headElements.length === 0) {

                     throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);

                }

                else {

                     headElements[0].appendChild(scriptElement);

                }

                

                

                Sys._ScriptLoader._clearScript(scriptElement);

                this._loadScriptsInternal();

            }

        }

        else {

            this._stopSession();

            var callback = session.allScriptsLoadedCallback;

            if(callback) {

                callback(this);

            }

            this._nextSession();

        }

    }

    function Sys$_ScriptLoader$_nextSession() {

        if (this._sessions.length === 0) {

            this._loading = false;

            this._currentSession = null;

            return;

        }

        this._loading = true;

        

        var session = Array.dequeue(this._sessions);

        this._currentSession = session;

        this._loadScriptsInternal();

    }

    function Sys$_ScriptLoader$_raiseError(multipleCallbacks) {

        var callback = this._currentSession.scriptLoadFailedCallback;

        var scriptElement = this._currentTask.get_scriptElement();

        this._stopSession();

        

        if(callback) {

            callback(this, scriptElement, multipleCallbacks);

            this._nextSession();

        }

        else {

            this._loading = false;

            throw Sys._ScriptLoader._errorScriptLoadFailed(scriptElement.src, multipleCallbacks);

        }

    }

    function Sys$_ScriptLoader$_scriptLoadedHandler(scriptElement, loaded) {

        if(loaded && this._currentTask._notified) {

            if(this._currentTask._notified > 1) {

                this._raiseError(true);

            }

            else {

                Array.add(Sys._ScriptLoader._getLoadedScripts(), scriptElement.src);

                this._currentTask.dispose();

                this._currentTask = null;

                this._loadScriptsInternal();

            }

        }

        else {

            this._raiseError(false);

        }

    }

    function Sys$_ScriptLoader$_scriptLoadTimeoutHandler() {

        var callback = this._currentSession.scriptLoadTimeoutCallback;

        this._stopSession();

        if(callback) {

            callback(this);

        }

        this._nextSession();

    }

    function Sys$_ScriptLoader$_stopSession() {

        if(this._currentTask) {

            this._currentTask.dispose();

            this._currentTask = null;

        }

    }

Sys._ScriptLoader.prototype = {

    dispose: Sys$_ScriptLoader$dispose,

    loadScripts: Sys$_ScriptLoader$loadScripts,

    notifyScriptLoaded: Sys$_ScriptLoader$notifyScriptLoaded,

    queueCustomScriptTag: Sys$_ScriptLoader$queueCustomScriptTag,

    queueScriptBlock: Sys$_ScriptLoader$queueScriptBlock,

    queueScriptReference: Sys$_ScriptLoader$queueScriptReference,

    _createScriptElement: Sys$_ScriptLoader$_createScriptElement,

    _loadScriptsInternal: Sys$_ScriptLoader$_loadScriptsInternal,

    _nextSession: Sys$_ScriptLoader$_nextSession,

    _raiseError: Sys$_ScriptLoader$_raiseError,

    _scriptLoadedHandler: Sys$_ScriptLoader$_scriptLoadedHandler,

    _scriptLoadTimeoutHandler: Sys$_ScriptLoader$_scriptLoadTimeoutHandler,

    _stopSession: Sys$_ScriptLoader$_stopSession    

}

Sys._ScriptLoader.registerClass('Sys._ScriptLoader', null, Sys.IDisposable);

Sys._ScriptLoader.getInstance = function Sys$_ScriptLoader$getInstance() {

    var sl = Sys._ScriptLoader._activeInstance;

    if(!sl) {

        sl = Sys._ScriptLoader._activeInstance = new Sys._ScriptLoader();

    }

    return sl;

}

Sys._ScriptLoader.isScriptLoaded = function Sys$_ScriptLoader$isScriptLoaded(scriptSrc) {

    var dummyScript = document.createElement('script');

    dummyScript.src = scriptSrc;

    return Array.contains(Sys._ScriptLoader._getLoadedScripts(), dummyScript.src);

}

Sys._ScriptLoader.readLoadedScripts = function Sys$_ScriptLoader$readLoadedScripts() {

    if(!Sys._ScriptLoader._referencedScripts) {

        var referencedScripts = Sys._ScriptLoader._referencedScripts = [];

        var existingScripts = document.getElementsByTagName('script');

        for (i = existingScripts.length - 1; i >= 0; i--) {

            var scriptNode = existingScripts[i];

            var scriptSrc = scriptNode.src;

            if (scriptSrc.length) {

                if (!Array.contains(referencedScripts, scriptSrc)) {

                    Array.add(referencedScripts, scriptSrc);

                }

            }

        }

    }

}

Sys._ScriptLoader._clearScript = function Sys$_ScriptLoader$_clearScript(scriptElement) {

    if (!Sys.Debug.isDebug) {

        scriptElement.parentNode.removeChild(scriptElement);

    }

}

Sys._ScriptLoader._errorScriptLoadFailed = function Sys$_ScriptLoader$_errorScriptLoadFailed(scriptUrl, multipleCallbacks) {

    var errorMessage;

    if(multipleCallbacks) {

        errorMessage = Sys.Res.scriptLoadMultipleCallbacks;

    }

    else {

        errorMessage = Sys.Res.scriptLoadFailedDebug;

    }

    var displayMessage = "Sys.ScriptLoadFailedException: " + String.format(errorMessage, scriptUrl);

    var e = Error.create(displayMessage, {name: 'Sys.ScriptLoadFailedException', 'scriptUrl': scriptUrl });

    e.popStackFrame();

    return e;

}

Sys._ScriptLoader._getLoadedScripts = function Sys$_ScriptLoader$_getLoadedScripts() {

    if(!Sys._ScriptLoader._referencedScripts) {

        Sys._ScriptLoader._referencedScripts = [];

        Sys._ScriptLoader.readLoadedScripts();

    }

    return Sys._ScriptLoader._referencedScripts;

}

 

Sys._ScriptLoaderTask = function Sys$_ScriptLoaderTask(scriptElement, completedCallback) {

    /// <summary locid="M:J#Sys._ScriptLoaderTask.#ctor" />

    /// <param name="scriptElement" domElement="true"></param>

    /// <param name="completedCallback" type="Function"></param>

    var e = Function._validateParams(arguments, [

        {name: "scriptElement", domElement: true},

        {name: "completedCallback", type: Function}

    ]);

    if (e) throw e;

    this._scriptElement = scriptElement;

    this._completedCallback = completedCallback;

    this._notified = 0;

}

    function Sys$_ScriptLoaderTask$get_scriptElement() {

        /// <value domElement="true" locid="P:J#Sys._ScriptLoaderTask.scriptElement"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._scriptElement;

    }

    function Sys$_ScriptLoaderTask$dispose() {

        if(this._disposed) {

            return;

        }

        this._disposed = true;

        this._removeScriptElementHandlers();

        Sys._ScriptLoader._clearScript(this._scriptElement);

        this._scriptElement = null;

    }

    function Sys$_ScriptLoaderTask$execute() {

        /// <summary locid="M:J#Sys._ScriptLoaderTask.execute" />

        if (arguments.length !== 0) throw Error.parameterCount();

        this._addScriptElementHandlers();

        var headElements = document.getElementsByTagName('head');

        if (headElements.length === 0) {

             throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);

        }

        else {

             headElements[0].appendChild(this._scriptElement);

        }

    }

    function Sys$_ScriptLoaderTask$_addScriptElementHandlers() {

        this._scriptLoadDelegate = Function.createDelegate(this, this._scriptLoadHandler);

        

        if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {

            this._scriptElement.readyState = 'loaded';

            $addHandler(this._scriptElement, 'load', this._scriptLoadDelegate);

        }

        else {

            $addHandler(this._scriptElement, 'readystatechange', this._scriptLoadDelegate);

        }    

        if (this._scriptElement.addEventListener) {

            this._scriptErrorDelegate = Function.createDelegate(this, this._scriptErrorHandler);

            this._scriptElement.addEventListener('error', this._scriptErrorDelegate, false);

        }

    }

    function Sys$_ScriptLoaderTask$_removeScriptElementHandlers() {

        if(this._scriptLoadDelegate) {

            var scriptElement = this.get_scriptElement();

            if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {

                $removeHandler(scriptElement, 'load', this._scriptLoadDelegate);

            }

            else {

                $removeHandler(scriptElement, 'readystatechange', this._scriptLoadDelegate);

            }

            if (this._scriptErrorDelegate) {

                this._scriptElement.removeEventListener('error', this._scriptErrorDelegate, false);

                this._scriptErrorDelegate = null;

            }

            this._scriptLoadDelegate = null;

        }

    }

    function Sys$_ScriptLoaderTask$_scriptErrorHandler() {

        if(this._disposed) {

            return;

        }

        

        this._completedCallback(this.get_scriptElement(), false);

    }

    function Sys$_ScriptLoaderTask$_scriptLoadHandler() {

        if(this._disposed) {

            return;

        }

        var scriptElement = this.get_scriptElement();

        if ((scriptElement.readyState !== 'loaded') &&

            (scriptElement.readyState !== 'complete')) {

            return;

        }

        

        var _this = this;

        window.setTimeout(function() {

            _this._completedCallback(scriptElement, true);

        }, 0);

    }

Sys._ScriptLoaderTask.prototype = {

    get_scriptElement: Sys$_ScriptLoaderTask$get_scriptElement,

    dispose: Sys$_ScriptLoaderTask$dispose,

    execute: Sys$_ScriptLoaderTask$execute,

    _addScriptElementHandlers: Sys$_ScriptLoaderTask$_addScriptElementHandlers,    

    _removeScriptElementHandlers: Sys$_ScriptLoaderTask$_removeScriptElementHandlers,    

    _scriptErrorHandler: Sys$_ScriptLoaderTask$_scriptErrorHandler,

    _scriptLoadHandler: Sys$_ScriptLoaderTask$_scriptLoadHandler  

}

Sys._ScriptLoaderTask.registerClass("Sys._ScriptLoaderTask", null, Sys.IDisposable);

 

Sys.ApplicationLoadEventArgs = function Sys$ApplicationLoadEventArgs(components, isPartialLoad) {

    /// <summary locid="M:J#Sys.ApplicationLoadEventArgs.#ctor" />

    /// <param name="components" type="Array" elementType="Sys.Component"></param>

    /// <param name="isPartialLoad" type="Boolean"></param>

    var e = Function._validateParams(arguments, [

        {name: "components", type: Array, elementType: Sys.Component},

        {name: "isPartialLoad", type: Boolean}

    ]);

    if (e) throw e;

    Sys.ApplicationLoadEventArgs.initializeBase(this);

    this._components = components;

    this._isPartialLoad = isPartialLoad;

}

 

    function Sys$ApplicationLoadEventArgs$get_components() {

        /// <value type="Array" elementType="Sys.Component" locid="P:J#Sys.ApplicationLoadEventArgs.components"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._components;

    }

    function Sys$ApplicationLoadEventArgs$get_isPartialLoad() {

        /// <value type="Boolean" locid="P:J#Sys.ApplicationLoadEventArgs.isPartialLoad"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._isPartialLoad;

    }

Sys.ApplicationLoadEventArgs.prototype = {

    get_components: Sys$ApplicationLoadEventArgs$get_components,

    get_isPartialLoad: Sys$ApplicationLoadEventArgs$get_isPartialLoad

}

Sys.ApplicationLoadEventArgs.registerClass('Sys.ApplicationLoadEventArgs', Sys.EventArgs);

Sys.HistoryEventArgs = function Sys$HistoryEventArgs(state) {

    /// <summary locid="M:J#Sys.HistoryEventArgs.#ctor" />

    /// <param name="state" type="Object"></param>

    var e = Function._validateParams(arguments, [

        {name: "state", type: Object}

    ]);

    if (e) throw e;

    Sys.HistoryEventArgs.initializeBase(this);

    this._state = state;

}

    function Sys$HistoryEventArgs$get_state() {

        /// <value type="Object" locid="P:J#Sys.HistoryEventArgs.state"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._state;

    }

Sys.HistoryEventArgs.prototype = {

    get_state: Sys$HistoryEventArgs$get_state

}

Sys.HistoryEventArgs.registerClass('Sys.HistoryEventArgs', Sys.EventArgs);

 

Sys._Application = function Sys$_Application() {

    /// <summary locid="M:J#Sys.Application.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys._Application.initializeBase(this);

    this._disposableObjects = [];

    this._components = {};

    this._createdComponents = [];

    this._secondPassComponents = [];

    this._appLoadHandler = null;

    this._beginRequestHandler = null;

    this._clientId = null;

    this._currentEntry = '';

    this._endRequestHandler = null;

    this._history = null;

    this._enableHistory = false;

    this._historyEnabledInScriptManager = false;

    this._historyFrame = null;

    this._historyInitialized = false;

    this._historyInitialLength = 0;

    this._historyLength = 0;

    this._historyPointIsNew = false;

    this._ignoreTimer = false;

    this._initialState = null;

    this._state = {};

    this._timerCookie = 0;

    this._timerHandler = null;

    this._uniqueId = null;

    this._unloadHandlerDelegate = Function.createDelegate(this, this._unloadHandler);

    this._loadHandlerDelegate = Function.createDelegate(this, this._loadHandler);

    Sys.UI.DomEvent.addHandler(window, "unload", this._unloadHandlerDelegate);

    Sys.UI.DomEvent.addHandler(window, "load", this._loadHandlerDelegate);

}

    function Sys$_Application$get_isCreatingComponents() {

        /// <value type="Boolean" locid="P:J#Sys.Application.isCreatingComponents"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._creatingComponents;

    }

    function Sys$_Application$get_stateString() {

        /// <value type="String" locid="P:J#Sys.Application.stateString"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        var hash = window.location.hash;

        if (this._isSafari2()) {

            var history = this._getHistory();

            if (history) {

                hash = history[window.history.length - this._historyInitialLength];

            }

        }

        if ((hash.length > 0) && (hash.charAt(0) === '#')) {

            hash = hash.substring(1);

        }

        if (Sys.Browser.agent === Sys.Browser.Firefox) {

            hash = this._serializeState(this._deserializeState(hash, true));

        }

        return hash;

    }

    function Sys$_Application$get_enableHistory() {

        /// <value type="Boolean" locid="P:J#Sys.Application.enableHistory"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._enableHistory;

    }

    function Sys$_Application$set_enableHistory(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);

        if (e) throw e;

        if (this._initialized && !this._initializing) {

            throw Error.invalidOperation(Sys.Res.historyCannotEnableHistory);

        }

        else if (this._historyEnabledInScriptManager && !value) {

            throw Error.invalidOperation(Sys.Res.invalidHistorySettingCombination);

        }

        this._enableHistory = value;

    }

    function Sys$_Application$add_init(handler) {

        /// <summary locid="E:J#Sys.Application.init" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        if (this._initialized) {

            handler(this, Sys.EventArgs.Empty);

        }

        else {

            this.get_events().addHandler("init", handler);

        }

    }

    function Sys$_Application$remove_init(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("init", handler);

    }

    function Sys$_Application$add_load(handler) {

        /// <summary locid="E:J#Sys.Application.load" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().addHandler("load", handler);

    }

    function Sys$_Application$remove_load(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("load", handler);

    }

    function Sys$_Application$add_navigate(handler) {

        /// <summary locid="E:J#Sys.Application.navigate" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().addHandler("navigate", handler);

    }

    function Sys$_Application$remove_navigate(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("navigate", handler);

    }

    function Sys$_Application$add_unload(handler) {

        /// <summary locid="E:J#Sys.Application.unload" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().addHandler("unload", handler);

    }

    function Sys$_Application$remove_unload(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this.get_events().removeHandler("unload", handler);

    }

    function Sys$_Application$addComponent(component) {

        /// <summary locid="M:J#Sys.Application.addComponent" />

        /// <param name="component" type="Sys.Component"></param>

        var e = Function._validateParams(arguments, [

            {name: "component", type: Sys.Component}

        ]);

        if (e) throw e;

        var id = component.get_id();

        if (!id) throw Error.invalidOperation(Sys.Res.cantAddWithoutId);

        if (typeof(this._components[id]) !== 'undefined') throw Error.invalidOperation(String.format(Sys.Res.appDuplicateComponent, id));

        this._components[id] = component;

    }

    function Sys$_Application$addHistoryPoint(state, title) {

        /// <summary locid="M:J#Sys.Application.addHistoryPoint" />

        /// <param name="state" type="Object"></param>

        /// <param name="title" type="String" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "state", type: Object},

            {name: "title", type: String, mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        if (!this._enableHistory) throw Error.invalidOperation(Sys.Res.historyCannotAddHistoryPointWithHistoryDisabled);

        for (var n in state) {

            var v = state[n];

            var t = typeof(v);

            if ((v !== null) && ((t === 'object') || (t === 'function') || (t === 'undefined'))) {

                throw Error.argument('state', Sys.Res.stateMustBeStringDictionary);

            }

        }

        this._ensureHistory();

        var initialState = this._state;

        for (var key in state) {

            var value = state[key];

            if (value === null) {

                if (typeof(initialState[key]) !== 'undefined') {

                    delete initialState[key];

                }

            }

            else {

                initialState[key] = value;

            }

        }

        var entry = this._serializeState(initialState);

        this._historyPointIsNew = true;

        this._setState(entry, title);

        this._raiseNavigate();

    }

    function Sys$_Application$beginCreateComponents() {

        /// <summary locid="M:J#Sys.Application.beginCreateComponents" />

        if (arguments.length !== 0) throw Error.parameterCount();

        this._creatingComponents = true;

    }

    function Sys$_Application$dispose() {

        /// <summary locid="M:J#Sys.Application.dispose" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._disposing) {

            this._disposing = true;

            if (this._timerCookie) {

                window.clearTimeout(this._timerCookie);

                delete this._timerCookie;

            }

            if (this._endRequestHandler) {

                Sys.WebForms.PageRequestManager.getInstance().remove_endRequest(this._endRequestHandler);

                delete this._endRequestHandler;

            }

            if (this._beginRequestHandler) {

                Sys.WebForms.PageRequestManager.getInstance().remove_beginRequest(this._beginRequestHandler);

                delete this._beginRequestHandler;

            }

            if (window.pageUnload) {

                window.pageUnload(this, Sys.EventArgs.Empty);

            }

            var unloadHandler = this.get_events().getHandler("unload");

            if (unloadHandler) {

                unloadHandler(this, Sys.EventArgs.Empty);

            }

            var disposableObjects = Array.clone(this._disposableObjects);

            for (var i = 0, l = disposableObjects.length; i < l; i++) {

                disposableObjects[i].dispose();

            }

            Array.clear(this._disposableObjects);

            Sys.UI.DomEvent.removeHandler(window, "unload", this._unloadHandlerDelegate);

            if(this._loadHandlerDelegate) {

                Sys.UI.DomEvent.removeHandler(window, "load", this._loadHandlerDelegate);

                this._loadHandlerDelegate = null;

            }

            var sl = Sys._ScriptLoader.getInstance();

            if(sl) {

                sl.dispose();

            }

            Sys._Application.callBaseMethod(this, 'dispose');

        }

    }

    function Sys$_Application$endCreateComponents() {

        /// <summary locid="M:J#Sys.Application.endCreateComponents" />

        if (arguments.length !== 0) throw Error.parameterCount();

        var components = this._secondPassComponents;

        for (var i = 0, l = components.length; i < l; i++) {

            var component = components[i].component;

            Sys$Component$_setReferences(component, components[i].references);

            component.endUpdate();

        }

        this._secondPassComponents = [];

        this._creatingComponents = false;

    }

    function Sys$_Application$findComponent(id, parent) {

        /// <summary locid="M:J#Sys.Application.findComponent" />

        /// <param name="id" type="String"></param>

        /// <param name="parent" optional="true" mayBeNull="true"></param>

        /// <returns type="Sys.Component" mayBeNull="true"></returns>

        var e = Function._validateParams(arguments, [

            {name: "id", type: String},

            {name: "parent", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        return (parent ?

            ((Sys.IContainer.isInstanceOfType(parent)) ?

                parent.findComponent(id) :

                parent[id] || null) :

            Sys.Application._components[id] || null);

    }

    function Sys$_Application$getComponents() {

        /// <summary locid="M:J#Sys.Application.getComponents" />

        /// <returns type="Array" elementType="Sys.Component"></returns>

        if (arguments.length !== 0) throw Error.parameterCount();

        var res = [];

        var components = this._components;

        for (var name in components) {

            res[res.length] = components[name];

        }

        return res;

    }

    function Sys$_Application$initialize() {

        /// <summary locid="M:J#Sys.Application.initialize" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if(!this._initialized && !this._initializing) {

            this._initializing = true;

            window.setTimeout(Function.createDelegate(this, this._doInitialize), 0);

        }

    }

    function Sys$_Application$notifyScriptLoaded() {

        /// <summary locid="M:J#Sys.Application.notifyScriptLoaded" />

        if (arguments.length !== 0) throw Error.parameterCount();

        var sl = Sys._ScriptLoader.getInstance();

        if(sl) {

            sl.notifyScriptLoaded();

        }

    }

    function Sys$_Application$registerDisposableObject(object) {

        /// <summary locid="M:J#Sys.Application.registerDisposableObject" />

        /// <param name="object" type="Sys.IDisposable"></param>

        var e = Function._validateParams(arguments, [

            {name: "object", type: Sys.IDisposable}

        ]);

        if (e) throw e;

        if (!this._disposing) {

            this._disposableObjects[this._disposableObjects.length] = object;

        }

    }

    function Sys$_Application$raiseLoad() {

        /// <summary locid="M:J#Sys.Application.raiseLoad" />

        if (arguments.length !== 0) throw Error.parameterCount();

        var h = this.get_events().getHandler("load");

        var args = new Sys.ApplicationLoadEventArgs(Array.clone(this._createdComponents), !this._initializing);

        if (h) {

            h(this, args);

        }

        if (window.pageLoad) {

            window.pageLoad(this, args);

        }

        this._createdComponents = [];

    }

    function Sys$_Application$removeComponent(component) {

        /// <summary locid="M:J#Sys.Application.removeComponent" />

        /// <param name="component" type="Sys.Component"></param>

        var e = Function._validateParams(arguments, [

            {name: "component", type: Sys.Component}

        ]);

        if (e) throw e;

        var id = component.get_id();

        if (id) delete this._components[id];

    }

    function Sys$_Application$setServerId(clientId, uniqueId) {

        /// <summary locid="M:J#Sys.Application.setServerId" />

        /// <param name="clientId" type="String"></param>

        /// <param name="uniqueId" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "clientId", type: String},

            {name: "uniqueId", type: String}

        ]);

        if (e) throw e;

        this._clientId = clientId;

        this._uniqueId = uniqueId;

    }

    function Sys$_Application$setServerState(value) {

        /// <summary locid="M:J#Sys.Application.setServerState" />

        /// <param name="value" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "value", type: String}

        ]);

        if (e) throw e;

        this._ensureHistory();

        this._state.__s = value;

        this._updateHiddenField(value);

    }

    function Sys$_Application$unregisterDisposableObject(object) {

        /// <summary locid="M:J#Sys.Application.unregisterDisposableObject" />

        /// <param name="object" type="Sys.IDisposable"></param>

        var e = Function._validateParams(arguments, [

            {name: "object", type: Sys.IDisposable}

        ]);

        if (e) throw e;

        if (!this._disposing) {

            Array.remove(this._disposableObjects, object);

        }

    }

    function Sys$_Application$_addComponentToSecondPass(component, references) {

        this._secondPassComponents[this._secondPassComponents.length] = {component: component, references: references};

    }

    function Sys$_Application$_deserializeState(entry, skipDecodeUri) {

        var result = {};

        entry = entry || '';

        var serverSeparator = entry.indexOf('&&');

        if ((serverSeparator !== -1) && (serverSeparator + 2 < entry.length)) {

            result.__s = entry.substr(serverSeparator + 2);

            entry = entry.substr(0, serverSeparator);

        }

        var tokens = entry.split('&');

        for (var i = 0, l = tokens.length; i < l; i++) {

            var token = tokens[i];

            var equal = token.indexOf('=');

            if ((equal !== -1) && (equal + 1 < token.length)) {

                var name = token.substr(0, equal);

                var value = token.substr(equal + 1);

                result[name] = skipDecodeUri ? value : decodeURIComponent(value);

            }

        }

        return result;

    }

    function Sys$_Application$_doInitialize() {

        Sys._Application.callBaseMethod(this, 'initialize');

        

        var handler = this.get_events().getHandler("init");

        if (handler) {

            this.beginCreateComponents();

            handler(this, Sys.EventArgs.Empty);

            this.endCreateComponents();

        }

        if (Sys.WebForms) {

            this._beginRequestHandler = Function.createDelegate(this, this._onPageRequestManagerBeginRequest);

            Sys.WebForms.PageRequestManager.getInstance().add_beginRequest(this._beginRequestHandler);

            this._endRequestHandler = Function.createDelegate(this, this._onPageRequestManagerEndRequest);

            Sys.WebForms.PageRequestManager.getInstance().add_endRequest(this._endRequestHandler);

        }

        

        var loadedEntry = this.get_stateString();

        if (loadedEntry !== this._currentEntry) {

            this._navigate(loadedEntry);

        }

 

        this.raiseLoad();

        this._initializing = false;

    }

    function Sys$_Application$_enableHistoryInScriptManager() {

        this._enableHistory = true;

        this._historyEnabledInScriptManager = true;

    }

    function Sys$_Application$_ensureHistory() {

        if (!this._historyInitialized && this._enableHistory) {

            if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) && (Sys.Browser.documentMode < 8)) {

                this._historyFrame = document.getElementById('__historyFrame');

                if (!this._historyFrame) throw Error.invalidOperation(Sys.Res.historyMissingFrame);

                this._ignoreIFrame = true;

            }

            if (this._isSafari2()) {

                var historyElement = document.getElementById('__history');

                if (!historyElement) throw Error.invalidOperation(Sys.Res.historyMissingHiddenInput);

                this._setHistory([window.location.hash]);

                this._historyInitialLength = window.history.length;

            }

            

            this._timerHandler = Function.createDelegate(this, this._onIdle);

            this._timerCookie = window.setTimeout(this._timerHandler, 100);

            

            try {

                this._initialState = this._deserializeState(this.get_stateString());

            } catch(e) {}

            

            this._historyInitialized = true;

        }

    }

    function Sys$_Application$_getHistory() {

        var historyElement = document.getElementById('__history');

        if (!historyElement) return '';

        var v = historyElement.value;

        return v ? Sys.Serialization.JavaScriptSerializer.deserialize(v, true) : '';

    }

    function Sys$_Application$_isSafari2() {

        return (Sys.Browser.agent === Sys.Browser.Safari) &&

            (Sys.Browser.version <= 419.3);

    }

    function Sys$_Application$_loadHandler() {

        if(this._loadHandlerDelegate) {

            Sys.UI.DomEvent.removeHandler(window, "load", this._loadHandlerDelegate);

            this._loadHandlerDelegate = null;

        }

        this.initialize();

    }

    function Sys$_Application$_navigate(entry) {

        this._ensureHistory();

        var state = this._deserializeState(entry);

        

        if (this._uniqueId) {

            var oldServerEntry = this._state.__s || '';

            var newServerEntry = state.__s || '';

            if (newServerEntry !== oldServerEntry) {

                this._updateHiddenField(newServerEntry);

                __doPostBack(this._uniqueId, newServerEntry);

                this._state = state;

                return;

            }

        }

        this._setState(entry);

        this._state = state;

        this._raiseNavigate();

    }

    function Sys$_Application$_onIdle() {

        delete this._timerCookie;

        

        var entry = this.get_stateString();

        if (entry !== this._currentEntry) {

            if (!this._ignoreTimer) {

                this._historyPointIsNew = false;

                this._navigate(entry);

                this._historyLength = window.history.length;

            }

        }

        else {

            this._ignoreTimer = false;

        }

        this._timerCookie = window.setTimeout(this._timerHandler, 100);

    }

    function Sys$_Application$_onIFrameLoad(entry) {

        this._ensureHistory();

        if (!this._ignoreIFrame) {

            this._historyPointIsNew = false;

            this._navigate(entry);

        }

        this._ignoreIFrame = false;

    }

    function Sys$_Application$_onPageRequestManagerBeginRequest(sender, args) {

        this._ignoreTimer = true;

    }

    function Sys$_Application$_onPageRequestManagerEndRequest(sender, args) {

        var dataItem = args.get_dataItems()[this._clientId];

        var eventTarget = document.getElementById("__EVENTTARGET");

        if (eventTarget && eventTarget.value === this._uniqueId) {

            eventTarget.value = '';

        }

        if (typeof(dataItem) !== 'undefined') {

            this.setServerState(dataItem);

            this._historyPointIsNew = true;

        }

        else {

            this._ignoreTimer = false;

        }

        var entry = this._serializeState(this._state);

        if (entry !== this._currentEntry) {

            this._ignoreTimer = true;

            this._setState(entry);

            this._raiseNavigate();

        }

    }

    function Sys$_Application$_raiseNavigate() {

        var h = this.get_events().getHandler("navigate");

        var stateClone = {};

        for (var key in this._state) {

            if (key !== '__s') {

                stateClone[key] = this._state[key];

            }

        }

        var args = new Sys.HistoryEventArgs(stateClone);

        if (h) {

            h(this, args);

        }

    }

    function Sys$_Application$_serializeState(state) {

        var serialized = [];

        for (var key in state) {

            var value = state[key];

            if (key === '__s') {

                var serverState = value;

            }

            else {

                if (key.indexOf('=') !== -1) throw Error.argument('state', Sys.Res.stateFieldNameInvalid);

                serialized[serialized.length] = key + '=' + encodeURIComponent(value);

            }

        }

        return serialized.join('&') + (serverState ? '&&' + serverState : '');

    }

    function Sys$_Application$_setHistory(historyArray) {

        var historyElement = document.getElementById('__history');

        if (historyElement) {

            historyElement.value = Sys.Serialization.JavaScriptSerializer.serialize(historyArray);

        }

    }

    function Sys$_Application$_setState(entry, title) {

        entry = entry || '';

        if (entry !== this._currentEntry) {

            if (window.theForm) {

                var action = window.theForm.action;

                var hashIndex = action.indexOf('#');

                window.theForm.action = ((hashIndex !== -1) ? action.substring(0, hashIndex) : action) + '#' + entry;

            }

            

            if (this._historyFrame && this._historyPointIsNew) {

                this._ignoreIFrame = true;

                this._historyPointIsNew = false;

                var frameDoc = this._historyFrame.contentWindow.document;

                frameDoc.open("javascript:'<html></html>'");

                frameDoc.write("<html><head><title>" + (title || document.title) +

                    "</title><scri" + "pt type=\"text/javascript\">parent.Sys.Application._onIFrameLoad('" + 

                    entry + "');</scri" + "pt></head><body></body></html>");

                frameDoc.close();

            }

            this._ignoreTimer = false;

            var currentHash = this.get_stateString();

            this._currentEntry = entry;

            if (entry !== currentHash) {

                var loc = document.location;

                if (loc.href.length - loc.hash.length + entry.length > 1024) {

                    throw Error.invalidOperation(Sys.Res.urlMustBeLessThan1024chars);

                }

                if (this._isSafari2()) {

                    var history = this._getHistory();

                    history[window.history.length - this._historyInitialLength + 1] = entry;

                    this._setHistory(history);

                    this._historyLength = window.history.length + 1;

                    var form = document.createElement('form');

                    form.method = 'get';

                    form.action = '#' + entry;

                    document.appendChild(form);

                    form.submit();

                    document.removeChild(form);

                }

                else {

                    window.location.hash = entry;

                }

                if ((typeof(title) !== 'undefined') && (title !== null)) {

                    document.title = title;

                }

            }

        }

    }

    function Sys$_Application$_unloadHandler(event) {

        this.dispose();

    }

    function Sys$_Application$_updateHiddenField(value) {

        if (this._clientId) {

            var serverStateField = document.getElementById(this._clientId);

            if (serverStateField) {

                serverStateField.value = value;

            }

        }

    }

Sys._Application.prototype = {

    _creatingComponents: false,

    _disposing: false,

    get_isCreatingComponents: Sys$_Application$get_isCreatingComponents,

    get_stateString: Sys$_Application$get_stateString,

    get_enableHistory: Sys$_Application$get_enableHistory,

    set_enableHistory: Sys$_Application$set_enableHistory,

    add_init: Sys$_Application$add_init,

    remove_init: Sys$_Application$remove_init,

    add_load: Sys$_Application$add_load,

    remove_load: Sys$_Application$remove_load,

    add_navigate: Sys$_Application$add_navigate,

    remove_navigate: Sys$_Application$remove_navigate,

    add_unload: Sys$_Application$add_unload,

    remove_unload: Sys$_Application$remove_unload,

    addComponent: Sys$_Application$addComponent,

    addHistoryPoint: Sys$_Application$addHistoryPoint,

    beginCreateComponents: Sys$_Application$beginCreateComponents,

    dispose: Sys$_Application$dispose,

    endCreateComponents: Sys$_Application$endCreateComponents,

    findComponent: Sys$_Application$findComponent,

    getComponents: Sys$_Application$getComponents,

    initialize: Sys$_Application$initialize,

    notifyScriptLoaded: Sys$_Application$notifyScriptLoaded,

    registerDisposableObject: Sys$_Application$registerDisposableObject,

    raiseLoad: Sys$_Application$raiseLoad,

    removeComponent: Sys$_Application$removeComponent,

    setServerId: Sys$_Application$setServerId,

    setServerState: Sys$_Application$setServerState,

    unregisterDisposableObject: Sys$_Application$unregisterDisposableObject,

    _addComponentToSecondPass: Sys$_Application$_addComponentToSecondPass,

    _deserializeState: Sys$_Application$_deserializeState,

    _doInitialize: Sys$_Application$_doInitialize,

    _enableHistoryInScriptManager: Sys$_Application$_enableHistoryInScriptManager,    

    _ensureHistory: Sys$_Application$_ensureHistory,

    _getHistory: Sys$_Application$_getHistory,

    _isSafari2: Sys$_Application$_isSafari2,

    _loadHandler: Sys$_Application$_loadHandler,

    _navigate: Sys$_Application$_navigate,

    _onIdle: Sys$_Application$_onIdle,

    _onIFrameLoad: Sys$_Application$_onIFrameLoad,

    _onPageRequestManagerBeginRequest: Sys$_Application$_onPageRequestManagerBeginRequest,

    _onPageRequestManagerEndRequest: Sys$_Application$_onPageRequestManagerEndRequest,

    _raiseNavigate: Sys$_Application$_raiseNavigate,

    _serializeState: Sys$_Application$_serializeState,

    _setHistory: Sys$_Application$_setHistory,

    _setState: Sys$_Application$_setState,

    _unloadHandler: Sys$_Application$_unloadHandler,

    _updateHiddenField: Sys$_Application$_updateHiddenField

}

Sys._Application.registerClass('Sys._Application', Sys.Component, Sys.IContainer);

Sys.Application = new Sys._Application();

var $find = Sys.Application.findComponent;

Type.registerNamespace('Sys.Net');

 

Sys.Net.WebRequestExecutor = function Sys$Net$WebRequestExecutor() {

    /// <summary locid="M:J#Sys.Net.WebRequestExecutor.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    this._webRequest = null;

    this._resultObject = null;

}

    function Sys$Net$WebRequestExecutor$get_webRequest() {

        /// <value type="Sys.Net.WebRequest" locid="P:J#Sys.Net.WebRequestExecutor.webRequest"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._webRequest;

    }

    function Sys$Net$WebRequestExecutor$_set_webRequest(value) {

        if (this.get_started()) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, 'set_webRequest'));

        }

        this._webRequest = value;

    }

    function Sys$Net$WebRequestExecutor$get_started() {

        /// <value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.started"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_responseAvailable() {

        /// <value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.responseAvailable"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_timedOut() {

        /// <value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.timedOut"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_aborted() {

        /// <value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.aborted"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_responseData() {

        /// <value type="String" locid="P:J#Sys.Net.WebRequestExecutor.responseData"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_statusCode() {

        /// <value type="Number" locid="P:J#Sys.Net.WebRequestExecutor.statusCode"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_statusText() {

        /// <value type="String" locid="P:J#Sys.Net.WebRequestExecutor.statusText"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_xml() {

        /// <value locid="P:J#Sys.Net.WebRequestExecutor.xml"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$get_object() {

        /// <value locid="P:J#Sys.Net.WebRequestExecutor.object"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._resultObject) {

            this._resultObject = Sys.Serialization.JavaScriptSerializer.deserialize(this.get_responseData());

        }

        return this._resultObject;

    }

    function Sys$Net$WebRequestExecutor$executeRequest() {

        /// <summary locid="M:J#Sys.Net.WebRequestExecutor.executeRequest" />

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$abort() {

        /// <summary locid="M:J#Sys.Net.WebRequestExecutor.abort" />

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$getResponseHeader(header) {

        /// <summary locid="M:J#Sys.Net.WebRequestExecutor.getResponseHeader" />

        /// <param name="header" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "header", type: String}

        ]);

        if (e) throw e;

        throw Error.notImplemented();

    }

    function Sys$Net$WebRequestExecutor$getAllResponseHeaders() {

        /// <summary locid="M:J#Sys.Net.WebRequestExecutor.getAllResponseHeaders" />

        if (arguments.length !== 0) throw Error.parameterCount();

        throw Error.notImplemented();

    }

Sys.Net.WebRequestExecutor.prototype = {

    get_webRequest: Sys$Net$WebRequestExecutor$get_webRequest,

    _set_webRequest: Sys$Net$WebRequestExecutor$_set_webRequest,

    get_started: Sys$Net$WebRequestExecutor$get_started,

    get_responseAvailable: Sys$Net$WebRequestExecutor$get_responseAvailable,

    get_timedOut: Sys$Net$WebRequestExecutor$get_timedOut,

    get_aborted: Sys$Net$WebRequestExecutor$get_aborted,

    get_responseData: Sys$Net$WebRequestExecutor$get_responseData,

    get_statusCode: Sys$Net$WebRequestExecutor$get_statusCode,

    get_statusText: Sys$Net$WebRequestExecutor$get_statusText,

    get_xml: Sys$Net$WebRequestExecutor$get_xml,

    get_object: Sys$Net$WebRequestExecutor$get_object,

    executeRequest: Sys$Net$WebRequestExecutor$executeRequest,

    abort: Sys$Net$WebRequestExecutor$abort,

    getResponseHeader: Sys$Net$WebRequestExecutor$getResponseHeader,

    getAllResponseHeaders: Sys$Net$WebRequestExecutor$getAllResponseHeaders

}

Sys.Net.WebRequestExecutor.registerClass('Sys.Net.WebRequestExecutor');

 

Sys.Net.XMLDOM = function Sys$Net$XMLDOM(markup) {

    /// <summary locid="M:J#Sys.Net.XMLDOM.#ctor" />

    /// <param name="markup" type="String"></param>

    var e = Function._validateParams(arguments, [

        {name: "markup", type: String}

    ]);

    if (e) throw e;

    if (!window.DOMParser) {

        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];

        for (var i = 0, l = progIDs.length; i < l; i++) {

            try {

                var xmlDOM = new ActiveXObject(progIDs[i]);

                xmlDOM.async = false;

                xmlDOM.loadXML(markup);

                xmlDOM.setProperty('SelectionLanguage', 'XPath');

                return xmlDOM;

            }

            catch (ex) {

            }

        }

    }

    else {

        try {

            var domParser = new window.DOMParser();

            return domParser.parseFromString(markup, 'text/xml');

        }

        catch (ex) {

        }

    }

    return null;

}

Sys.Net.XMLHttpExecutor = function Sys$Net$XMLHttpExecutor() {

    /// <summary locid="M:J#Sys.Net.XMLHttpExecutor.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys.Net.XMLHttpExecutor.initializeBase(this);

    var _this = this;

    this._xmlHttpRequest = null;

    this._webRequest = null;

    this._responseAvailable = false;

    this._timedOut = false;

    this._timer = null;

    this._aborted = false;

    this._started = false;

    this._onReadyStateChange = (function () {

        

        if (_this._xmlHttpRequest.readyState === 4 ) {

            try {

                if (typeof(_this._xmlHttpRequest.status) === "undefined") {

                    return;

                }

            }

            catch(ex) {

                return;

            }

            

            _this._clearTimer();

            _this._responseAvailable = true;

            try {

                _this._webRequest.completed(Sys.EventArgs.Empty);

            }

            finally {

                if (_this._xmlHttpRequest != null) {

                    _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;

                    _this._xmlHttpRequest = null;

                }

            }

        }

    });

    this._clearTimer = (function() {

        if (_this._timer != null) {

            window.clearTimeout(_this._timer);

            _this._timer = null;

        }

    });

    this._onTimeout = (function() {

        if (!_this._responseAvailable) {

            _this._clearTimer();

            _this._timedOut = true;

            _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;

            _this._xmlHttpRequest.abort();

            _this._webRequest.completed(Sys.EventArgs.Empty);

            _this._xmlHttpRequest = null;

        }

    });

}

    function Sys$Net$XMLHttpExecutor$get_timedOut() {

        /// <value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.timedOut"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._timedOut;

    }

    function Sys$Net$XMLHttpExecutor$get_started() {

        /// <value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.started"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._started;

    }

    function Sys$Net$XMLHttpExecutor$get_responseAvailable() {

        /// <value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.responseAvailable"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._responseAvailable;

    }

    function Sys$Net$XMLHttpExecutor$get_aborted() {

        /// <value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.aborted"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._aborted;

    }

    function Sys$Net$XMLHttpExecutor$executeRequest() {

        /// <summary locid="M:J#Sys.Net.XMLHttpExecutor.executeRequest" />

        if (arguments.length !== 0) throw Error.parameterCount();

        this._webRequest = this.get_webRequest();

        if (this._started) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, 'executeRequest'));

        }

        if (this._webRequest === null) {

            throw Error.invalidOperation(Sys.Res.nullWebRequest);

        }

        var body = this._webRequest.get_body();

        var headers = this._webRequest.get_headers();

        this._xmlHttpRequest = new XMLHttpRequest();

        this._xmlHttpRequest.onreadystatechange = this._onReadyStateChange;

        var verb = this._webRequest.get_httpVerb();

        this._xmlHttpRequest.open(verb, this._webRequest.getResolvedUrl(), true );

        if (headers) {

            for (var header in headers) {

                var val = headers[header];

                if (typeof(val) !== "function")

                    this._xmlHttpRequest.setRequestHeader(header, val);

            }

        }

        if (verb.toLowerCase() === "post") {

            if ((headers === null) || !headers['Content-Type']) {

                this._xmlHttpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8');

            }

            if (!body) {

                body = "";

            }

        }

        var timeout = this._webRequest.get_timeout();

        if (timeout > 0) {

            this._timer = window.setTimeout(Function.createDelegate(this, this._onTimeout), timeout);

        }

        this._xmlHttpRequest.send(body);

        this._started = true;

    }

    function Sys$Net$XMLHttpExecutor$getResponseHeader(header) {

        /// <summary locid="M:J#Sys.Net.XMLHttpExecutor.getResponseHeader" />

        /// <param name="header" type="String"></param>

        /// <returns type="String"></returns>

        var e = Function._validateParams(arguments, [

            {name: "header", type: String}

        ]);

        if (e) throw e;

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'getResponseHeader'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'getResponseHeader'));

        }

        var result;

        try {

            result = this._xmlHttpRequest.getResponseHeader(header);

        } catch (e) {

        }

        if (!result) result = "";

        return result;

    }

    function Sys$Net$XMLHttpExecutor$getAllResponseHeaders() {

        /// <summary locid="M:J#Sys.Net.XMLHttpExecutor.getAllResponseHeaders" />

        /// <returns type="String"></returns>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'getAllResponseHeaders'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'getAllResponseHeaders'));

        }

        return this._xmlHttpRequest.getAllResponseHeaders();

    }

    function Sys$Net$XMLHttpExecutor$get_responseData() {

        /// <value type="String" locid="P:J#Sys.Net.XMLHttpExecutor.responseData"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_responseData'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_responseData'));

        }

        return this._xmlHttpRequest.responseText;

    }

    function Sys$Net$XMLHttpExecutor$get_statusCode() {

        /// <value type="Number" locid="P:J#Sys.Net.XMLHttpExecutor.statusCode"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusCode'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_statusCode'));

        }

        var result = 0;

        try {

            result = this._xmlHttpRequest.status;

        }

        catch(ex) {

        }

        return result;

    }

    function Sys$Net$XMLHttpExecutor$get_statusText() {

        /// <value type="String" locid="P:J#Sys.Net.XMLHttpExecutor.statusText"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusText'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_statusText'));

        }

        return this._xmlHttpRequest.statusText;

    }

    function Sys$Net$XMLHttpExecutor$get_xml() {

        /// <value locid="P:J#Sys.Net.XMLHttpExecutor.xml"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._responseAvailable) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_xml'));

        }

        if (!this._xmlHttpRequest) {

            throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_xml'));

        }

        var xml = this._xmlHttpRequest.responseXML;

        if (!xml || !xml.documentElement) {

            xml = Sys.Net.XMLDOM(this._xmlHttpRequest.responseText);

            if (!xml || !xml.documentElement)

                return null;

        }

        else if (navigator.userAgent.indexOf('MSIE') !== -1) {

            xml.setProperty('SelectionLanguage', 'XPath');

        }

        if (xml.documentElement.namespaceURI === "http://www.mozilla.org/newlayout/xml/parsererror.xml" &&

            xml.documentElement.tagName === "parsererror") {

            return null;

        }

        

        if (xml.documentElement.firstChild && xml.documentElement.firstChild.tagName === "parsererror") {

            return null;

        }

        

        return xml;

    }

    function Sys$Net$XMLHttpExecutor$abort() {

        /// <summary locid="M:J#Sys.Net.XMLHttpExecutor.abort" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._started) {

            throw Error.invalidOperation(Sys.Res.cannotAbortBeforeStart);

        }

        if (this._aborted || this._responseAvailable || this._timedOut)

            return;

        this._aborted = true;

        this._clearTimer();

        if (this._xmlHttpRequest && !this._responseAvailable) {

            this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;

            this._xmlHttpRequest.abort();

            

            this._xmlHttpRequest = null;            

            this._webRequest.completed(Sys.EventArgs.Empty);

        }

    }

Sys.Net.XMLHttpExecutor.prototype = {

    get_timedOut: Sys$Net$XMLHttpExecutor$get_timedOut,

    get_started: Sys$Net$XMLHttpExecutor$get_started,

    get_responseAvailable: Sys$Net$XMLHttpExecutor$get_responseAvailable,

    get_aborted: Sys$Net$XMLHttpExecutor$get_aborted,

    executeRequest: Sys$Net$XMLHttpExecutor$executeRequest,

    getResponseHeader: Sys$Net$XMLHttpExecutor$getResponseHeader,

    getAllResponseHeaders: Sys$Net$XMLHttpExecutor$getAllResponseHeaders,

    get_responseData: Sys$Net$XMLHttpExecutor$get_responseData,

    get_statusCode: Sys$Net$XMLHttpExecutor$get_statusCode,

    get_statusText: Sys$Net$XMLHttpExecutor$get_statusText,

    get_xml: Sys$Net$XMLHttpExecutor$get_xml,

    abort: Sys$Net$XMLHttpExecutor$abort

}

Sys.Net.XMLHttpExecutor.registerClass('Sys.Net.XMLHttpExecutor', Sys.Net.WebRequestExecutor);

 

Sys.Net._WebRequestManager = function Sys$Net$_WebRequestManager() {

    /// <summary locid="P:J#Sys.Net.WebRequestManager.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    this._defaultTimeout = 0;

    this._defaultExecutorType = "Sys.Net.XMLHttpExecutor";

}

    function Sys$Net$_WebRequestManager$add_invokingRequest(handler) {

        /// <summary locid="E:J#Sys.Net.WebRequestManager.invokingRequest" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this._get_eventHandlerList().addHandler("invokingRequest", handler);

    }

    function Sys$Net$_WebRequestManager$remove_invokingRequest(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this._get_eventHandlerList().removeHandler("invokingRequest", handler);

    }

    function Sys$Net$_WebRequestManager$add_completedRequest(handler) {

        /// <summary locid="E:J#Sys.Net.WebRequestManager.completedRequest" />

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this._get_eventHandlerList().addHandler("completedRequest", handler);

    }

    function Sys$Net$_WebRequestManager$remove_completedRequest(handler) {

        var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

        if (e) throw e;

        this._get_eventHandlerList().removeHandler("completedRequest", handler);

    }

    function Sys$Net$_WebRequestManager$_get_eventHandlerList() {

        if (!this._events) {

            this._events = new Sys.EventHandlerList();

        }

        return this._events;

    }

    function Sys$Net$_WebRequestManager$get_defaultTimeout() {

        /// <value type="Number" locid="P:J#Sys.Net.WebRequestManager.defaultTimeout"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultTimeout;

    }

    function Sys$Net$_WebRequestManager$set_defaultTimeout(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Number}]);

        if (e) throw e;

        if (value < 0) {

            throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout);

        }

        this._defaultTimeout = value;

    }

    function Sys$Net$_WebRequestManager$get_defaultExecutorType() {

        /// <value type="String" locid="P:J#Sys.Net.WebRequestManager.defaultExecutorType"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultExecutorType;

    }

    function Sys$Net$_WebRequestManager$set_defaultExecutorType(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        this._defaultExecutorType = value;

    }

    function Sys$Net$_WebRequestManager$executeRequest(webRequest) {

        /// <summary locid="M:J#Sys.Net.WebRequestManager.executeRequest" />

        /// <param name="webRequest" type="Sys.Net.WebRequest"></param>

        var e = Function._validateParams(arguments, [

            {name: "webRequest", type: Sys.Net.WebRequest}

        ]);

        if (e) throw e;

        var executor = webRequest.get_executor();

        if (!executor) {

            var failed = false;

            try {

                var executorType = eval(this._defaultExecutorType);

                executor = new executorType();

            } catch (e) {

                failed = true;

            }

            if (failed  || !Sys.Net.WebRequestExecutor.isInstanceOfType(executor) || !executor) {

                throw Error.argument("defaultExecutorType", String.format(Sys.Res.invalidExecutorType, this._defaultExecutorType));

            }

            webRequest.set_executor(executor);

        }

        if (executor.get_aborted()) {

            return;

        }

        var evArgs = new Sys.Net.NetworkRequestEventArgs(webRequest);

        var handler = this._get_eventHandlerList().getHandler("invokingRequest");

        if (handler) {

            handler(this, evArgs);

        }

        if (!evArgs.get_cancel()) {

            executor.executeRequest();

        }

    }

Sys.Net._WebRequestManager.prototype = {

    add_invokingRequest: Sys$Net$_WebRequestManager$add_invokingRequest,

    remove_invokingRequest: Sys$Net$_WebRequestManager$remove_invokingRequest,

    add_completedRequest: Sys$Net$_WebRequestManager$add_completedRequest,

    remove_completedRequest: Sys$Net$_WebRequestManager$remove_completedRequest,

    _get_eventHandlerList: Sys$Net$_WebRequestManager$_get_eventHandlerList,

    get_defaultTimeout: Sys$Net$_WebRequestManager$get_defaultTimeout,

    set_defaultTimeout: Sys$Net$_WebRequestManager$set_defaultTimeout,

    get_defaultExecutorType: Sys$Net$_WebRequestManager$get_defaultExecutorType,

    set_defaultExecutorType: Sys$Net$_WebRequestManager$set_defaultExecutorType,

    executeRequest: Sys$Net$_WebRequestManager$executeRequest

}

Sys.Net._WebRequestManager.registerClass('Sys.Net._WebRequestManager');

Sys.Net.WebRequestManager = new Sys.Net._WebRequestManager();

 

Sys.Net.NetworkRequestEventArgs = function Sys$Net$NetworkRequestEventArgs(webRequest) {

    /// <summary locid="M:J#Sys.Net.NetworkRequestEventArgs.#ctor" />

    /// <param name="webRequest" type="Sys.Net.WebRequest"></param>

    var e = Function._validateParams(arguments, [

        {name: "webRequest", type: Sys.Net.WebRequest}

    ]);

    if (e) throw e;

    Sys.Net.NetworkRequestEventArgs.initializeBase(this);

    this._webRequest = webRequest;

}

    function Sys$Net$NetworkRequestEventArgs$get_webRequest() {

        /// <value type="Sys.Net.WebRequest" locid="P:J#Sys.Net.NetworkRequestEventArgs.webRequest"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._webRequest;

    }

Sys.Net.NetworkRequestEventArgs.prototype = {

    get_webRequest: Sys$Net$NetworkRequestEventArgs$get_webRequest

}

Sys.Net.NetworkRequestEventArgs.registerClass('Sys.Net.NetworkRequestEventArgs', Sys.CancelEventArgs);

 

Sys.Net.WebRequest = function Sys$Net$WebRequest() {

    /// <summary locid="M:J#Sys.Net.WebRequest.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    this._url = "";

    this._headers = { };

    this._body = null;

    this._userContext = null;

    this._httpVerb = null;

    this._executor = null;

    this._invokeCalled = false;

    this._timeout = 0;

}

    function Sys$Net$WebRequest$add_completed(handler) {

    /// <summary locid="E:J#Sys.Net.WebRequest.completed" />

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        this._get_eventHandlerList().addHandler("completed", handler);

    }

    function Sys$Net$WebRequest$remove_completed(handler) {

    var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    if (e) throw e;

        this._get_eventHandlerList().removeHandler("completed", handler);

    }

    function Sys$Net$WebRequest$completed(eventArgs) {

        /// <summary locid="M:J#Sys.Net.WebRequest.completed" />

        /// <param name="eventArgs" type="Sys.EventArgs"></param>

        var e = Function._validateParams(arguments, [

            {name: "eventArgs", type: Sys.EventArgs}

        ]);

        if (e) throw e;

        var handler = Sys.Net.WebRequestManager._get_eventHandlerList().getHandler("completedRequest");

        if (handler) {

            handler(this._executor, eventArgs);

        }

        handler = this._get_eventHandlerList().getHandler("completed");

        if (handler) {

            handler(this._executor, eventArgs);

        }

    }

    function Sys$Net$WebRequest$_get_eventHandlerList() {

        if (!this._events) {

            this._events = new Sys.EventHandlerList();

        }

        return this._events;

    }

    function Sys$Net$WebRequest$get_url() {

        /// <value type="String" locid="P:J#Sys.Net.WebRequest.url"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._url;

    }

    function Sys$Net$WebRequest$set_url(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        this._url = value;

    }

    function Sys$Net$WebRequest$get_headers() {

        /// <value locid="P:J#Sys.Net.WebRequest.headers"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._headers;

    }

    function Sys$Net$WebRequest$get_httpVerb() {

        /// <value type="String" locid="P:J#Sys.Net.WebRequest.httpVerb"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._httpVerb === null) {

            if (this._body === null) {

                return "GET";

            }

            return "POST";

        }

        return this._httpVerb;

    }

    function Sys$Net$WebRequest$set_httpVerb(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        if (value.length === 0) {

            throw Error.argument('value', Sys.Res.invalidHttpVerb);

        }

        this._httpVerb = value;

    }

    function Sys$Net$WebRequest$get_body() {

        /// <value mayBeNull="true" locid="P:J#Sys.Net.WebRequest.body"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._body;

    }

    function Sys$Net$WebRequest$set_body(value) {

        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);

        if (e) throw e;

        this._body = value;

    }

    function Sys$Net$WebRequest$get_userContext() {

        /// <value mayBeNull="true" locid="P:J#Sys.Net.WebRequest.userContext"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._userContext;

    }

    function Sys$Net$WebRequest$set_userContext(value) {

        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);

        if (e) throw e;

        this._userContext = value;

    }

    function Sys$Net$WebRequest$get_executor() {

        /// <value type="Sys.Net.WebRequestExecutor" locid="P:J#Sys.Net.WebRequest.executor"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._executor;

    }

    function Sys$Net$WebRequest$set_executor(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Sys.Net.WebRequestExecutor}]);

        if (e) throw e;

        if (this._executor !== null && this._executor.get_started()) {

            throw Error.invalidOperation(Sys.Res.setExecutorAfterActive);

        }

        this._executor = value;

        this._executor._set_webRequest(this);

    }

    function Sys$Net$WebRequest$get_timeout() {

        /// <value type="Number" locid="P:J#Sys.Net.WebRequest.timeout"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._timeout === 0) {

            return Sys.Net.WebRequestManager.get_defaultTimeout();

        }

        return this._timeout;

    }

    function Sys$Net$WebRequest$set_timeout(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Number}]);

        if (e) throw e;

        if (value < 0) {

            throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout);

        }

        this._timeout = value;

    }

    function Sys$Net$WebRequest$getResolvedUrl() {

        /// <summary locid="M:J#Sys.Net.WebRequest.getResolvedUrl" />

        /// <returns type="String"></returns>

        if (arguments.length !== 0) throw Error.parameterCount();

        return Sys.Net.WebRequest._resolveUrl(this._url);

    }

    function Sys$Net$WebRequest$invoke() {

        /// <summary locid="M:J#Sys.Net.WebRequest.invoke" />

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._invokeCalled) {

            throw Error.invalidOperation(Sys.Res.invokeCalledTwice);

        }

        Sys.Net.WebRequestManager.executeRequest(this);

        this._invokeCalled = true;

    }

Sys.Net.WebRequest.prototype = {

    add_completed: Sys$Net$WebRequest$add_completed,

    remove_completed: Sys$Net$WebRequest$remove_completed,

    completed: Sys$Net$WebRequest$completed,

    _get_eventHandlerList: Sys$Net$WebRequest$_get_eventHandlerList,

    get_url: Sys$Net$WebRequest$get_url,

    set_url: Sys$Net$WebRequest$set_url,

    get_headers: Sys$Net$WebRequest$get_headers,

    get_httpVerb: Sys$Net$WebRequest$get_httpVerb,

    set_httpVerb: Sys$Net$WebRequest$set_httpVerb,

    get_body: Sys$Net$WebRequest$get_body,

    set_body: Sys$Net$WebRequest$set_body,

    get_userContext: Sys$Net$WebRequest$get_userContext,

    set_userContext: Sys$Net$WebRequest$set_userContext,

    get_executor: Sys$Net$WebRequest$get_executor,

    set_executor: Sys$Net$WebRequest$set_executor,

    get_timeout: Sys$Net$WebRequest$get_timeout,

    set_timeout: Sys$Net$WebRequest$set_timeout,

    getResolvedUrl: Sys$Net$WebRequest$getResolvedUrl,

    invoke: Sys$Net$WebRequest$invoke

}

Sys.Net.WebRequest._resolveUrl = function Sys$Net$WebRequest$_resolveUrl(url, baseUrl) {

    if (url && url.indexOf('://') !== -1) {

        return url;

    }

    if (!baseUrl || baseUrl.length === 0) {

        var baseElement = document.getElementsByTagName('base')[0];

        if (baseElement && baseElement.href && baseElement.href.length > 0) {

            baseUrl = baseElement.href;

        }

        else {

            baseUrl = document.URL;

        }

    }

    var qsStart = baseUrl.indexOf('?');

    if (qsStart !== -1) {

        baseUrl = baseUrl.substr(0, qsStart);

    }

    qsStart = baseUrl.indexOf('#');

    if (qsStart !== -1) {

        baseUrl = baseUrl.substr(0, qsStart);

    }

    baseUrl = baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1);

    if (!url || url.length === 0) {

        return baseUrl;

    }

    if (url.charAt(0) === '/') {

        var slashslash = baseUrl.indexOf('://');

        if (slashslash === -1) {

            throw Error.argument("baseUrl", Sys.Res.badBaseUrl1);

        }

        var nextSlash = baseUrl.indexOf('/', slashslash + 3);

        if (nextSlash === -1) {

            throw Error.argument("baseUrl", Sys.Res.badBaseUrl2);

        }

        return baseUrl.substr(0, nextSlash) + url;

    }

    else {

        var lastSlash = baseUrl.lastIndexOf('/');

        if (lastSlash === -1) {

            throw Error.argument("baseUrl", Sys.Res.badBaseUrl3);

        }

        return baseUrl.substr(0, lastSlash+1) + url;

    }

}

Sys.Net.WebRequest._createQueryString = function Sys$Net$WebRequest$_createQueryString(queryString, encodeMethod) {

    if (!encodeMethod)

        encodeMethod = encodeURIComponent;

    var sb = new Sys.StringBuilder();

    var i = 0;

    for (var arg in queryString) {

        var obj = queryString[arg];

        if (typeof(obj) === "function") continue;

        var val = Sys.Serialization.JavaScriptSerializer.serialize(obj);

        if (i !== 0) {

            sb.append('&');

        }

        sb.append(arg);

        sb.append('=');

        sb.append(encodeMethod(val));

        i++;

    }

    return sb.toString();

}

Sys.Net.WebRequest._createUrl = function Sys$Net$WebRequest$_createUrl(url, queryString) {

    if (!queryString) {

        return url;

    }

    var qs = Sys.Net.WebRequest._createQueryString(queryString);

    if (qs.length > 0) {

        var sep = '?';

        if (url && url.indexOf('?') !== -1)

            sep = '&';

        return url + sep + qs;

    } else {

        return url;

    }

}

Sys.Net.WebRequest.registerClass('Sys.Net.WebRequest');

 

Sys.Net.WebServiceProxy = function Sys$Net$WebServiceProxy() {

}

    function Sys$Net$WebServiceProxy$get_timeout() {

        /// <value type="Number" locid="P:J#Sys.Net.WebServiceProxy.timeout"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._timeout;

    }

    function Sys$Net$WebServiceProxy$set_timeout(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Number}]);

        if (e) throw e;

        if (value < 0) { throw Error.argumentOutOfRange('value', value, Sys.Res.invalidTimeout); }

        this._timeout = value;

    }

    function Sys$Net$WebServiceProxy$get_defaultUserContext() {

        /// <value mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultUserContext"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._userContext;

    }

    function Sys$Net$WebServiceProxy$set_defaultUserContext(value) {

        var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);

        if (e) throw e;

        this._userContext = value;

    }

    function Sys$Net$WebServiceProxy$get_defaultSucceededCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultSucceededCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._succeeded;

    }

    function Sys$Net$WebServiceProxy$set_defaultSucceededCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._succeeded = value;

    }

    function Sys$Net$WebServiceProxy$get_defaultFailedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultFailedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._failed;

    }

    function Sys$Net$WebServiceProxy$set_defaultFailedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._failed = value;

    }

    function Sys$Net$WebServiceProxy$get_path() {

        /// <value type="String" locid="P:J#Sys.Net.WebServiceProxy.path"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._path;

    }

    function Sys$Net$WebServiceProxy$set_path(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        this._path = value;

    }

    function Sys$Net$WebServiceProxy$_invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext) {

        /// <summary locid="M:J#Sys.Net.WebServiceProxy._invoke" />

        /// <param name="servicePath" type="String"></param>

        /// <param name="methodName" type="String"></param>

        /// <param name="useGet" type="Boolean"></param>

        /// <param name="params"></param>

        /// <param name="onSuccess" type="Function" mayBeNull="true" optional="true"></param>

        /// <param name="onFailure" type="Function" mayBeNull="true" optional="true"></param>

        /// <param name="userContext" mayBeNull="true" optional="true"></param>

        /// <returns type="Sys.Net.WebRequest"></returns>

        var e = Function._validateParams(arguments, [

            {name: "servicePath", type: String},

            {name: "methodName", type: String},

            {name: "useGet", type: Boolean},

            {name: "params"},

            {name: "onSuccess", type: Function, mayBeNull: true, optional: true},

            {name: "onFailure", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        if (onSuccess === null || typeof onSuccess === 'undefined') onSuccess = this.get_defaultSucceededCallback();

        if (onFailure === null || typeof onFailure === 'undefined') onFailure = this.get_defaultFailedCallback();

        if (userContext === null || typeof userContext === 'undefined') userContext = this.get_defaultUserContext();

        

        return Sys.Net.WebServiceProxy.invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, this.get_timeout());

    }

Sys.Net.WebServiceProxy.prototype = {

    get_timeout: Sys$Net$WebServiceProxy$get_timeout,

    set_timeout: Sys$Net$WebServiceProxy$set_timeout,

    get_defaultUserContext: Sys$Net$WebServiceProxy$get_defaultUserContext,

    set_defaultUserContext: Sys$Net$WebServiceProxy$set_defaultUserContext,

    get_defaultSucceededCallback: Sys$Net$WebServiceProxy$get_defaultSucceededCallback,

    set_defaultSucceededCallback: Sys$Net$WebServiceProxy$set_defaultSucceededCallback,

    get_defaultFailedCallback: Sys$Net$WebServiceProxy$get_defaultFailedCallback,

    set_defaultFailedCallback: Sys$Net$WebServiceProxy$set_defaultFailedCallback,

    get_path: Sys$Net$WebServiceProxy$get_path,

    set_path: Sys$Net$WebServiceProxy$set_path,

    _invoke: Sys$Net$WebServiceProxy$_invoke

}

Sys.Net.WebServiceProxy.registerClass('Sys.Net.WebServiceProxy');

Sys.Net.WebServiceProxy.invoke = function Sys$Net$WebServiceProxy$invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, timeout) {

    /// <summary locid="M:J#Sys.Net.WebServiceProxy.invoke" />

    /// <param name="servicePath" type="String"></param>

    /// <param name="methodName" type="String"></param>

    /// <param name="useGet" type="Boolean" optional="true"></param>

    /// <param name="params" mayBeNull="true" optional="true"></param>

    /// <param name="onSuccess" type="Function" mayBeNull="true" optional="true"></param>

    /// <param name="onFailure" type="Function" mayBeNull="true" optional="true"></param>

    /// <param name="userContext" mayBeNull="true" optional="true"></param>

    /// <param name="timeout" type="Number" optional="true"></param>

    /// <returns type="Sys.Net.WebRequest"></returns>

    var e = Function._validateParams(arguments, [

        {name: "servicePath", type: String},

        {name: "methodName", type: String},

        {name: "useGet", type: Boolean, optional: true},

        {name: "params", mayBeNull: true, optional: true},

        {name: "onSuccess", type: Function, mayBeNull: true, optional: true},

        {name: "onFailure", type: Function, mayBeNull: true, optional: true},

        {name: "userContext", mayBeNull: true, optional: true},

        {name: "timeout", type: Number, optional: true}

    ]);

    if (e) throw e;

    var request = new Sys.Net.WebRequest();

    request.get_headers()['Content-Type'] = 'application/json; charset=utf-8';

    if (!params) params = {};

    var urlParams = params;

    if (!useGet || !urlParams) urlParams = {};

    request.set_url(Sys.Net.WebRequest._createUrl(servicePath+"/"+encodeURIComponent(methodName), urlParams));

    var body = null;

    if (!useGet) {

        body = Sys.Serialization.JavaScriptSerializer.serialize(params);

        if (body === "{}") body = "";

    }

    request.set_body(body);

    request.add_completed(onComplete);

    if (timeout && timeout > 0) request.set_timeout(timeout);

    request.invoke();

    function onComplete(response, eventArgs) {

        if (response.get_responseAvailable()) {

            var statusCode = response.get_statusCode();

            var result = null;

           

            try {

                var contentType = response.getResponseHeader("Content-Type");

                if (contentType.startsWith("application/json")) {

                    result = response.get_object();

                }

                else if (contentType.startsWith("text/xml")) {

                    result = response.get_xml();

                }

                else {

                    result = response.get_responseData();

                }

            } catch (ex) {

            }

            var error = response.getResponseHeader("jsonerror");

            var errorObj = (error === "true");

            if (errorObj) {

                if (result) {

                    result = new Sys.Net.WebServiceError(false, result.Message, result.StackTrace, result.ExceptionType);

                }

            }

            else if (contentType.startsWith("application/json")) {

                if (!result || typeof(result.d) === "undefined") {

                    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceInvalidJsonWrapper, methodName));

                }

                result = result.d;

            }

            if (((statusCode < 200) || (statusCode >= 300)) || errorObj) {

                if (onFailure) {

                    if (!result || !errorObj) {

                        result = new Sys.Net.WebServiceError(false , String.format(Sys.Res.webServiceFailedNoMsg, methodName), "", "");

                    }

                    result._statusCode = statusCode;

                    onFailure(result, userContext, methodName);

                }

                else {

                    var error;

                    if (result && errorObj) {

                        error = result.get_exceptionType() + "-- " + result.get_message();

                    }

                    else {

                        error = response.get_responseData();

                    }

                    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));

                }

            }

            else if (onSuccess) {

                onSuccess(result, userContext, methodName);

            }

        }

        else {

            var msg;

            if (response.get_timedOut()) {

                msg = String.format(Sys.Res.webServiceTimedOut, methodName);

            }

            else {

                msg = String.format(Sys.Res.webServiceFailedNoMsg, methodName)

            }

            if (onFailure) {

                onFailure(new Sys.Net.WebServiceError(response.get_timedOut(), msg, "", ""), userContext, methodName);

            }

            else {

                throw Sys.Net.WebServiceProxy._createFailedError(methodName, msg);

            }

        }

    }

    return request;

}

Sys.Net.WebServiceProxy._createFailedError = function Sys$Net$WebServiceProxy$_createFailedError(methodName, errorMessage) {

    var displayMessage = "Sys.Net.WebServiceFailedException: " + errorMessage;

    var e = Error.create(displayMessage, { 'name': 'Sys.Net.WebServiceFailedException', 'methodName': methodName });

    e.popStackFrame();

    return e;

}

Sys.Net.WebServiceProxy._defaultFailedCallback = function Sys$Net$WebServiceProxy$_defaultFailedCallback(err, methodName) {

    var error = err.get_exceptionType() + "-- " + err.get_message();

    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));

}

Sys.Net.WebServiceProxy._generateTypedConstructor = function Sys$Net$WebServiceProxy$_generateTypedConstructor(type) {

    return function(properties) {

        if (properties) {

            for (var name in properties) {

                this[name] = properties[name];

            }

        }

        this.__type = type;

    }

}

 

Sys.Net.WebServiceError = function Sys$Net$WebServiceError(timedOut, message, stackTrace, exceptionType) {

    /// <summary locid="M:J#Sys.Net.WebServiceError.#ctor" />

    /// <param name="timedOut" type="Boolean"></param>

    /// <param name="message" type="String" mayBeNull="true"></param>

    /// <param name="stackTrace" type="String" mayBeNull="true"></param>

    /// <param name="exceptionType" type="String" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "timedOut", type: Boolean},

        {name: "message", type: String, mayBeNull: true},

        {name: "stackTrace", type: String, mayBeNull: true},

        {name: "exceptionType", type: String, mayBeNull: true}

    ]);

    if (e) throw e;

    this._timedOut = timedOut;

    this._message = message;

    this._stackTrace = stackTrace;

    this._exceptionType = exceptionType;

    this._statusCode = -1;

}

    function Sys$Net$WebServiceError$get_timedOut() {

        /// <value type="Boolean" locid="P:J#Sys.Net.WebServiceError.timedOut"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._timedOut;

    }

    function Sys$Net$WebServiceError$get_statusCode() {

        /// <value type="Number" locid="P:J#Sys.Net.WebServiceError.statusCode"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._statusCode;

    }

    function Sys$Net$WebServiceError$get_message() {

        /// <value type="String" locid="P:J#Sys.Net.WebServiceError.message"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._message;

    }

    function Sys$Net$WebServiceError$get_stackTrace() {

        /// <value type="String" locid="P:J#Sys.Net.WebServiceError.stackTrace"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._stackTrace;

    }

    function Sys$Net$WebServiceError$get_exceptionType() {

        /// <value type="String" locid="P:J#Sys.Net.WebServiceError.exceptionType"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._exceptionType;

    }

Sys.Net.WebServiceError.prototype = {

    get_timedOut: Sys$Net$WebServiceError$get_timedOut,

    get_statusCode: Sys$Net$WebServiceError$get_statusCode,

    get_message: Sys$Net$WebServiceError$get_message,

    get_stackTrace: Sys$Net$WebServiceError$get_stackTrace,

    get_exceptionType: Sys$Net$WebServiceError$get_exceptionType

}

Sys.Net.WebServiceError.registerClass('Sys.Net.WebServiceError');

Type.registerNamespace('Sys.Services');

Sys.Services._ProfileService = function Sys$Services$_ProfileService() {

    /// <summary locid="M:J#Sys.Net.ProfileService.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys.Services._ProfileService.initializeBase(this);

    this.properties = {};

}

Sys.Services._ProfileService.DefaultWebServicePath = '';

    function Sys$Services$_ProfileService$get_defaultLoadCompletedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Services.ProfileService.defaultLoadCompletedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultLoadCompletedCallback;

    }

    function Sys$Services$_ProfileService$set_defaultLoadCompletedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._defaultLoadCompletedCallback = value;

    }

    function Sys$Services$_ProfileService$get_defaultSaveCompletedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Services.ProfileService.defaultSaveCompletedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultSaveCompletedCallback;

    }

    function Sys$Services$_ProfileService$set_defaultSaveCompletedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._defaultSaveCompletedCallback = value;

    }

    function Sys$Services$_ProfileService$get_path() {

        /// <value type="String" mayBeNull="true" locid="P:J#Sys.Services.ProfileService.path"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._path || '';

    }

    function Sys$Services$_ProfileService$load(propertyNames, loadCompletedCallback, failedCallback, userContext) {

        /// <summary locid="M:J#Sys.Services.ProfileService.load" />

        /// <param name="propertyNames" type="Array" elementType="String" optional="true" elementMayBeNull="false" mayBeNull="true"></param>

        /// <param name="loadCompletedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="userContext" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "propertyNames", type: Array, mayBeNull: true, optional: true, elementType: String},

            {name: "loadCompletedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        var parameters;

        var methodName;

        if (!propertyNames) {

            methodName = "GetAllPropertiesForCurrentUser";

            parameters = { authenticatedUserOnly: false };

        }

        else {

            methodName = "GetPropertiesForCurrentUser";

            parameters = { properties: this._clonePropertyNames(propertyNames), authenticatedUserOnly: false };

        }

        this._invoke(this._get_path(),

                                        methodName,

                                        false,

                                        parameters,

                                        Function.createDelegate(this, this._onLoadComplete),

                                        Function.createDelegate(this, this._onLoadFailed),

                                        [loadCompletedCallback, failedCallback, userContext]);

    }

    function Sys$Services$_ProfileService$save(propertyNames, saveCompletedCallback, failedCallback, userContext) {

        /// <summary locid="M:J#Sys.Services.ProfileService.save" />

        /// <param name="propertyNames" type="Array" elementType="String" optional="true" elementMayBeNull="false" mayBeNull="true"></param>

        /// <param name="saveCompletedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="userContext" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "propertyNames", type: Array, mayBeNull: true, optional: true, elementType: String},

            {name: "saveCompletedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        var flattenedProperties = this._flattenProperties(propertyNames, this.properties);

        this._invoke(this._get_path(),

                                        "SetPropertiesForCurrentUser",

                                        false,

                                        { values: flattenedProperties.value, authenticatedUserOnly: false },

                                        Function.createDelegate(this, this._onSaveComplete),

                                        Function.createDelegate(this, this._onSaveFailed),

                                        [saveCompletedCallback, failedCallback, userContext, flattenedProperties.count]);

    }

    function Sys$Services$_ProfileService$_clonePropertyNames(arr) {

        var nodups = [];

        var seen = {};

        for (var i=0; i < arr.length; i++) {

            var prop = arr[i];

            if(!seen[prop]) { Array.add(nodups, prop); seen[prop]=true; };

        }

        return nodups;

    }

    function Sys$Services$_ProfileService$_flattenProperties(propertyNames, properties, groupName) {

        var flattenedProperties = {};

        var val;

        var key;

        var count = 0;

        if (propertyNames && propertyNames.length === 0) {

            return { value: flattenedProperties, count: 0 };

        }

        for (var property in properties) {

            val = properties[property];

            key = groupName ? groupName + "." + property : property;

            if(Sys.Services.ProfileGroup.isInstanceOfType(val)) {

                var obj = this._flattenProperties(propertyNames, val, key);

                var groupProperties = obj.value;

                count += obj.count; 

                for(var subKey in groupProperties) {

                    var subVal = groupProperties[subKey];

                    flattenedProperties[subKey] = subVal;

                }

            }

            else {

                if(!propertyNames || Array.indexOf(propertyNames, key) !== -1) {

                    flattenedProperties[key] = val;

                    count++; 

                }

            }

        }

        return { value: flattenedProperties, count: count };

    }

    function Sys$Services$_ProfileService$_get_path() {

        var path = this.get_path();

        if (!path.length) {

            path = Sys.Services._ProfileService.DefaultWebServicePath;

        }

        if (!path || !path.length) {

            throw Error.invalidOperation(Sys.Res.servicePathNotSet);

        }

        return path;

    }

    function Sys$Services$_ProfileService$_onLoadComplete(result, context, methodName) {

        if (typeof(result) !== "object") {

            throw Error.invalidOperation(String.format(Sys.Res.webServiceInvalidReturnType, methodName, "Object"));

        }

        var unflattened = this._unflattenProperties(result);

        for (var name in unflattened) {

            this.properties[name] = unflattened[name];

        }

        

        var callback = context[0] || this.get_defaultLoadCompletedCallback() || this.get_defaultSucceededCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();        

            callback(result.length, userContext, "Sys.Services.ProfileService.load");

        }

    }

    function Sys$Services$_ProfileService$_onLoadFailed(err, context, methodName) {

        var callback = context[1] || this.get_defaultFailedCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();        

            callback(err, userContext, "Sys.Services.ProfileService.load");

        }

        else {

            Sys.Net.WebServiceProxy._defaultFailedCallback(err, methodName);

        }

    }

    function Sys$Services$_ProfileService$_onSaveComplete(result, context, methodName) {

        var count = context[3];

        if (result !== null) { 

            if (result instanceof Array) {

                count -= result.length;

            }

            else if (typeof(result) === 'number') {

                count = result;

            }

            else {

                throw Error.invalidOperation(String.format(Sys.Res.webServiceInvalidReturnType, methodName, "Array"));

            }

        }

        

        var callback = context[0] || this.get_defaultSaveCompletedCallback() || this.get_defaultSucceededCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();

            callback(count, userContext, "Sys.Services.ProfileService.save");

        }

    }

    function Sys$Services$_ProfileService$_onSaveFailed(err, context, methodName) {

        var callback = context[1] || this.get_defaultFailedCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();

            callback(err, userContext, "Sys.Services.ProfileService.save");

        }

        else {

            Sys.Net.WebServiceProxy._defaultFailedCallback(err, methodName);

        }

    }

    function Sys$Services$_ProfileService$_unflattenProperties(properties) {

        var unflattenedProperties = {};

        var dotIndex;

        var val;

        var count = 0;

        for (var key in properties) {

            count++;

            val = properties[key];

            dotIndex = key.indexOf('.');

            if (dotIndex !== -1) {

                var groupName = key.substr(0, dotIndex);

                key = key.substr(dotIndex+1);

                var group = unflattenedProperties[groupName];

                if (!group || !Sys.Services.ProfileGroup.isInstanceOfType(group)) {

                    group = new Sys.Services.ProfileGroup();

                    unflattenedProperties[groupName] = group;

                }

                group[key] = val;

            }

            else {

                unflattenedProperties[key] = val;

            }

        }

        properties.length = count;

        return unflattenedProperties;

    }

Sys.Services._ProfileService.prototype = {

    _defaultLoadCompletedCallback: null,

    _defaultSaveCompletedCallback: null,

    _path: '',

    _timeout: 0,

    get_defaultLoadCompletedCallback: Sys$Services$_ProfileService$get_defaultLoadCompletedCallback,

    set_defaultLoadCompletedCallback: Sys$Services$_ProfileService$set_defaultLoadCompletedCallback,

    get_defaultSaveCompletedCallback: Sys$Services$_ProfileService$get_defaultSaveCompletedCallback,

    set_defaultSaveCompletedCallback: Sys$Services$_ProfileService$set_defaultSaveCompletedCallback,

    get_path: Sys$Services$_ProfileService$get_path,

    load: Sys$Services$_ProfileService$load,

    save: Sys$Services$_ProfileService$save,

    _clonePropertyNames: Sys$Services$_ProfileService$_clonePropertyNames,    

    _flattenProperties: Sys$Services$_ProfileService$_flattenProperties,

    _get_path: Sys$Services$_ProfileService$_get_path,    

    _onLoadComplete: Sys$Services$_ProfileService$_onLoadComplete,

    _onLoadFailed: Sys$Services$_ProfileService$_onLoadFailed,

    _onSaveComplete: Sys$Services$_ProfileService$_onSaveComplete,

    _onSaveFailed: Sys$Services$_ProfileService$_onSaveFailed,

    _unflattenProperties: Sys$Services$_ProfileService$_unflattenProperties

}

Sys.Services._ProfileService.registerClass('Sys.Services._ProfileService', Sys.Net.WebServiceProxy);

Sys.Services.ProfileService = new Sys.Services._ProfileService();

Sys.Services.ProfileGroup = function Sys$Services$ProfileGroup(properties) {

    /// <summary locid="M:J#Sys.Services.ProfileGroup.#ctor" />

    /// <param name="properties" optional="true" mayBeNull="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "properties", mayBeNull: true, optional: true}

    ]);

    if (e) throw e;

    if (properties) {

        for (var property in properties) {

            this[property] = properties[property];

        }

    }

}

Sys.Services.ProfileGroup.registerClass('Sys.Services.ProfileGroup');

Sys.Services._AuthenticationService = function Sys$Services$_AuthenticationService() {

    /// <summary locid="M:J#Sys.Services.AuthenticationService.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys.Services._AuthenticationService.initializeBase(this);

}

Sys.Services._AuthenticationService.DefaultWebServicePath = '';

    function Sys$Services$_AuthenticationService$get_defaultLoginCompletedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Services.AuthenticationService.defaultLoginCompletedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultLoginCompletedCallback;

    }

    function Sys$Services$_AuthenticationService$set_defaultLoginCompletedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._defaultLoginCompletedCallback = value;

    }

    function Sys$Services$_AuthenticationService$get_defaultLogoutCompletedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Services.AuthenticationService.defaultLogoutCompletedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultLogoutCompletedCallback;

    }

    function Sys$Services$_AuthenticationService$set_defaultLogoutCompletedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._defaultLogoutCompletedCallback = value;

    }

    function Sys$Services$_AuthenticationService$get_isLoggedIn() {

        /// <value type="Boolean" locid="P:J#Sys.Services.AuthenticationService.isLoggedIn"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._authenticated;

    }

    function Sys$Services$_AuthenticationService$get_path() {

        /// <value type="String" mayBeNull="true" locid="P:J#Sys.Services.AuthenticationService.path"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._path || '';

    }

    function Sys$Services$_AuthenticationService$login(username, password, isPersistent, customInfo, redirectUrl, loginCompletedCallback, failedCallback, userContext) {

        /// <summary locid="M:J#Sys.Services.AuthenticationService.login" />

        /// <param name="username" type="String" mayBeNull="false"></param>

        /// <param name="password" type="String" mayBeNull="true"></param>

        /// <param name="isPersistent" type="Boolean" optional="true" mayBeNull="true"></param>

        /// <param name="customInfo" type="String" optional="true" mayBeNull="true"></param>

        /// <param name="redirectUrl" type="String" optional="true" mayBeNull="true"></param>

        /// <param name="loginCompletedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="userContext" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "username", type: String},

            {name: "password", type: String, mayBeNull: true},

            {name: "isPersistent", type: Boolean, mayBeNull: true, optional: true},

            {name: "customInfo", type: String, mayBeNull: true, optional: true},

            {name: "redirectUrl", type: String, mayBeNull: true, optional: true},

            {name: "loginCompletedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        this._invoke(this._get_path(), "Login", false,

                                        { userName: username, password: password, createPersistentCookie: isPersistent },

                                        Function.createDelegate(this, this._onLoginComplete),

                                        Function.createDelegate(this, this._onLoginFailed),

                                        [username, password, isPersistent, customInfo, redirectUrl, loginCompletedCallback, failedCallback, userContext]);

    }

    function Sys$Services$_AuthenticationService$logout(redirectUrl, logoutCompletedCallback, failedCallback, userContext) {

        /// <summary locid="M:J#Sys.Services.AuthenticationService.logout" />

        /// <param name="redirectUrl" type="String" optional="true" mayBeNull="true"></param>

        /// <param name="logoutCompletedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="userContext" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "redirectUrl", type: String, mayBeNull: true, optional: true},

            {name: "logoutCompletedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        this._invoke(this._get_path(), "Logout", false, {}, 

                                        Function.createDelegate(this, this._onLogoutComplete),

                                        Function.createDelegate(this, this._onLogoutFailed),

                                        [redirectUrl, logoutCompletedCallback, failedCallback, userContext]);

    }

    function Sys$Services$_AuthenticationService$_get_path() {

        var path = this.get_path();

        if(!path.length) {

            path = Sys.Services._AuthenticationService.DefaultWebServicePath;

        }

        if(!path || !path.length) {

            throw Error.invalidOperation(Sys.Res.servicePathNotSet);

        }

        return path;

    }

    function Sys$Services$_AuthenticationService$_onLoginComplete(result, context, methodName) {

        if(typeof(result) !== "boolean") {

            throw Error.invalidOperation(String.format(Sys.Res.webServiceInvalidReturnType, methodName, "Boolean"));

        }

        

        var redirectUrl = context[4];

        var userContext = context[7] || this.get_defaultUserContext();

        var callback = context[5] || this.get_defaultLoginCompletedCallback() || this.get_defaultSucceededCallback();

        

        if(result) {

            this._authenticated = true;

            if (callback) {

                callback(true, userContext, "Sys.Services.AuthenticationService.login");

            }

            

            if (typeof(redirectUrl) !== "undefined" && redirectUrl !== null) {

                window.location.href = redirectUrl;

            }

        }

        else if (callback) {

            callback(false, userContext, "Sys.Services.AuthenticationService.login");

        }

    }

    function Sys$Services$_AuthenticationService$_onLoginFailed(err, context, methodName) {

        var callback = context[6] || this.get_defaultFailedCallback();

        if (callback) {

            var userContext = context[7] || this.get_defaultUserContext();

            callback(err, userContext, "Sys.Services.AuthenticationService.login");

        }

        else {

            Sys.Net.WebServiceProxy._defaultFailedCallback(err, methodName);

        }

    }

    function Sys$Services$_AuthenticationService$_onLogoutComplete(result, context, methodName) {

        if(result !== null) {

            throw Error.invalidOperation(String.format(Sys.Res.webServiceInvalidReturnType, methodName, "null"));

        }

        

        var redirectUrl = context[0];

        var userContext = context[3] || this.get_defaultUserContext();

        var callback = context[1] || this.get_defaultLogoutCompletedCallback() || this.get_defaultSucceededCallback();

        this._authenticated = false;

        

        if (callback) {

            callback(null, userContext, "Sys.Services.AuthenticationService.logout");

        }

        

        if(!redirectUrl) {

            window.location.reload();

        }

        else {

            window.location.href = redirectUrl;

        }

    }

    function Sys$Services$_AuthenticationService$_onLogoutFailed(err, context, methodName) {

        var callback = context[2] || this.get_defaultFailedCallback();

        if (callback) {

            callback(err, context[3], "Sys.Services.AuthenticationService.logout");

        }

        else {

            Sys.Net.WebServiceProxy._defaultFailedCallback(err, methodName);

        }

    }

    function Sys$Services$_AuthenticationService$_setAuthenticated(authenticated) {

        this._authenticated = authenticated;

    }

Sys.Services._AuthenticationService.prototype = {

    _defaultLoginCompletedCallback: null,

    _defaultLogoutCompletedCallback: null,

    _path: '',

    _timeout: 0,

    _authenticated: false,

    get_defaultLoginCompletedCallback: Sys$Services$_AuthenticationService$get_defaultLoginCompletedCallback,

    set_defaultLoginCompletedCallback: Sys$Services$_AuthenticationService$set_defaultLoginCompletedCallback,

    get_defaultLogoutCompletedCallback: Sys$Services$_AuthenticationService$get_defaultLogoutCompletedCallback,

    set_defaultLogoutCompletedCallback: Sys$Services$_AuthenticationService$set_defaultLogoutCompletedCallback,

    get_isLoggedIn: Sys$Services$_AuthenticationService$get_isLoggedIn,

    get_path: Sys$Services$_AuthenticationService$get_path,  

    login: Sys$Services$_AuthenticationService$login,

    logout: Sys$Services$_AuthenticationService$logout,

    _get_path: Sys$Services$_AuthenticationService$_get_path,

    _onLoginComplete: Sys$Services$_AuthenticationService$_onLoginComplete,

    _onLoginFailed: Sys$Services$_AuthenticationService$_onLoginFailed,

    _onLogoutComplete: Sys$Services$_AuthenticationService$_onLogoutComplete,

    _onLogoutFailed: Sys$Services$_AuthenticationService$_onLogoutFailed,

    _setAuthenticated: Sys$Services$_AuthenticationService$_setAuthenticated    

}

Sys.Services._AuthenticationService.registerClass('Sys.Services._AuthenticationService', Sys.Net.WebServiceProxy);

Sys.Services.AuthenticationService = new Sys.Services._AuthenticationService();

Sys.Services._RoleService = function Sys$Services$_RoleService() {

    /// <summary locid="M:J#Sys.Services.RoleService.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

    Sys.Services._RoleService.initializeBase(this);

    this._roles = [];

}

Sys.Services._RoleService.DefaultWebServicePath = '';

    function Sys$Services$_RoleService$get_defaultLoadCompletedCallback() {

        /// <value type="Function" mayBeNull="true" locid="P:J#Sys.Services.RoleService.defaultLoadCompletedCallback"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._defaultLoadCompletedCallback;

    }

    function Sys$Services$_RoleService$set_defaultLoadCompletedCallback(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);

        if (e) throw e;

        this._defaultLoadCompletedCallback = value;

    }

    function Sys$Services$_RoleService$get_path() {

        /// <value type="String" mayBeNull="true" locid="P:J#Sys.Services.RoleService.path"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._path || '';

    }

    function Sys$Services$_RoleService$get_roles() {

        /// <value type="Array" elementType="String" mayBeNull="false" locid="P:J#Sys.Services.RoleService.roles"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return Array.clone(this._roles);

    }

    function Sys$Services$_RoleService$isUserInRole(role) {

        /// <summary locid="M:J#Sys.Services.RoleService.isUserInRole" />

        /// <param name="role" type="String" mayBeNull="false"></param>

        /// <returns type="Boolean"></returns>

        var e = Function._validateParams(arguments, [

            {name: "role", type: String}

        ]);

        if (e) throw e;

        var v = this._get_rolesIndex()[role.trim().toLowerCase()];

        return !!v;

    }

    function Sys$Services$_RoleService$load(loadCompletedCallback, failedCallback, userContext) {

        /// <summary locid="M:J#Sys.Services.RoleService.load" />

        /// <param name="loadCompletedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>

        /// <param name="userContext" optional="true" mayBeNull="true"></param>

        var e = Function._validateParams(arguments, [

            {name: "loadCompletedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},

            {name: "userContext", mayBeNull: true, optional: true}

        ]);

        if (e) throw e;

        Sys.Net.WebServiceProxy.invoke(

                    this._get_path(),

                    "GetRolesForCurrentUser",

                    false,

                    {} ,

                    Function.createDelegate(this, this._onLoadComplete),

                    Function.createDelegate(this, this._onLoadFailed),

                    [loadCompletedCallback, failedCallback, userContext],

                    this.get_timeout());

    }

    function Sys$Services$_RoleService$_get_path() {

        var path = this.get_path();

        if(!path || !path.length) {

            path = Sys.Services._RoleService.DefaultWebServicePath;

        }

        if(!path || !path.length) {

            throw Error.invalidOperation(Sys.Res.servicePathNotSet);

        }

        return path;

    }

    function Sys$Services$_RoleService$_get_rolesIndex() {

        if (!this._rolesIndex) {

            var index = {};

            for(var i=0; i < this._roles.length; i++) {

                index[this._roles[i].toLowerCase()] = true;

            }

            this._rolesIndex = index;

        }

        return this._rolesIndex;

    }

    function Sys$Services$_RoleService$_onLoadComplete(result, context, methodName) {

        if(result && !(result instanceof Array)) {

            throw Error.invalidOperation(String.format(Sys.Res.webServiceInvalidReturnType, methodName, "Array"));

        }

        this._roles = result;

        this._rolesIndex = null;

        var callback = context[0] || this.get_defaultLoadCompletedCallback() || this.get_defaultSucceededCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();

            var clonedResult = Array.clone(result);

            callback(clonedResult, userContext, "Sys.Services.RoleService.load");

        }

    }

    function Sys$Services$_RoleService$_onLoadFailed(err, context, methodName) {

        var callback = context[1] || this.get_defaultFailedCallback();

        if (callback) {

            var userContext = context[2] || this.get_defaultUserContext();

            callback(err, userContext, "Sys.Services.RoleService.load");

        }

        else {

            Sys.Net.WebServiceProxy._defaultFailedCallback(err, methodName);

        }

    }

Sys.Services._RoleService.prototype = {

    _defaultLoadCompletedCallback: null,

    _rolesIndex: null,

    _timeout: 0,

    _path: '',

    get_defaultLoadCompletedCallback: Sys$Services$_RoleService$get_defaultLoadCompletedCallback,

    set_defaultLoadCompletedCallback: Sys$Services$_RoleService$set_defaultLoadCompletedCallback,

    get_path: Sys$Services$_RoleService$get_path,

    get_roles: Sys$Services$_RoleService$get_roles,

    isUserInRole: Sys$Services$_RoleService$isUserInRole,

    load: Sys$Services$_RoleService$load,

    _get_path: Sys$Services$_RoleService$_get_path,  

    _get_rolesIndex: Sys$Services$_RoleService$_get_rolesIndex,

    _onLoadComplete: Sys$Services$_RoleService$_onLoadComplete,

    _onLoadFailed: Sys$Services$_RoleService$_onLoadFailed

}

Sys.Services._RoleService.registerClass('Sys.Services._RoleService', Sys.Net.WebServiceProxy);

Sys.Services.RoleService = new Sys.Services._RoleService();

Type.registerNamespace('Sys.Serialization');

Sys.Serialization.JavaScriptSerializer = function Sys$Serialization$JavaScriptSerializer() {

    /// <summary locid="M:J#Sys.Serialization.JavaScriptSerializer.#ctor" />

    if (arguments.length !== 0) throw Error.parameterCount();

}

Sys.Serialization.JavaScriptSerializer.registerClass('Sys.Serialization.JavaScriptSerializer');

Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs = [];

Sys.Serialization.JavaScriptSerializer._charsToEscape = [];

Sys.Serialization.JavaScriptSerializer._dateRegEx = new RegExp('(^|[^\\\\])\\"\\\\/Date\\((-?[0-9]+)(?:[a-zA-Z]|(?:\\+|-)[0-9]{4})?\\)\\\\/\\"', 'g');

Sys.Serialization.JavaScriptSerializer._escapeChars = {};

Sys.Serialization.JavaScriptSerializer._escapeRegEx = new RegExp('["\\\\\\x00-\\x1F]', 'i');

Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal = new RegExp('["\\\\\\x00-\\x1F]', 'g');

Sys.Serialization.JavaScriptSerializer._jsonRegEx = new RegExp('[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]', 'g');

Sys.Serialization.JavaScriptSerializer._jsonStringRegEx = new RegExp('"(\\\\.|[^"\\\\])*"', 'g');

Sys.Serialization.JavaScriptSerializer._serverTypeFieldName = '__type';

Sys.Serialization.JavaScriptSerializer._init = function Sys$Serialization$JavaScriptSerializer$_init() {

    var replaceChars = ['\\u0000','\\u0001','\\u0002','\\u0003','\\u0004','\\u0005','\\u0006','\\u0007',

                        '\\b','\\t','\\n','\\u000b','\\f','\\r','\\u000e','\\u000f','\\u0010','\\u0011',

                        '\\u0012','\\u0013','\\u0014','\\u0015','\\u0016','\\u0017','\\u0018','\\u0019',

                        '\\u001a','\\u001b','\\u001c','\\u001d','\\u001e','\\u001f'];

    Sys.Serialization.JavaScriptSerializer._charsToEscape[0] = '\\';

    Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs['\\'] = new RegExp('\\\\', 'g');

    Sys.Serialization.JavaScriptSerializer._escapeChars['\\'] = '\\\\';

    Sys.Serialization.JavaScriptSerializer._charsToEscape[1] = '"';

    Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs['"'] = new RegExp('"', 'g');

    Sys.Serialization.JavaScriptSerializer._escapeChars['"'] = '\\"';

    for (var i = 0; i < 32; i++) {

        var c = String.fromCharCode(i);

        Sys.Serialization.JavaScriptSerializer._charsToEscape[i+2] = c;

        Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c] = new RegExp(c, 'g');

        Sys.Serialization.JavaScriptSerializer._escapeChars[c] = replaceChars[i];

    }

}

Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeBooleanWithBuilder(object, stringBuilder) {

    stringBuilder.append(object.toString());

}

Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeNumberWithBuilder(object, stringBuilder) {

    if (isFinite(object)) {

        stringBuilder.append(String(object));

    }

    else {

        throw Error.invalidOperation(Sys.Res.cannotSerializeNonFiniteNumbers);

    }

}

Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeStringWithBuilder(string, stringBuilder) {

    stringBuilder.append('"');

    if (Sys.Serialization.JavaScriptSerializer._escapeRegEx.test(string)) {

        if (Sys.Serialization.JavaScriptSerializer._charsToEscape.length === 0) {

            Sys.Serialization.JavaScriptSerializer._init();

        }

        if (string.length < 128) {

            string = string.replace(Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal,

                function(x) { return Sys.Serialization.JavaScriptSerializer._escapeChars[x]; });

        }

        else {

            for (var i = 0; i < 34; i++) {

                var c = Sys.Serialization.JavaScriptSerializer._charsToEscape[i];

                if (string.indexOf(c) !== -1) {

                    if (Sys.Browser.agent === Sys.Browser.Opera || Sys.Browser.agent === Sys.Browser.FireFox) {

                        string = string.split(c).join(Sys.Serialization.JavaScriptSerializer._escapeChars[c]);

                    }

                    else {

                        string = string.replace(Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c],

                            Sys.Serialization.JavaScriptSerializer._escapeChars[c]);

                    }

                }

            }

       }

    }

    stringBuilder.append(string);

    stringBuilder.append('"');

}

Sys.Serialization.JavaScriptSerializer._serializeWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeWithBuilder(object, stringBuilder, sort, prevObjects) {

    var i;

    switch (typeof object) {

    case 'object':

        if (object) {

            if (prevObjects){

                for( var j = 0; j < prevObjects.length; j++) {

                    if (prevObjects[j] === object) {

                        throw Error.invalidOperation(Sys.Res.cannotSerializeObjectWithCycle);

                    }

                }

            }

            else {

                prevObjects = new Array();

            }

            try {

                Array.add(prevObjects, object);

                

                if (Number.isInstanceOfType(object)){

                    Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder(object, stringBuilder);

                }

                else if (Boolean.isInstanceOfType(object)){

                    Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder(object, stringBuilder);

                }

                else if (String.isInstanceOfType(object)){

                    Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder(object, stringBuilder);

                }

            

                else if (Array.isInstanceOfType(object)) {

                    stringBuilder.append('[');

                   

                    for (i = 0; i < object.length; ++i) {

                        if (i > 0) {

                            stringBuilder.append(',');

                        }

                        Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object[i], stringBuilder,false,prevObjects);

                    }

                    stringBuilder.append(']');

                }

                else {

                    if (Date.isInstanceOfType(object)) {

                        stringBuilder.append('"\\/Date(');

                        stringBuilder.append(object.getTime());

                        stringBuilder.append(')\\/"');

                        break;

                    }

                    var properties = [];

                    var propertyCount = 0;

                    for (var name in object) {

                        if (name.startsWith('$')) {

                            continue;

                        }

                        if (name === Sys.Serialization.JavaScriptSerializer._serverTypeFieldName && propertyCount !== 0){

                            properties[propertyCount++] = properties[0];

                            properties[0] = name;

                        }

                        else{

                            properties[propertyCount++] = name;

                        }

                    }

                    if (sort) properties.sort();

                    stringBuilder.append('{');

                    var needComma = false;

                     

                    for (i=0; i<propertyCount; i++) {

                        var value = object[properties[i]];

                        if (typeof value !== 'undefined' && typeof value !== 'function') {

                            if (needComma) {

                                stringBuilder.append(',');

                            }

                            else {

                                needComma = true;

                            }

                           

                            Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(properties[i], stringBuilder, sort, prevObjects);

                            stringBuilder.append(':');

                            Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(value, stringBuilder, sort, prevObjects);

                          

                        }

                    }

                stringBuilder.append('}');

                }

            }

            finally {

                Array.removeAt(prevObjects, prevObjects.length - 1);

            }

        }

        else {

            stringBuilder.append('null');

        }

        break;

    case 'number':

        Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder(object, stringBuilder);

        break;

    case 'string':

        Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder(object, stringBuilder);

        break;

    case 'boolean':

        Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder(object, stringBuilder);

        break;

    default:

        stringBuilder.append('null');

        break;

    }

}

Sys.Serialization.JavaScriptSerializer.serialize = function Sys$Serialization$JavaScriptSerializer$serialize(object) {

    /// <summary locid="M:J#Sys.Serialization.JavaScriptSerializer.serialize" />

    /// <param name="object" mayBeNull="true"></param>

    /// <returns type="String"></returns>

    var e = Function._validateParams(arguments, [

        {name: "object", mayBeNull: true}

    ]);

    if (e) throw e;

    var stringBuilder = new Sys.StringBuilder();

    Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object, stringBuilder, false);

    return stringBuilder.toString();

}

Sys.Serialization.JavaScriptSerializer.deserialize = function Sys$Serialization$JavaScriptSerializer$deserialize(data, secure) {

    /// <summary locid="M:J#Sys.Serialization.JavaScriptSerializer.deserialize" />

    /// <param name="data" type="String"></param>

    /// <param name="secure" type="Boolean" optional="true"></param>

    /// <returns></returns>

    var e = Function._validateParams(arguments, [

        {name: "data", type: String},

        {name: "secure", type: Boolean, optional: true}

    ]);

    if (e) throw e;

    

    if (data.length === 0) throw Error.argument('data', Sys.Res.cannotDeserializeEmptyString);

    try {    

        var exp = data.replace(Sys.Serialization.JavaScriptSerializer._dateRegEx, "$1new Date($2)");

        

        if (secure && Sys.Serialization.JavaScriptSerializer._jsonRegEx.test(

             exp.replace(Sys.Serialization.JavaScriptSerializer._jsonStringRegEx, ''))) throw null;

        return eval('(' + exp + ')');

    }

    catch (e) {

         throw Error.argument('data', Sys.Res.cannotDeserializeInvalidJson);

    }

}

 

Sys.CultureInfo = function Sys$CultureInfo(name, numberFormat, dateTimeFormat) {

    /// <summary locid="M:J#Sys.CultureInfo.#ctor" />

    /// <param name="name" type="String"></param>

    /// <param name="numberFormat" type="Object"></param>

    /// <param name="dateTimeFormat" type="Object"></param>

    var e = Function._validateParams(arguments, [

        {name: "name", type: String},

        {name: "numberFormat", type: Object},

        {name: "dateTimeFormat", type: Object}

    ]);

    if (e) throw e;

    this.name = name;

    this.numberFormat = numberFormat;

    this.dateTimeFormat = dateTimeFormat;

}

    function Sys$CultureInfo$_getDateTimeFormats() {

        if (! this._dateTimeFormats) {

            var dtf = this.dateTimeFormat;

            this._dateTimeFormats =

              [ dtf.MonthDayPattern,

                dtf.YearMonthPattern,

                dtf.ShortDatePattern,

                dtf.ShortTimePattern,

                dtf.LongDatePattern,

                dtf.LongTimePattern,

                dtf.FullDateTimePattern,

                dtf.RFC1123Pattern,

                dtf.SortableDateTimePattern,

                dtf.UniversalSortableDateTimePattern ];

        }

        return this._dateTimeFormats;

    }

    function Sys$CultureInfo$_getMonthIndex(value) {

        if (!this._upperMonths) {

            this._upperMonths = this._toUpperArray(this.dateTimeFormat.MonthNames);

        }

        return Array.indexOf(this._upperMonths, this._toUpper(value));

    }

    function Sys$CultureInfo$_getAbbrMonthIndex(value) {

        if (!this._upperAbbrMonths) {

            this._upperAbbrMonths = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);

        }

        return Array.indexOf(this._upperAbbrMonths, this._toUpper(value));

    }

    function Sys$CultureInfo$_getDayIndex(value) {

        if (!this._upperDays) {

            this._upperDays = this._toUpperArray(this.dateTimeFormat.DayNames);

        }

        return Array.indexOf(this._upperDays, this._toUpper(value));

    }

    function Sys$CultureInfo$_getAbbrDayIndex(value) {

        if (!this._upperAbbrDays) {

            this._upperAbbrDays = this._toUpperArray(this.dateTimeFormat.AbbreviatedDayNames);

        }

        return Array.indexOf(this._upperAbbrDays, this._toUpper(value));

    }

    function Sys$CultureInfo$_toUpperArray(arr) {

        var result = [];

        for (var i = 0, il = arr.length; i < il; i++) {

            result[i] = this._toUpper(arr[i]);

        }

        return result;

    }

    function Sys$CultureInfo$_toUpper(value) {

        return value.split("\u00A0").join(' ').toUpperCase();

    }

Sys.CultureInfo.prototype = {

    _getDateTimeFormats: Sys$CultureInfo$_getDateTimeFormats,

    _getMonthIndex: Sys$CultureInfo$_getMonthIndex,

    _getAbbrMonthIndex: Sys$CultureInfo$_getAbbrMonthIndex,

    _getDayIndex: Sys$CultureInfo$_getDayIndex,

    _getAbbrDayIndex: Sys$CultureInfo$_getAbbrDayIndex,

    _toUpperArray: Sys$CultureInfo$_toUpperArray,

    _toUpper: Sys$CultureInfo$_toUpper

}

Sys.CultureInfo._parse = function Sys$CultureInfo$_parse(value) {

    var cultureInfo = Sys.Serialization.JavaScriptSerializer.deserialize(value);

    return new Sys.CultureInfo(cultureInfo.name, cultureInfo.numberFormat, cultureInfo.dateTimeFormat);

}

Sys.CultureInfo.registerClass('Sys.CultureInfo');

Sys.CultureInfo.InvariantCulture = Sys.CultureInfo._parse('{"name":"","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":true,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"\u00A4","NaNSymbol":"NaN","CurrencyNegativePattern":0,"NumberNegativePattern":1,"PercentPositivePattern":0,"PercentNegativePattern":0,"NegativeInfinitySymbol":"-Infinity","NegativeSign":"-","NumberDecimalDigits":2,"NumberDecimalSeparator":".","NumberGroupSeparator":",","CurrencyPositivePattern":0,"PositiveInfinitySymbol":"Infinity","PositiveSign":"+","PercentDecimalDigits":2,"PercentDecimalSeparator":".","PercentGroupSeparator":",","PercentSymbol":"%","PerMilleSymbol":"\u2030","NativeDigits":["0","1","2","3","4","5","6","7","8","9"],"DigitSubstitution":1},"dateTimeFormat":{"AMDesignator":"AM","Calendar":{"MinSupportedDateTime":"@-62135568000000@","MaxSupportedDateTime":"@253402300799999@","AlgorithmType":1,"CalendarType":1,"Eras":[1],"TwoDigitYearMax":2029,"IsReadOnly":true},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, dd MMMM yyyy HH:mm:ss","LongDatePattern":"dddd, dd MMMM yyyy","LongTimePattern":"HH:mm:ss","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"MM/dd/yyyy","ShortTimePattern":"HH:mm","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"yyyy MMMM","AbbreviatedDayNames":["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],"ShortestDayNames":["Su","Mo","Tu","We","Th","Fr","Sa"],"DayNames":["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"AbbreviatedMonthNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthNames":["January","February","March","April","May","June","July","August","September","October","November","December",""],"IsReadOnly":true,"NativeCalendarName":"Gregorian Calendar","AbbreviatedMonthGenitiveNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthGenitiveNames":["January","February","March","April","May","June","July","August","September","October","November","December",""]}}');

if (typeof(__cultureInfo) === 'undefined') {

    var __cultureInfo = '{"name":"en-US","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":false,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"$","NaNSymbol":"NaN","CurrencyNegativePattern":0,"NumberNegativePattern":1,"PercentPositivePattern":0,"PercentNegativePattern":0,"NegativeInfinitySymbol":"-Infinity","NegativeSign":"-","NumberDecimalDigits":2,"NumberDecimalSeparator":".","NumberGroupSeparator":",","CurrencyPositivePattern":0,"PositiveInfinitySymbol":"Infinity","PositiveSign":"+","PercentDecimalDigits":2,"PercentDecimalSeparator":".","PercentGroupSeparator":",","PercentSymbol":"%","PerMilleSymbol":"\u2030","NativeDigits":["0","1","2","3","4","5","6","7","8","9"],"DigitSubstitution":1},"dateTimeFormat":{"AMDesignator":"AM","Calendar":{"MinSupportedDateTime":"@-62135568000000@","MaxSupportedDateTime":"@253402300799999@","AlgorithmType":1,"CalendarType":1,"Eras":[1],"TwoDigitYearMax":2029,"IsReadOnly":false},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, MMMM dd, yyyy h:mm:ss tt","LongDatePattern":"dddd, MMMM dd, yyyy","LongTimePattern":"h:mm:ss tt","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"M/d/yyyy","ShortTimePattern":"h:mm tt","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"MMMM, yyyy","AbbreviatedDayNames":["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],"ShortestDayNames":["Su","Mo","Tu","We","Th","Fr","Sa"],"DayNames":["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"AbbreviatedMonthNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthNames":["January","February","March","April","May","June","July","August","September","October","November","December",""],"IsReadOnly":false,"NativeCalendarName":"Gregorian Calendar","AbbreviatedMonthGenitiveNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthGenitiveNames":["January","February","March","April","May","June","July","August","September","October","November","December",""]}}';

}

Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse(__cultureInfo);

delete __cultureInfo;

 

Sys.UI.Behavior = function Sys$UI$Behavior(element) {

    /// <summary locid="M:J#Sys.UI.Behavior.#ctor" />

    /// <param name="element" domElement="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    Sys.UI.Behavior.initializeBase(this);

    this._element = element;

    var behaviors = element._behaviors;

    if (!behaviors) {

        element._behaviors = [this];

    }

    else {

        behaviors[behaviors.length] = this;

    }

}

    function Sys$UI$Behavior$get_element() {

        /// <value domElement="true" locid="P:J#Sys.UI.Behavior.element"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._element;

    }

    function Sys$UI$Behavior$get_id() {

        /// <value type="String" locid="P:J#Sys.UI.Behavior.id"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        var baseId = Sys.UI.Behavior.callBaseMethod(this, 'get_id');

        if (baseId) return baseId;

        if (!this._element || !this._element.id) return '';

        return this._element.id + '$' + this.get_name();

    }

    function Sys$UI$Behavior$get_name() {

        /// <value type="String" locid="P:J#Sys.UI.Behavior.name"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._name) return this._name;

        var name = Object.getTypeName(this);

        var i = name.lastIndexOf('.');

        if (i != -1) name = name.substr(i + 1);

        if (!this.get_isInitialized()) this._name = name;

        return name;

    }

    function Sys$UI$Behavior$set_name(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        if ((value === '') || (value.charAt(0) === ' ') || (value.charAt(value.length - 1) === ' '))

            throw Error.argument('value', Sys.Res.invalidId);

        if (typeof(this._element[value]) !== 'undefined')

            throw Error.invalidOperation(String.format(Sys.Res.behaviorDuplicateName, value));

        if (this.get_isInitialized()) throw Error.invalidOperation(Sys.Res.cantSetNameAfterInit);

        this._name = value;

    }

    function Sys$UI$Behavior$initialize() {

        Sys.UI.Behavior.callBaseMethod(this, 'initialize');

        var name = this.get_name();

        if (name) this._element[name] = this;

    }

    function Sys$UI$Behavior$dispose() {

        Sys.UI.Behavior.callBaseMethod(this, 'dispose');

        if (this._element) {

            var name = this.get_name();

            if (name) {

                this._element[name] = null;

            }

            Array.remove(this._element._behaviors, this);

            delete this._element;

        }

    }

Sys.UI.Behavior.prototype = {

    _name: null,

    get_element: Sys$UI$Behavior$get_element,

    get_id: Sys$UI$Behavior$get_id,

    get_name: Sys$UI$Behavior$get_name,

    set_name: Sys$UI$Behavior$set_name,

    initialize: Sys$UI$Behavior$initialize,

    dispose: Sys$UI$Behavior$dispose

}

Sys.UI.Behavior.registerClass('Sys.UI.Behavior', Sys.Component);

Sys.UI.Behavior.getBehaviorByName = function Sys$UI$Behavior$getBehaviorByName(element, name) {

    /// <summary locid="M:J#Sys.UI.Behavior.getBehaviorByName" />

    /// <param name="element" domElement="true"></param>

    /// <param name="name" type="String"></param>

    /// <returns type="Sys.UI.Behavior" mayBeNull="true"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "name", type: String}

    ]);

    if (e) throw e;

    var b = element[name];

    return (b && Sys.UI.Behavior.isInstanceOfType(b)) ? b : null;

}

Sys.UI.Behavior.getBehaviors = function Sys$UI$Behavior$getBehaviors(element) {

    /// <summary locid="M:J#Sys.UI.Behavior.getBehaviors" />

    /// <param name="element" domElement="true"></param>

    /// <returns type="Array" elementType="Sys.UI.Behavior"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    if (!element._behaviors) return [];

    return Array.clone(element._behaviors);

}

Sys.UI.Behavior.getBehaviorsByType = function Sys$UI$Behavior$getBehaviorsByType(element, type) {

    /// <summary locid="M:J#Sys.UI.Behavior.getBehaviorsByType" />

    /// <param name="element" domElement="true"></param>

    /// <param name="type" type="Type"></param>

    /// <returns type="Array" elementType="Sys.UI.Behavior"></returns>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true},

        {name: "type", type: Type}

    ]);

    if (e) throw e;

    var behaviors = element._behaviors;

    var results = [];

    if (behaviors) {

        for (var i = 0, l = behaviors.length; i < l; i++) {

            if (type.isInstanceOfType(behaviors[i])) {

                results[results.length] = behaviors[i];

            }

        }

    }

    return results;

}

 

Sys.UI.VisibilityMode = function Sys$UI$VisibilityMode() {

    /// <summary locid="M:J#Sys.UI.VisibilityMode.#ctor" />

    /// <field name="hide" type="Number" integer="true" static="true" locid="F:J#Sys.UI.VisibilityMode.hide"></field>

    /// <field name="collapse" type="Number" integer="true" static="true" locid="F:J#Sys.UI.VisibilityMode.collapse"></field>

    if (arguments.length !== 0) throw Error.parameterCount();

    throw Error.notImplemented();

}

Sys.UI.VisibilityMode.prototype = {

    hide: 0,

    collapse: 1

}

Sys.UI.VisibilityMode.registerEnum("Sys.UI.VisibilityMode");

 

Sys.UI.Control = function Sys$UI$Control(element) {

    /// <summary locid="M:J#Sys.UI.Control.#ctor" />

    /// <param name="element" domElement="true"></param>

    var e = Function._validateParams(arguments, [

        {name: "element", domElement: true}

    ]);

    if (e) throw e;

    if (typeof(element.control) != 'undefined') throw Error.invalidOperation(Sys.Res.controlAlreadyDefined);

    Sys.UI.Control.initializeBase(this);

    this._element = element;

    element.control = this;

}

    function Sys$UI$Control$get_element() {

        /// <value domElement="true" locid="P:J#Sys.UI.Control.element"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        return this._element;

    }

    function Sys$UI$Control$get_id() {

        /// <value type="String" locid="P:J#Sys.UI.Control.id"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._element) return '';

        return this._element.id;

    }

    function Sys$UI$Control$set_id(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: String}]);

        if (e) throw e;

        throw Error.invalidOperation(Sys.Res.cantSetId);

    }

    function Sys$UI$Control$get_parent() {

        /// <value type="Sys.UI.Control" locid="P:J#Sys.UI.Control.parent"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (this._parent) return this._parent;

        if (!this._element) return null;

        

        var parentElement = this._element.parentNode;

        while (parentElement) {

            if (parentElement.control) {

                return parentElement.control;

            }

            parentElement = parentElement.parentNode;

        }

        return null;

    }

    function Sys$UI$Control$set_parent(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.Control}]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        var parents = [this];

        var current = value;

        while (current) {

            if (Array.contains(parents, current)) throw Error.invalidOperation(Sys.Res.circularParentChain);

            parents[parents.length] = current;

            current = current.get_parent();

        }

        this._parent = value;

    }

    function Sys$UI$Control$get_visibilityMode() {

        /// <value type="Sys.UI.VisibilityMode" locid="P:J#Sys.UI.Control.visibilityMode"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        return Sys.UI.DomElement.getVisibilityMode(this._element);

    }

    function Sys$UI$Control$set_visibilityMode(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.VisibilityMode}]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        Sys.UI.DomElement.setVisibilityMode(this._element, value);

    }

    function Sys$UI$Control$get_visible() {

        /// <value type="Boolean" locid="P:J#Sys.UI.Control.visible"></value>

        if (arguments.length !== 0) throw Error.parameterCount();

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        return Sys.UI.DomElement.getVisible(this._element);

    }

    function Sys$UI$Control$set_visible(value) {

        var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        Sys.UI.DomElement.setVisible(this._element, value)

    }

    function Sys$UI$Control$addCssClass(className) {

        /// <summary locid="M:J#Sys.UI.Control.addCssClass" />

        /// <param name="className" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "className", type: String}

        ]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        Sys.UI.DomElement.addCssClass(this._element, className);

    }

    function Sys$UI$Control$dispose() {

        Sys.UI.Control.callBaseMethod(this, 'dispose');

        if (this._element) {

            this._element.control = undefined;

            delete this._element;

        }

        if (this._parent) delete this._parent;

    }

    function Sys$UI$Control$onBubbleEvent(source, args) {

        /// <summary locid="M:J#Sys.UI.Control.onBubbleEvent" />

        /// <param name="source"></param>

        /// <param name="args" type="Sys.EventArgs"></param>

        /// <returns type="Boolean"></returns>

        var e = Function._validateParams(arguments, [

            {name: "source"},

            {name: "args", type: Sys.EventArgs}

        ]);

        if (e) throw e;

        return false;

    }

    function Sys$UI$Control$raiseBubbleEvent(source, args) {

        /// <summary locid="M:J#Sys.UI.Control.raiseBubbleEvent" />

        /// <param name="source"></param>

        /// <param name="args" type="Sys.EventArgs"></param>

        var e = Function._validateParams(arguments, [

            {name: "source"},

            {name: "args", type: Sys.EventArgs}

        ]);

        if (e) throw e;

        var currentTarget = this.get_parent();

        while (currentTarget) {

            if (currentTarget.onBubbleEvent(source, args)) {

                return;

            }

            currentTarget = currentTarget.get_parent();

        }

    }

    function Sys$UI$Control$removeCssClass(className) {

        /// <summary locid="M:J#Sys.UI.Control.removeCssClass" />

        /// <param name="className" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "className", type: String}

        ]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        Sys.UI.DomElement.removeCssClass(this._element, className);

    }

    function Sys$UI$Control$toggleCssClass(className) {

        /// <summary locid="M:J#Sys.UI.Control.toggleCssClass" />

        /// <param name="className" type="String"></param>

        var e = Function._validateParams(arguments, [

            {name: "className", type: String}

        ]);

        if (e) throw e;

        if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);

        Sys.UI.DomElement.toggleCssClass(this._element, className);

    }

Sys.UI.Control.prototype = {

    _parent: null,

    _visibilityMode: Sys.UI.VisibilityMode.hide,

    get_element: Sys$UI$Control$get_element,

    get_id: Sys$UI$Control$get_id,

    set_id: Sys$UI$Control$set_id,

    get_parent: Sys$UI$Control$get_parent,

    set_parent: Sys$UI$Control$set_parent,

    get_visibilityMode: Sys$UI$Control$get_visibilityMode,

    set_visibilityMode: Sys$UI$Control$set_visibilityMode,

    get_visible: Sys$UI$Control$get_visible,

    set_visible: Sys$UI$Control$set_visible,

    addCssClass: Sys$UI$Control$addCssClass,

    dispose: Sys$UI$Control$dispose,

    onBubbleEvent: Sys$UI$Control$onBubbleEvent,

    raiseBubbleEvent: Sys$UI$Control$raiseBubbleEvent,

    removeCssClass: Sys$UI$Control$removeCssClass,

    toggleCssClass: Sys$UI$Control$toggleCssClass

}

Sys.UI.Control.registerClass('Sys.UI.Control', Sys.Component);





Type.registerNamespace('Sys');

Sys.Res={

"urlMustBeLessThan1024chars":"The history state must be small enough to not make the url larger than 1024 characters.",

"argumentTypeName":"Value is not the name of an existing type.",

"methodRegisteredTwice":"Method {0} has already been registered.",

"cantSetIdAfterInit":"The id property can\u0027t be set on this object after initialization.",

"cantBeCalledAfterDispose":"Can\u0027t be called after dispose.",

"componentCantSetIdAfterAddedToApp":"The id property of a component can\u0027t be set after it\u0027s been added to the Application object.",

"behaviorDuplicateName":"A behavior with name \u0027{0}\u0027 already exists or it is the name of an existing property on the target element.",

"notATypeName":"Value is not a valid type name.",

"typeShouldBeTypeOrString":"Value is not a valid type or a valid type name.",

"historyInvalidHistorySettingCombination":"Cannot set enableHistory to false when ScriptManager.EnableHistory is true.",

"stateMustBeStringDictionary":"The state object can only have null and string fields.",

"boolTrueOrFalse":"Value must be \u0027true\u0027 or \u0027false\u0027.",

"scriptLoadFailedNoHead":"ScriptLoader requires pages to contain a \u003chead\u003e element.",

"stringFormatInvalid":"The format string is invalid.",

"referenceNotFound":"Component \u0027{0}\u0027 was not found.",

"enumReservedName":"\u0027{0}\u0027 is a reserved name that can\u0027t be used as an enum value name.",

"eventHandlerNotFound":"Handler not found.",

"circularParentChain":"The chain of control parents can\u0027t have circular references.",

"undefinedEvent":"\u0027{0}\u0027 is not an event.",

"notAMethod":"{0} is not a method.",

"propertyUndefined":"\u0027{0}\u0027 is not a property or an existing field.",

"historyCannotEnableHistory":"Cannot set enableHistory after initialization.",

"eventHandlerInvalid":"Handler was not added through the Sys.UI.DomEvent.addHandler method.",

"scriptLoadFailedDebug":"The script \u0027{0}\u0027 failed to load. Check for:\r\n Inaccessible path.\r\n Script errors. (IE) Enable \u0027Display a notification about every script error\u0027 under advanced settings.\r\n Missing call to Sys.Application.notifyScriptLoaded().",

"propertyNotWritable":"\u0027{0}\u0027 is not a writable property.",

"enumInvalidValueName":"\u0027{0}\u0027 is not a valid name for an enum value.",

"controlAlreadyDefined":"A control is already associated with the element.",

"addHandlerCantBeUsedForError":"Can\u0027t add a handler for the error event using this method. Please set the window.onerror property instead.",

"namespaceContainsObject":"Object {0} already exists and is not a namespace.",

"cantAddNonFunctionhandler":"Can\u0027t add a handler that is not a function.",

"invalidNameSpace":"Value is not a valid namespace identifier.",

"notAnInterface":"Value is not a valid interface.",

"eventHandlerNotFunction":"Handler must be a function.",

"propertyNotAnArray":"\u0027{0}\u0027 is not an Array property.",

"typeRegisteredTwice":"Type {0} has already been registered. The type may be defined multiple times or the script file that defines it may have already been loaded. A possible cause is a change of settings during a partial update.",

"cantSetNameAfterInit":"The name property can\u0027t be set on this object after initialization.",

"historyMissingFrame":"For the history feature to work in IE, the page must have an iFrame element with id \u0027__historyFrame\u0027 pointed to a page that gets its title from the \u0027title\u0027 query string parameter and calls Sys.Application._onIFrameLoad() on the parent window. This can be done by setting EnableHistory to true on ScriptManager.",

"appDuplicateComponent":"Two components with the same id \u0027{0}\u0027 can\u0027t be added to the application.",

"historyCannotAddHistoryPointWithHistoryDisabled":"A history point can only be added if enableHistory is set to true.",

"appComponentMustBeInitialized":"Components must be initialized before they are added to the Application object.",

"baseNotAClass":"Value is not a class.",

"methodNotFound":"No method found with name \u0027{0}\u0027.",

"arrayParseBadFormat":"Value must be a valid string representation for an array. It must start with a \u0027[\u0027 and end with a \u0027]\u0027.",

"stateFieldNameInvalid":"State field names must not contain any \u0027=\u0027 characters.",

"cantSetId":"The id property can\u0027t be set on this object.",

"historyMissingHiddenInput":"For the history feature to work in Safari 2, the page must have a hidden input element with id \u0027__history\u0027.",

"stringFormatBraceMismatch":"The format string contains an unmatched opening or closing brace.",

"enumValueNotInteger":"An enumeration definition can only contain integer values.",

"propertyNullOrUndefined":"Cannot set the properties of \u0027{0}\u0027 because it returned a null value.",

"argumentDomNode":"Value must be a DOM element or a text node.",

"componentCantSetIdTwice":"The id property of a component can\u0027t be set more than once.",

"createComponentOnDom":"Value must be null for Components that are not Controls or Behaviors.",

"createNotComponent":"{0} does not derive from Sys.Component.",

"createNoDom":"Value must not be null for Controls and Behaviors.",

"cantAddWithoutId":"Can\u0027t add a component that doesn\u0027t have an id.",

"badTypeName":"Value is not the name of the type being registered or the name is a reserved word.",

"argumentInteger":"Value must be an integer.",

"scriptLoadMultipleCallbacks":"The script \u0027{0}\u0027 contains multiple calls to Sys.Application.notifyScriptLoaded(). Only one is allowed.",

"invokeCalledTwice":"Cannot call invoke more than once.",

"webServiceFailed":"The server method \u0027{0}\u0027 failed with the following error: {1}",

"webServiceInvalidJsonWrapper":"The server method \u0027{0}\u0027 returned invalid data. The \u0027d\u0027 property is missing from the JSON wrapper.",

"argumentType":"Object cannot be converted to the required type.",

"argumentNull":"Value cannot be null.",

"controlCantSetId":"The id property can\u0027t be set on a control.",

"formatBadFormatSpecifier":"Format specifier was invalid.",

"webServiceFailedNoMsg":"The server method \u0027{0}\u0027 failed.",

"argumentDomElement":"Value must be a DOM element.",

"invalidExecutorType":"Could not create a valid Sys.Net.WebRequestExecutor from: {0}.",

"cannotCallBeforeResponse":"Cannot call {0} when responseAvailable is false.",

"actualValue":"Actual value was {0}.",

"enumInvalidValue":"\u0027{0}\u0027 is not a valid value for enum {1}.",

"scriptLoadFailed":"The script \u0027{0}\u0027 could not be loaded.",

"parameterCount":"Parameter count mismatch.",

"cannotDeserializeEmptyString":"Cannot deserialize empty string.",

"formatInvalidString":"Input string was not in a correct format.",

"invalidTimeout":"Value must be greater than or equal to zero.",

"cannotAbortBeforeStart":"Cannot abort when executor has not started.",

"argument":"Value does not fall within the expected range.",

"cannotDeserializeInvalidJson":"Cannot deserialize. The data does not correspond to valid JSON.",

"invalidHttpVerb":"httpVerb cannot be set to an empty or null string.",

"nullWebRequest":"Cannot call executeRequest with a null webRequest.",

"eventHandlerInvalid":"Handler was not added through the Sys.UI.DomEvent.addHandler method.",

"cannotSerializeNonFiniteNumbers":"Cannot serialize non finite numbers.",

"argumentUndefined":"Value cannot be undefined.",

"webServiceInvalidReturnType":"The server method \u0027{0}\u0027 returned an invalid type. Expected type: {1}",

"servicePathNotSet":"The path to the web service has not been set.",

"argumentTypeWithTypes":"Object of type \u0027{0}\u0027 cannot be converted to type \u0027{1}\u0027.",

"cannotCallOnceStarted":"Cannot call {0} once started.",

"badBaseUrl1":"Base URL does not contain ://.",

"badBaseUrl2":"Base URL does not contain another /.",

"badBaseUrl3":"Cannot find last / in base URL.",

"setExecutorAfterActive":"Cannot set executor after it has become active.",

"paramName":"Parameter name: {0}",

"cannotCallOutsideHandler":"Cannot call {0} outside of a completed event handler.",

"cannotSerializeObjectWithCycle":"Cannot serialize object with cyclic reference within child properties.",

"format":"One of the identified items was in an invalid format.",

"assertFailedCaller":"Assertion Failed: {0}\r\nat {1}",

"argumentOutOfRange":"Specified argument was out of the range of valid values.",

"webServiceTimedOut":"The server method \u0027{0}\u0027 timed out.",

"notImplemented":"The method or operation is not implemented.",

"assertFailed":"Assertion Failed: {0}",

"invalidOperation":"Operation is not valid due to the current state of the object.",

"breakIntoDebugger":"{0}\r\n\r\nBreak into debugger?"

};



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