AJAX

Discussion in 'Programming & Software Development' started by Luke212, Jun 5, 2009.

  1. Luke212

    Luke212 Member

    Joined:
    Feb 26, 2003
    Messages:
    10,055
    Location:
    Sydney
    Last time I tried AJAX it was buggy and on the bleeding edge. As I understand it now VS 2008 has some integrated support for AJAX?

    If I were to consider AJAX for projects, what types of applications would they be most suitable? I would assume not for your standard marketing website?

    I would also assume only some components/sections of a page would be AJAX, or do you design the whole site/window to use AJAX?
     
  2. seano_bob_seano

    seano_bob_seano Member

    Joined:
    Nov 28, 2002
    Messages:
    455
    Location:
    Melbourne
  3. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
    The ASP.Net Ajax Framework should ONLY be used for non-public facing pages.

    Untill the next version is released which apparently only sends back whats required and not the entire viewstate/html. Don't use it.

    Learn jQuery.
     
  4. dukestar

    dukestar Member

    Joined:
    May 4, 2002
    Messages:
    827
    Location:
    Sydney
    Is this only the case for update panels elyzion?

    I use web services with the script manager to pull down information, would you only recommend using these on internal apps also?
     
  5. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
    It creates FAR too much unnecessary code, so yes i recommend only using them internally too.

    For anything thats public facing i create custom http handlers in a seperate project, theses can call web services or the db or what ever you want in a clean maintainable file that handles text/json/xml etc.

    Register them in the web.config.

    Then use jquery to target those handlers.


    If you want i can write up an example project tonight and post it on here. One of the architects here at work used to do the same as you using the asp.net ajax toolkit/framework with script manager and web services, and after doing my method outside of work hes convinced and agrees that you shouldn't use the asp.net ajax framework on any public facing app.

    Granted when the new version comes out i may change my mind. It sounds promissing.

    For administration sections tho, update panel is a god send.
     
  6. dukestar

    dukestar Member

    Joined:
    May 4, 2002
    Messages:
    827
    Location:
    Sydney
    Thanks that would be great, always keen to learn better ways of doing things :thumbup:
     
  7. ravescar

    ravescar Member

    Joined:
    Nov 22, 2007
    Messages:
    1,603
    Location:
    Darwin
    That is simply false, how about do soem better research before outputting such an blanket statement like that.
    Update panel in asp.net ajax extension sends back all the data in page, yes. but alternatively you can just use asmx web service, combined with a javascript call instead, which is very lightweight.

    with JS call you can restrict it to only send back and return the data you need.
     
  8. OP
    OP
    Luke212

    Luke212 Member

    Joined:
    Feb 26, 2003
    Messages:
    10,055
    Location:
    Sydney
    so you are saying i should build a web-service and call it with a javascript callback to populate some control?
    i think that is what jquery does, but i am not sure yet.
     
  9. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
    Yeah that's pretty much what it does, but he's obviously never looked at the script files generated on the fly for making those web service calls. Otherwise he wouldn't be calling them lightweight.

    It's like

    Update Panel Infomation
    |-------------------------------------------------------------------------|

    Client side callback methods
    |-----------------------------|

    jQuery + Http Handlers
    |----|
     
  10. ravescar

    ravescar Member

    Joined:
    Nov 22, 2007
    Messages:
    1,603
    Location:
    Darwin
    something like this:

    Code:
    <asp:ScriptManager id="ScriptManager" runat="Server">
    	<Services>
    		<asp:ServiceReference Path="~/GenericData.asmx" />
    	</Services>
    </asp:ScriptManager>
    
    <script language="Javascript">
    function GetPerson(){
            val={};
    	val.PERSON_ID=<somevalue>;
    //Web service call
    GenericData.RetrieveNextPerson(val,evaluateResponse,FailedCallback);
    	
    }
    
    function evaluateResponse(result, eventArgs){
       alert(result["PERSON_NAME"]);
     //or populating to control below
    <%=somecontro.CLIENT_ID%>=result["PERSON_NAME"];
    }
    
    </script>
    
    
    That is all that you need to write to use it, apart from web service which you also need to write for updatepanel anyway.

    It is all in Asp.net ajax extension, no other addon necessary.
     
  11. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
    Yeah, except for....

    [i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i]

    [QUOTE]// 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()[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/QUOTE][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i]

    And all the rest of the web resources that get spat out onto the page.[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i]
     
    Last edited: Jun 5, 2009
  12. ravescar

    ravescar Member

    Joined:
    Nov 22, 2007
    Messages:
    1,603
    Location:
    Darwin
    Actually i did, I was just pointing out Asp.net Ajax extension can output a much more lightweight callback than Updatepanel can do.

    I didn't realize it now turned to discussion of whether page itself was lightweight.
     
  13. ravescar

    ravescar Member

    Joined:
    Nov 22, 2007
    Messages:
    1,603
    Location:
    Darwin
    Err, do you just realize that you are linking to codes for Ajax Control Toolkit, an entirely different animal to Asp.net Ajax Extension?

    I am sorry but i don't think the code you listed are even remotely relevant, since:

    1. Asp.net Ajax extension alone is enough to perform basic callback needed.
    2. My code only use Asp.net Ajax Extension, nowhere does the Ajax control toolkit comes into picture.
    3. Show me an Ajax library that does not have any javascript bloat, you won't find any, it is a price you pay for user and server interactivity.
     
    Last edited: Jun 5, 2009
  14. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
    There edited.

    Granted we can put it into release mode to reduce it.

    It still produces really nasty code. I mean, if it wasn't so bad, they wouldn't be fixing it right???

    Anyway, you can keep defending the only way you know how to do something. Thats fine. :)
     
  15. ravescar

    ravescar Member

    Joined:
    Nov 22, 2007
    Messages:
    1,603
    Location:
    Darwin
    the code elegantness is subjective, they will most likely have source control system that formats and comments code properly for development anyway.

    Also, i don't care about what the source code looks like beyond keeping footprint as small as possible(which they do with GZIP compression) and actually works.

    And you are complaining that they fix and update the code? Do they never update jQuery? Do you also complain about company updates the games and microsoft release security updates?

    Buggy software is just part of life.

    Not sure where you get the idea that it is the only AJAX technique i know, people are just quick to make assumption on internet for no reason whatsorever to show off their stupidity i guess.

    Again, I am just providing an example of AJAX call in asp.net ajax framework without using updatepanel, take it what you will.
     
  16. yoink

    yoink Member

    Joined:
    Feb 19, 2002
    Messages:
    3,489
    You didn't really need to post all that, you could just have said:
    320KB of crap JS code!
    :wired:

    Anyway, yes, learn jQuery, or similar. If you're after pre-made widgets, you'll need something other than jQuery, eg: extJS, jQuery UI, or something a bit more lightweight ;)
    Usually the main issue is integrating the widgets easily with whatever back-end you're using, so perhaps make sure that it is integrated easily, and does what you're after.
     
  17. Elyzion

    Elyzion Member

    Joined:
    Oct 27, 2004
    Messages:
    7,449
    Location:
    Singapore
  18. yoink

    yoink Member

    Joined:
    Feb 19, 2002
    Messages:
    3,489
    Last edited: Jun 5, 2009
  19. acks

    acks Member

    Joined:
    Feb 20, 2006
    Messages:
    15
    Another vote for jQuery. I am a jQuery newbie and using it with asp.net. Now, thinking to dump MS AJAX front-end mask/validation for jQuery ones.

     

Share This Page

Advertisement: