text: // var rnotwhite = ( /\S+/g );
  // var
  //     r20 = /%20/g,
  //     rhash = /#.*$/,
  //     rts = /([?&])_=[^&]*/,
  //     rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
  //
  //     // #7653, #8125, #8152: local protocol detection
  //     rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
  //     rnoContent = /^(?:GET|HEAD)$/,
  //     rprotocol = /^\/\//,
  //
  //     /* Prefilters
  //      * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  //      * 2) These are called:
  //      *    - BEFORE asking for a transport
  //      *    - AFTER param serialization (s.data is a string if s.processData is true)
  //      * 3) key is the dataType
  //      * 4) the catchall symbol "*" can be used
  //      * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  //      */
  //     prefilters = {},
  //
  //     /* Transports bindings
  //      * 1) key is the dataType
  //      * 2) the catchall symbol "*" can be used
  //      * 3) selection will start with transport dataType and THEN go to "*" if needed
  //      */
  //     transports = {},
  //
  //     // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
  //     allTypes = "*/".concat( "*" ),
  //
  //     // Anchor tag for parsing the document origin
  //     originAnchor = document.createElement( "a" );
  // originAnchor.href = location.href;
  //
  // // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  // function addToPrefiltersOrTransports( structure ) {
  //
  //     // dataTypeExpression is optional and defaults to "*"
  //     return function( dataTypeExpression, func ) {
  //
  //         if ( typeof dataTypeExpression !== "string" ) {
  //             func = dataTypeExpression;
  //             dataTypeExpression = "*";
  //         }
  //
  //         var dataType,
  //             i = 0,
  //             dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
  //
  //         if ( _z.isFunction( func ) ) {
  //
  //             // For each dataType in the dataTypeExpression
  //             while ( ( dataType = dataTypes[ i++ ] ) ) {
  //
  //                 // Prepend if requested
  //                 if ( dataType[ 0 ] === "+" ) {
  //                     dataType = dataType.slice( 1 ) || "*";
  //                     ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
  //
  //                     // Otherwise append
  //                 } else {
  //                     ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
  //                 }
  //             }
  //         }
  //     };
  // }
  //
  // // Base inspection function for prefilters and transports
  // function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
  //
  //     var inspected = {},
  //         seekingTransport = ( structure === transports );
  //
  //     function inspect( dataType ) {
  //         var selected;
  //         inspected[ dataType ] = true;
  //         _z.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
  //             var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
  //             if ( typeof dataTypeOrTransport === "string" &&
  //                 !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
  //
  //                 options.dataTypes.unshift( dataTypeOrTransport );
  //                 inspect( dataTypeOrTransport );
  //                 return false;
  //             } else if ( seekingTransport ) {
  //                 return !( selected = dataTypeOrTransport );
  //             }
  //         } );
  //         return selected;
  //     }
  //
  //     return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
  // }
  //
  // // A special extend for ajax options
  // // that takes "flat" options (not to be deep extended)
  // // Fixes #9887
  // function ajaxExtend( target, src ) {
  //     var key, deep,
  //         flatOptions = _z.ajaxSettings.flatOptions || {};
  //
  //     for ( key in src ) {
  //         if ( src[ key ] !== undefined ) {
  //             ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
  //         }
  //     }
  //     if ( deep ) {
  //         _z.extend( true, target, deep );
  //     }
  //
  //     return target;
  // }
  //
  // /* Handles responses to an ajax request:
  //  * - finds the right dataType (mediates between content-type and expected dataType)
  //  * - returns the corresponding response
  //  */
  // function ajaxHandleResponses( s, jqXHR, responses ) {
  //
  //     var ct, type, finalDataType, firstDataType,
  //         contents = s.contents,
  //         dataTypes = s.dataTypes;
  //
  //     // Remove auto dataType and get content-type in the process
  //     while ( dataTypes[ 0 ] === "*" ) {
  //         dataTypes.shift();
  //         if ( ct === undefined ) {
  //             ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
  //         }
  //     }
  //
  //     // Check if we're dealing with a known content-type
  //     if ( ct ) {
  //         for ( type in contents ) {
  //             if ( contents[ type ] && contents[ type ].test( ct ) ) {
  //                 dataTypes.unshift( type );
  //                 break;
  //             }
  //         }
  //     }
  //
  //     // Check to see if we have a response for the expected dataType
  //     if ( dataTypes[ 0 ] in responses ) {
  //         finalDataType = dataTypes[ 0 ];
  //     } else {
  //
  //         // Try convertible dataTypes
  //         for ( type in responses ) {
  //             if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
  //                 finalDataType = type;
  //                 break;
  //             }
  //             if ( !firstDataType ) {
  //                 firstDataType = type;
  //             }
  //         }
  //
  //         // Or just use first one
  //         finalDataType = finalDataType || firstDataType;
  //     }
  //
  //     // If we found a dataType
  //     // We add the dataType to the list if needed
  //     // and return the corresponding response
  //     if ( finalDataType ) {
  //         if ( finalDataType !== dataTypes[ 0 ] ) {
  //             dataTypes.unshift( finalDataType );
  //         }
  //         return responses[ finalDataType ];
  //     }
  // }
  //
  // /* Chain conversions given the request and the original response
  //  * Also sets the responseXXX fields on the jqXHR instance
  //  */
  // function ajaxConvert( s, response, jqXHR, isSuccess ) {
  //     var conv2, current, conv, tmp, prev,
  //         converters = {},
  //
  //         // Work with a copy of dataTypes in case we need to modify it for conversion
  //         dataTypes = s.dataTypes.slice();
  //
  //     // Create converters map with lowercased keys
  //     if ( dataTypes[ 1 ] ) {
  //         for ( conv in s.converters ) {
  //             converters[ conv.toLowerCase() ] = s.converters[ conv ];
  //         }
  //     }
  //
  //     current = dataTypes.shift();
  //
  //     // Convert to each sequential dataType
  //     while ( current ) {
  //
  //         if ( s.responseFields[ current ] ) {
  //             jqXHR[ s.responseFields[ current ] ] = response;
  //         }
  //
  //         // Apply the dataFilter if provided
  //         if ( !prev && isSuccess && s.dataFilter ) {
  //             response = s.dataFilter( response, s.dataType );
  //         }
  //
  //         prev = current;
  //         current = dataTypes.shift();
  //
  //         if ( current ) {
  //
  //             // There's only work to do if current dataType is non-auto
  //             if ( current === "*" ) {
  //
  //                 current = prev;
  //
  //                 // Convert response if prev dataType is non-auto and differs from current
  //             } else if ( prev !== "*" && prev !== current ) {
  //
  //                 // Seek a direct converter
  //                 conv = converters[ prev + " " + current ] || converters[ "* " + current ];
  //
  //                 // If none found, seek a pair
  //                 if ( !conv ) {
  //                     for ( conv2 in converters ) {
  //
  //                         // If conv2 outputs current
  //                         tmp = conv2.split( " " );
  //                         if ( tmp[ 1 ] === current ) {
  //
  //                             // If prev can be converted to accepted input
  //                             conv = converters[ prev + " " + tmp[ 0 ] ] ||
  //                                 converters[ "* " + tmp[ 0 ] ];
  //                             if ( conv ) {
  //
  //                                 // Condense equivalence converters
  //                                 if ( conv === true ) {
  //                                     conv = converters[ conv2 ];
  //
  //                                     // Otherwise, insert the intermediate dataType
  //                                 } else if ( converters[ conv2 ] !== true ) {
  //                                     current = tmp[ 0 ];
  //                                     dataTypes.unshift( tmp[ 1 ] );
  //                                 }
  //                                 break;
  //                             }
  //                         }
  //                     }
  //                 }
  //
  //                 // Apply converter (if not an equivalence)
  //                 if ( conv !== true ) {
  //
  //                     // Unless errors are allowed to bubble, catch and return them
  //                     if ( conv && s.throws ) {
  //                         response = conv( response );
  //                     } else {
  //                         try {
  //                             response = conv( response );
  //                         } catch ( e ) {
  //                             return {
  //                                 state: "parsererror",
  //                                 error: conv ? e : "No conversion from " + prev + " to " + current
  //                             };
  //                         }
  //                     }
  //                 }
  //             }
  //         }
  //     }
  //
  //     return { state: "success", data: response };
  // }
  //
  // _z.extend( {
  //
  //     // Counter for holding the number of active queries
  //     active: 0,
  //
  //     // Last-Modified header cache for next request
  //     lastModified: {},
  //     etag: {},
  //
  //     ajaxSettings: {
  //         url: location.href,
  //         type: "GET",
  //         isLocal: rlocalProtocol.test( location.protocol ),
  //         global: true,
  //         processData: true,
  //         async: true,
  //         contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  //
  //         /*
  //         timeout: 0,
  //         data: null,
  //         dataType: null,
  //         username: null,
  //         password: null,
  //         cache: null,
  //         throws: false,
  //         traditional: false,
  //         headers: {},
  //         */
  //
  //         accepts: {
  //             "*": allTypes,
  //             text: "text/plain",
  //             html: "text/html",
  //             xml: "application/xml, text/xml",
  //             json: "application/json, text/javascript"
  //         },
  //
  //         contents: {
  //             xml: /\bxml\b/,
  //             html: /\bhtml/,
  //             json: /\bjson\b/
  //         },
  //
  //         responseFields: {
  //             xml: "responseXML",
  //             text: "responseText",
  //             json: "responseJSON"
  //         },
  //
  //         // Data converters
  //         // Keys separate source (or catchall "*") and destination types with a single space
  //         converters: {
  //
  //             // Convert anything to text
  //             "* text": String,
  //
  //             // Text to html (true = no transformation)
  //             "text html": true,
  //
  //             // Evaluate text as a json expression
  //             "text json": JSON.parse,
  //
  //             // Parse text as xml
  //             "text xml": _z.parse.parseXML
  //         },
  //
  //         // For options that shouldn't be deep extended:
  //         // you can add your own custom options here if
  //         // and when you create one that shouldn't be
  //         // deep extended (see ajaxExtend)
  //         flatOptions: {
  //             url: true,
  //             context: true
  //         }
  //     },
  //
  //     // Creates a full fledged settings object into target
  //     // with both ajaxSettings and settings fields.
  //     // If target is omitted, writes into ajaxSettings.
  //     ajaxSetup: function( target, settings ) {
  //         return settings ?
  //
  //             // Building a settings object
  //             ajaxExtend( ajaxExtend( target, _z.ajaxSettings ), settings ) :
  //
  //             // Extending ajaxSettings
  //             ajaxExtend( _z.ajaxSettings, target );
  //     },
  //
  //     ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
  //     ajaxTransport: addToPrefiltersOrTransports( transports ),
  //
  //     // Main method
  //     ajax: function( url, options ) {
  //
  //         // If url is an object, simulate pre-1.5 signature
  //         if ( typeof url === "object" ) {
  //             options = url;
  //             url = undefined;
  //         }
  //
  //         // Force options to be an object
  //         options = options || {};
  //
  //         var transport,
  //
  //             // URL without anti-cache param
  //             cacheURL,
  //
  //             // Response headers
  //             responseHeadersString,
  //             responseHeaders,
  //
  //             // timeout handle
  //             timeoutTimer,
  //
  //             // Url cleanup var
  //             urlAnchor,
  //
  //             // Request state (becomes false upon send and true upon completion)
  //             completed,
  //
  //             // To know if global events are to be dispatched
  //             fireGlobals,
  //
  //             // Loop variable
  //             i,
  //
  //             // uncached part of the url
  //             uncached,
  //
  //             // Create the final options object
  //             s = _z.ajaxSetup( {}, options ),
  //
  //             // Callbacks context
  //             callbackContext = s.context || s,
  //
  //             // Context for global events is callbackContext if it is a DOM node or jQuery collection
  //             globalEventContext = s.context &&
  //             ( callbackContext.nodeType || callbackContext._z ) ?
  //                 _z( callbackContext ) :
  //                 _z.event,
  //
  //             // Deferreds
  //             deferred = jQuery.Deferred(),
  //             completeDeferred = jQuery.Callbacks( "once memory" ),
  //
  //             // Status-dependent callbacks
  //             statusCode = s.statusCode || {},
  //
  //             // Headers (they are sent all at once)
  //             requestHeaders = {},
  //             requestHeadersNames = {},
  //
  //             // Default abort message
  //             strAbort = "canceled",
  //
  //             // Fake xhr
  //             jqXHR = {
  //                 readyState: 0,
  //
  //                 // Builds headers hashtable if needed
  //                 getResponseHeader: function( key ) {
  //                     var match;
  //                     if ( completed ) {
  //                         if ( !responseHeaders ) {
  //                             responseHeaders = {};
  //                             while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
  //                                 responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
  //                             }
  //                         }
  //                         match = responseHeaders[ key.toLowerCase() ];
  //                     }
  //                     return match == null ? null : match;
  //                 },
  //
  //                 // Raw string
  //                 getAllResponseHeaders: function() {
  //                     return completed ? responseHeadersString : null;
  //                 },
  //
  //                 // Caches the header
  //                 setRequestHeader: function( name, value ) {
  //                     if ( completed == null ) {
  //                         name = requestHeadersNames[ name.toLowerCase() ] =
  //                             requestHeadersNames[ name.toLowerCase() ] || name;
  //                         requestHeaders[ name ] = value;
  //                     }
  //                     return this;
  //                 },
  //
  //                 // Overrides response content-type header
  //                 overrideMimeType: function( type ) {
  //                     if ( completed == null ) {
  //                         s.mimeType = type;
  //                     }
  //                     return this;
  //                 },
  //
  //                 // Status-dependent callbacks
  //                 statusCode: function( map ) {
  //                     var code;
  //                     if ( map ) {
  //                         if ( completed ) {
  //
  //                             // Execute the appropriate callbacks
  //                             jqXHR.always( map[ jqXHR.status ] );
  //                         } else {
  //
  //                             // Lazy-add the new callbacks in a way that preserves old ones
  //                             for ( code in map ) {
  //                                 statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
  //                             }
  //                         }
  //                     }
  //                     return this;
  //                 },
  //
  //                 // Cancel the request
  //                 abort: function( statusText ) {
  //                     var finalText = statusText || strAbort;
  //                     if ( transport ) {
  //                         transport.abort( finalText );
  //                     }
  //                     done( 0, finalText );
  //                     return this;
  //                 }
  //             };
  //
  //         // Attach deferreds
  //         deferred.promise( jqXHR );
  //
  //         // Add protocol if not provided (prefilters might expect it)
  //         // Handle falsy url in the settings object (#10093: consistency with old signature)
  //         // We also use the url parameter if available
  //         s.url = ( ( url || s.url || location.href ) + "" )
  //             .replace( rprotocol, location.protocol + "//" );
  //
  //         // Alias method option to type as per ticket #12004
  //         s.type = options.method || options.type || s.method || s.type;
  //
  //         // Extract dataTypes list
  //         s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
  //
  //         // A cross-domain request is in order when the origin doesn't match the current origin.
  //         if ( s.crossDomain == null ) {
  //             urlAnchor = document.createElement( "a" );
  //
  //             // Support: IE <=8 - 11, Edge 12 - 13
  //             // IE throws exception on accessing the href property if url is malformed,
  //             // e.g. http://example.com:80x/
  //             try {
  //                 urlAnchor.href = s.url;
  //
  //                 // Support: IE <=8 - 11 only
  //                 // Anchor's host property isn't correctly set when s.url is relative
  //                 urlAnchor.href = urlAnchor.href;
  //                 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
  //                     urlAnchor.protocol + "//" + urlAnchor.host;
  //             } catch ( e ) {
  //
  //                 // If there is an error parsing the URL, assume it is crossDomain,
  //                 // it can be rejected by the transport if it is invalid
  //                 s.crossDomain = true;
  //             }
  //         }
  //
  //         // Convert data if not already a string
  //         if ( s.data && s.processData && typeof s.data !== "string" ) {
  //             s.data = _z.param( s.data, s.traditional );
  //         }
  //
  //         // Apply prefilters
  //         inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  //
  //         // If request was aborted inside a prefilter, stop there
  //         if ( completed ) {
  //             return jqXHR;
  //         }
  //
  //         // We can fire global events as of now if asked to
  //         // Don't fire events if _z.event is undefined in an AMD-usage scenario (#15118)
  //         fireGlobals = _z.event && s.global;
  //
  //         // Watch for a new set of requests
  //         if ( fireGlobals && _z.active++ === 0 ) {
  //             _z.event.trigger( "ajaxStart" );
  //         }
  //
  //         // Uppercase the type
  //         s.type = s.type.toUpperCase();
  //
  //         // Determine if request has content
  //         s.hasContent = !rnoContent.test( s.type );
  //
  //         // Save the URL in case we're toying with the If-Modified-Since
  //         // and/or If-None-Match header later on
  //         // Remove hash to simplify url manipulation
  //         cacheURL = s.url.replace( rhash, "" );
  //
  //         // More options handling for requests with no content
  //         if ( !s.hasContent ) {
  //
  //             // Remember the hash so we can put it back
  //             uncached = s.url.slice( cacheURL.length );
  //
  //             // If data is available, append data to url
  //             if ( s.data ) {
  //                 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
  //
  //                 // #9682: remove data so that it's not used in an eventual retry
  //                 delete s.data;
  //             }
  //
  //             // Add anti-cache in uncached url if needed
  //             if ( s.cache === false ) {
  //                 cacheURL = cacheURL.replace( rts, "" );
  //                 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
  //             }
  //
  //             // Put hash and anti-cache on the URL that will be requested (gh-1732)
  //             s.url = cacheURL + uncached;
  //
  //             // Change '%20' to '+' if this is encoded form body content (gh-2658)
  //         } else if ( s.data && s.processData &&
  //             ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
  //             s.data = s.data.replace( r20, "+" );
  //         }
  //
  //         // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  //         if ( s.ifModified ) {
  //             if ( _z.lastModified[ cacheURL ] ) {
  //                 jqXHR.setRequestHeader( "If-Modified-Since", _z.lastModified[ cacheURL ] );
  //             }
  //             if ( _z.etag[ cacheURL ] ) {
  //                 jqXHR.setRequestHeader( "If-None-Match", _z.etag[ cacheURL ] );
  //             }
  //         }
  //
  //         // Set the correct header, if data is being sent
  //         if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
  //             jqXHR.setRequestHeader( "Content-Type", s.contentType );
  //         }
  //
  //         // Set the Accepts header for the server, depending on the dataType
  //         jqXHR.setRequestHeader(
  //             "Accept",
  //             s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
  //                 s.accepts[ s.dataTypes[ 0 ] ] +
  //                 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
  //                 s.accepts[ "*" ]
  //         );
  //
  //         // Check for headers option
  //         for ( i in s.headers ) {
  //             jqXHR.setRequestHeader( i, s.headers[ i ] );
  //         }
  //
  //         // Allow custom headers/mimetypes and early abort
  //         if ( s.beforeSend &&
  //             ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
  //
  //             // Abort if not done already and return
  //             return jqXHR.abort();
  //         }
  //
  //         // Aborting is no longer a cancellation
  //         strAbort = "abort";
  //
  //         // Install callbacks on deferreds
  //         completeDeferred.add( s.complete );
  //         jqXHR.done( s.success );
  //         jqXHR.fail( s.error );
  //
  //         // Get transport
  //         transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  //
  //         // If no transport, we auto-abort
  //         if ( !transport ) {
  //             done( -1, "No Transport" );
  //         } else {
  //             jqXHR.readyState = 1;
  //
  //             // Send global event
  //             if ( fireGlobals ) {
  //                 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
  //             }
  //
  //             // If request was aborted inside ajaxSend, stop there
  //             if ( completed ) {
  //                 return jqXHR;
  //             }
  //
  //             // Timeout
  //             if ( s.async && s.timeout > 0 ) {
  //                 timeoutTimer = window.setTimeout( function() {
  //                     jqXHR.abort( "timeout" );
  //                 }, s.timeout );
  //             }
  //
  //             try {
  //                 completed = false;
  //                 transport.send( requestHeaders, done );
  //             } catch ( e ) {
  //
  //                 // Rethrow post-completion exceptions
  //                 if ( completed ) {
  //                     throw e;
  //                 }
  //
  //                 // Propagate others as results
  //                 done( -1, e );
  //             }
  //         }
  //
  //         // Callback for when everything is done
  //         function done( status, nativeStatusText, responses, headers ) {
  //             var isSuccess, success, error, response, modified,
  //                 statusText = nativeStatusText;
  //
  //             // Ignore repeat invocations
  //             if ( completed ) {
  //                 return;
  //             }
  //
  //             completed = true;
  //
  //             // Clear timeout if it exists
  //             if ( timeoutTimer ) {
  //                 window.clearTimeout( timeoutTimer );
  //             }
  //
  //             // Dereference transport for early garbage collection
  //             // (no matter how long the jqXHR object will be used)
  //             transport = undefined;
  //
  //             // Cache response headers
  //             responseHeadersString = headers || "";
  //
  //             // Set readyState
  //             jqXHR.readyState = status > 0 ? 4 : 0;
  //
  //             // Determine if successful
  //             isSuccess = status >= 200 && status < 300 || status === 304;
  //
  //             // Get response data
  //             if ( responses ) {
  //                 response = ajaxHandleResponses( s, jqXHR, responses );
  //             }
  //
  //             // Convert no matter what (that way responseXXX fields are always set)
  //             response = ajaxConvert( s, response, jqXHR, isSuccess );
  //
  //             // If successful, handle type chaining
  //             if ( isSuccess ) {
  //
  //                 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  //                 if ( s.ifModified ) {
  //                     modified = jqXHR.getResponseHeader( "Last-Modified" );
  //                     if ( modified ) {
  //                         _z.lastModified[ cacheURL ] = modified;
  //                     }
  //                     modified = jqXHR.getResponseHeader( "etag" );
  //                     if ( modified ) {
  //                         _z.etag[ cacheURL ] = modified;
  //                     }
  //                 }
  //
  //                 // if no content
  //                 if ( status === 204 || s.type === "HEAD" ) {
  //                     statusText = "nocontent";
  //
  //                     // if not modified
  //                 } else if ( status === 304 ) {
  //                     statusText = "notmodified";
  //
  //                     // If we have data, let's convert it
  //                 } else {
  //                     statusText = response.state;
  //                     success = response.data;
  //                     error = response.error;
  //                     isSuccess = !error;
  //                 }
  //             } else {
  //
  //                 // Extract error from statusText and normalize for non-aborts
  //                 error = statusText;
  //                 if ( status || !statusText ) {
  //                     statusText = "error";
  //                     if ( status < 0 ) {
  //                         status = 0;
  //                     }
  //                 }
  //             }
  //
  //             // Set data for the fake xhr object
  //             jqXHR.status = status;
  //             jqXHR.statusText = ( nativeStatusText || statusText ) + "";
  //
  //             // Success/Error
  //             if ( isSuccess ) {
  //                 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
  //             } else {
  //                 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
  //             }
  //
  //             // Status-dependent callbacks
  //             jqXHR.statusCode( statusCode );
  //             statusCode = undefined;
  //
  //             if ( fireGlobals ) {
  //                 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
  //                     [ jqXHR, s, isSuccess ? success : error ] );
  //             }
  //
  //             // Complete
  //             completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
  //
  //             if ( fireGlobals ) {
  //                 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
  //
  //                 // Handle the global AJAX counter
  //                 if ( !( --_z.active ) ) {
  //                     _z.event.trigger( "ajaxStop" );
  //                 }
  //             }
  //         }
  //
  //         return jqXHR;
  //     },
  //
  //     getJSON: function( url, data, callback ) {
  //         return _z.get( url, data, callback, "json" );
  //     },
  //
  //     getScript: function( url, callback ) {
  //         return _z.get( url, undefined, callback, "script" );
  //     }
  // } );
  //
  // _z.each( [ "get", "post" ], function( i, method ) {
  //     _z[ method ] = function( url, data, callback, type ) {
  //
  //         // Shift arguments if data argument was omitted
  //         if ( _z.isFunction( data ) ) {
  //             type = type || callback;
  //             callback = data;
  //             data = undefined;
  //         }
  //
  //         // The url can be an options object (which then must have .url)
  //         return _z.ajax( _z.extend( {
  //             url: url,
  //             type: method,
  //             dataType: type,
  //             data: data,
  //             success: callback
  //         }, _z.isObject( url ) && url ) );
  //     };
  // } );
  //
  
  
  
  
  
  
  var rnotwhite = ( /\S+/g );
  var
      r20 = /%20/g,
      rhash = /#.*$/,
      rts = /([?&])_=[^&]*/,
      rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
  
      // #7653, #8125, #8152: local protocol detection
      rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
      rnoContent = /^(?:GET|HEAD)$/,
      rprotocol = /^\/\//,
  
      /* Prefilters
       * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
       * 2) These are called:
       *    - BEFORE asking for a transport
       *    - AFTER param serialization (s.data is a string if s.processData is true)
       * 3) key is the dataType
       * 4) the catchall symbol "*" can be used
       * 5) execution will start with transport dataType and THEN continue down to "*" if needed
       */
      prefilters = {},
  
      /* Transports bindings
       * 1) key is the dataType
       * 2) the catchall symbol "*" can be used
       * 3) selection will start with transport dataType and THEN go to "*" if needed
       */
      transports = {},
  
      // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
      allTypes = "*/".concat( "*" ),
  
      // Anchor tag for parsing the document origin
      originAnchor = document.createElement( "a" );
  originAnchor.href = location.href;
  
  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  function addToPrefiltersOrTransports( structure ) {
  
      // dataTypeExpression is optional and defaults to "*"
      return function( dataTypeExpression, func ) {
  
          if ( typeof dataTypeExpression !== "string" ) {
              func = dataTypeExpression;
              dataTypeExpression = "*";
          }
  
          var dataType,
              i = 0,
              dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
  
          if ( _z.isFunction( func ) ) {
  
              // For each dataType in the dataTypeExpression
              while ( ( dataType = dataTypes[ i++ ] ) ) {
  
                  // Prepend if requested
                  if ( dataType[ 0 ] === "+" ) {
                      dataType = dataType.slice( 1 ) || "*";
                      ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
  
                      // Otherwise append
                  } else {
                      ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
                  }
              }
          }
      };
  }
  
  // Base inspection function for prefilters and transports
  function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
  
      var inspected = {},
          seekingTransport = ( structure === transports );
  
      function inspect( dataType ) {
          var selected;
          inspected[ dataType ] = true;
          _z.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
              var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
              if ( typeof dataTypeOrTransport === "string" &&
                  !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
  
                  options.dataTypes.unshift( dataTypeOrTransport );
                  inspect( dataTypeOrTransport );
                  return false;
              } else if ( seekingTransport ) {
                  return !( selected = dataTypeOrTransport );
              }
          } );
          return selected;
      }
  
      return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
  }
  
  // A special extend for ajax options
  // that takes "flat" options (not to be deep extended)
  // Fixes #9887
  function ajaxExtend( target, src ) {
      var key, deep,
          flatOptions = _z.ajaxSettings.flatOptions || {};
  
      for ( key in src ) {
          if ( src[ key ] !== undefined ) {
              ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
          }
      }
      if ( deep ) {
          _z.extend( true, target, deep );
      }
  
      return target;
  }
  
  /* Handles responses to an ajax request:
   * - finds the right dataType (mediates between content-type and expected dataType)
   * - returns the corresponding response
   */
  function ajaxHandleResponses( s, jqXHR, responses ) {
  
      var ct, type, finalDataType, firstDataType,
          contents = s.contents,
          dataTypes = s.dataTypes;
  
      // Remove auto dataType and get content-type in the process
      while ( dataTypes[ 0 ] === "*" ) {
          dataTypes.shift();
          if ( ct === undefined ) {
              ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
          }
      }
  
      // Check if we're dealing with a known content-type
      if ( ct ) {
          for ( type in contents ) {
              if ( contents[ type ] && contents[ type ].test( ct ) ) {
                  dataTypes.unshift( type );
                  break;
              }
          }
      }
  
      // Check to see if we have a response for the expected dataType
      if ( dataTypes[ 0 ] in responses ) {
          finalDataType = dataTypes[ 0 ];
      } else {
  
          // Try convertible dataTypes
          for ( type in responses ) {
              if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
                  finalDataType = type;
                  break;
              }
              if ( !firstDataType ) {
                  firstDataType = type;
              }
          }
  
          // Or just use first one
          finalDataType = finalDataType || firstDataType;
      }
  
      // If we found a dataType
      // We add the dataType to the list if needed
      // and return the corresponding response
      if ( finalDataType ) {
          if ( finalDataType !== dataTypes[ 0 ] ) {
              dataTypes.unshift( finalDataType );
          }
          return responses[ finalDataType ];
      }
  }
  
  /* Chain conversions given the request and the original response
   * Also sets the responseXXX fields on the jqXHR instance
   */
  function ajaxConvert( s, response, jqXHR, isSuccess ) {
      var conv2, current, conv, tmp, prev,
          converters = {},
  
          // Work with a copy of dataTypes in case we need to modify it for conversion
          dataTypes = s.dataTypes.slice();
  
      // Create converters map with lowercased keys
      if ( dataTypes[ 1 ] ) {
          for ( conv in s.converters ) {
              converters[ conv.toLowerCase() ] = s.converters[ conv ];
          }
      }
  
      current = dataTypes.shift();
  
      // Convert to each sequential dataType
      while ( current ) {
  
          if ( s.responseFields[ current ] ) {
              jqXHR[ s.responseFields[ current ] ] = response;
          }
  
          // Apply the dataFilter if provided
          if ( !prev && isSuccess && s.dataFilter ) {
              response = s.dataFilter( response, s.dataType );
          }
  
          prev = current;
          current = dataTypes.shift();
  
          if ( current ) {
  
              // There's only work to do if current dataType is non-auto
              if ( current === "*" ) {
  
                  current = prev;
  
                  // Convert response if prev dataType is non-auto and differs from current
              } else if ( prev !== "*" && prev !== current ) {
  
                  // Seek a direct converter
                  conv = converters[ prev + " " + current ] || converters[ "* " + current ];
  
                  // If none found, seek a pair
                  if ( !conv ) {
                      for ( conv2 in converters ) {
  
                          // If conv2 outputs current
                          tmp = conv2.split( " " );
                          if ( tmp[ 1 ] === current ) {
  
                              // If prev can be converted to accepted input
                              conv = converters[ prev + " " + tmp[ 0 ] ] ||
                                  converters[ "* " + tmp[ 0 ] ];
                              if ( conv ) {
  
                                  // Condense equivalence converters
                                  if ( conv === true ) {
                                      conv = converters[ conv2 ];
  
                                      // Otherwise, insert the intermediate dataType
                                  } else if ( converters[ conv2 ] !== true ) {
                                      current = tmp[ 0 ];
                                      dataTypes.unshift( tmp[ 1 ] );
                                  }
                                  break;
                              }
                          }
                      }
                  }
  
                  // Apply converter (if not an equivalence)
                  if ( conv !== true ) {
  
                      // Unless errors are allowed to bubble, catch and return them
                      if ( conv && s.throws ) {
                          response = conv( response );
                      } else {
                          try {
                              response = conv( response );
                          } catch ( e ) {
                              return {
                                  state: "parsererror",
                                  error: conv ? e : "No conversion from " + prev + " to " + current
                              };
                          }
                      }
                  }
              }
          }
      }
  
      return { state: "success", data: response };
  }
  
  _z.extend( {
  
      // Counter for holding the number of active queries
      active: 0,
  
      // Last-Modified header cache for next request
      lastModified: {},
      etag: {},
  
      ajaxSettings: {
          url: location.href,
          type: "GET",
          isLocal: rlocalProtocol.test( location.protocol ),
          global: true,
          processData: true,
          async: true,
          contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  
          /*
          timeout: 0,
          data: null,
          dataType: null,
          username: null,
          password: null,
          cache: null,
          throws: false,
          traditional: false,
          headers: {},
          */
  
          accepts: {
              "*": allTypes,
              text: "text/plain",
              html: "text/html",
              xml: "application/xml, text/xml",
              json: "application/json, text/javascript"
          },
  
          contents: {
              xml: /\bxml\b/,
              html: /\bhtml/,
              json: /\bjson\b/
          },
  
          responseFields: {
              xml: "responseXML",
              text: "responseText",
              json: "responseJSON"
          },
  
          // Data converters
          // Keys separate source (or catchall "*") and destination types with a single space
          converters: {
  
              // Convert anything to text
              "* text": String,
  
              // Text to html (true = no transformation)
              "text html": true,
  
              // Evaluate text as a json expression
              "text json": JSON.parse,
  
              // Parse text as xml
              "text xml": _z.parse.parseXML
          },
  
          // For options that shouldn't be deep extended:
          // you can add your own custom options here if
          // and when you create one that shouldn't be
          // deep extended (see ajaxExtend)
          flatOptions: {
              url: true,
              context: true
          }
      },
  
      // Creates a full fledged settings object into target
      // with both ajaxSettings and settings fields.
      // If target is omitted, writes into ajaxSettings.
      ajaxSetup: function( target, settings ) {
          return settings ?
  
              // Building a settings object
              ajaxExtend( ajaxExtend( target, _z.ajaxSettings ), settings ) :
  
              // Extending ajaxSettings
              ajaxExtend( _z.ajaxSettings, target );
      },
  
      ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
      ajaxTransport: addToPrefiltersOrTransports( transports ),
  
      // Main method
      ajax: function( url, options ) {
  
          // If url is an object, simulate pre-1.5 signature
          if ( typeof url === "object" ) {
              options = url;
              url = undefined;
          }
  
          // Force options to be an object
          options = options || {};
  
          var transport,
  
              // URL without anti-cache param
              cacheURL,
  
              // Response headers
              responseHeadersString,
              responseHeaders,
  
              // timeout handle
              timeoutTimer,
  
              // Url cleanup var
              urlAnchor,
  
              // Request state (becomes false upon send and true upon completion)
              completed,
  
              // To know if global events are to be dispatched
              fireGlobals,
  
              // Loop variable
              i,
  
              // uncached part of the url
              uncached,
  
              // Create the final options object
              s = _z.ajaxSetup( {}, options ),
  
              // Callbacks context
              callbackContext = s.context || s,
  
              // Context for global events is callbackContext if it is a DOM node or jQuery collection
              globalEventContext = s.context &&
              ( callbackContext.nodeType || callbackContext._z ) ?
                  _z( callbackContext ) :
                  _z.event,
  
              // Deferreds
              deferred = jQuery.Deferred(),
              completeDeferred = jQuery.Callbacks( "once memory" ),
  
              // Status-dependent callbacks
              statusCode = s.statusCode || {},
  
              // Headers (they are sent all at once)
              requestHeaders = {},
              requestHeadersNames = {},
  
              // Default abort message
              strAbort = "canceled",
  
              // Fake xhr
              jqXHR = {
                  readyState: 0,
  
                  // Builds headers hashtable if needed
                  getResponseHeader: function( key ) {
                      var match;
                      if ( completed ) {
                          if ( !responseHeaders ) {
                              responseHeaders = {};
                              while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
                                  responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
                              }
                          }
                          match = responseHeaders[ key.toLowerCase() ];
                      }
                      return match == null ? null : match;
                  },
  
                  // Raw string
                  getAllResponseHeaders: function() {
                      return completed ? responseHeadersString : null;
                  },
  
                  // Caches the header
                  setRequestHeader: function( name, value ) {
                      if ( completed == null ) {
                          name = requestHeadersNames[ name.toLowerCase() ] =
                              requestHeadersNames[ name.toLowerCase() ] || name;
                          requestHeaders[ name ] = value;
                      }
                      return this;
                  },
  
                  // Overrides response content-type header
                  overrideMimeType: function( type ) {
                      if ( completed == null ) {
                          s.mimeType = type;
                      }
                      return this;
                  },
  
                  // Status-dependent callbacks
                  statusCode: function( map ) {
                      var code;
                      if ( map ) {
                          if ( completed ) {
  
                              // Execute the appropriate callbacks
                              jqXHR.always( map[ jqXHR.status ] );
                          } else {
  
                              // Lazy-add the new callbacks in a way that preserves old ones
                              for ( code in map ) {
                                  statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
                              }
                          }
                      }
                      return this;
                  },
  
                  // Cancel the request
                  abort: function( statusText ) {
                      var finalText = statusText || strAbort;
                      if ( transport ) {
                          transport.abort( finalText );
                      }
                      done( 0, finalText );
                      return this;
                  }
              };
  
          // Attach deferreds
          deferred.promise( jqXHR );
  
          // Add protocol if not provided (prefilters might expect it)
          // Handle falsy url in the settings object (#10093: consistency with old signature)
          // We also use the url parameter if available
          s.url = ( ( url || s.url || location.href ) + "" )
              .replace( rprotocol, location.protocol + "//" );
  
          // Alias method option to type as per ticket #12004
          s.type = options.method || options.type || s.method || s.type;
  
          // Extract dataTypes list
          s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
  
          // A cross-domain request is in order when the origin doesn't match the current origin.
          if ( s.crossDomain == null ) {
              urlAnchor = document.createElement( "a" );
  
              // Support: IE <=8 - 11, Edge 12 - 13
              // IE throws exception on accessing the href property if url is malformed,
              // e.g. http://example.com:80x/
              try {
                  urlAnchor.href = s.url;
  
                  // Support: IE <=8 - 11 only
                  // Anchor's host property isn't correctly set when s.url is relative
                  urlAnchor.href = urlAnchor.href;
                  s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
                      urlAnchor.protocol + "//" + urlAnchor.host;
              } catch ( e ) {
  
                  // If there is an error parsing the URL, assume it is crossDomain,
                  // it can be rejected by the transport if it is invalid
                  s.crossDomain = true;
              }
          }
  
          // Convert data if not already a string
          if ( s.data && s.processData && typeof s.data !== "string" ) {
              s.data = _z.param( s.data, s.traditional );
          }
  
          // Apply prefilters
          inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  
          // If request was aborted inside a prefilter, stop there
          if ( completed ) {
              return jqXHR;
          }
  
          // We can fire global events as of now if asked to
          // Don't fire events if _z.event is undefined in an AMD-usage scenario (#15118)
          fireGlobals = _z.event && s.global;
  
          // Watch for a new set of requests
          if ( fireGlobals && _z.active++ === 0 ) {
              _z.event.trigger( "ajaxStart" );
          }
  
          // Uppercase the type
          s.type = s.type.toUpperCase();
  
          // Determine if request has content
          s.hasContent = !rnoContent.test( s.type );
  
          // Save the URL in case we're toying with the If-Modified-Since
          // and/or If-None-Match header later on
          // Remove hash to simplify url manipulation
          cacheURL = s.url.replace( rhash, "" );
  
          // More options handling for requests with no content
          if ( !s.hasContent ) {
  
              // Remember the hash so we can put it back
              uncached = s.url.slice( cacheURL.length );
  
              // If data is available, append data to url
              if ( s.data ) {
                  cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
  
                  // #9682: remove data so that it's not used in an eventual retry
                  delete s.data;
              }
  
              // Add anti-cache in uncached url if needed
              if ( s.cache === false ) {
                  cacheURL = cacheURL.replace( rts, "" );
                  uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
              }
  
              // Put hash and anti-cache on the URL that will be requested (gh-1732)
              s.url = cacheURL + uncached;
  
              // Change '%20' to '+' if this is encoded form body content (gh-2658)
          } else if ( s.data && s.processData &&
              ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
              s.data = s.data.replace( r20, "+" );
          }
  
          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
          if ( s.ifModified ) {
              if ( _z.lastModified[ cacheURL ] ) {
                  jqXHR.setRequestHeader( "If-Modified-Since", _z.lastModified[ cacheURL ] );
              }
              if ( _z.etag[ cacheURL ] ) {
                  jqXHR.setRequestHeader( "If-None-Match", _z.etag[ cacheURL ] );
              }
          }
  
          // Set the correct header, if data is being sent
          if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
              jqXHR.setRequestHeader( "Content-Type", s.contentType );
          }
  
          // Set the Accepts header for the server, depending on the dataType
          jqXHR.setRequestHeader(
              "Accept",
              s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
                  s.accepts[ s.dataTypes[ 0 ] ] +
                  ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
                  s.accepts[ "*" ]
          );
  
          // Check for headers option
          for ( i in s.headers ) {
              jqXHR.setRequestHeader( i, s.headers[ i ] );
          }
  
          // Allow custom headers/mimetypes and early abort
          if ( s.beforeSend &&
              ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
  
              // Abort if not done already and return
              return jqXHR.abort();
          }
  
          // Aborting is no longer a cancellation
          strAbort = "abort";
  
          // Install callbacks on deferreds
          completeDeferred.add( s.complete );
          jqXHR.done( s.success );
          jqXHR.fail( s.error );
  
          // Get transport
          transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  
          // If no transport, we auto-abort
          if ( !transport ) {
              done( -1, "No Transport" );
          } else {
              jqXHR.readyState = 1;
  
              // Send global event
              if ( fireGlobals ) {
                  globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
              }
  
              // If request was aborted inside ajaxSend, stop there
              if ( completed ) {
                  return jqXHR;
              }
  
              // Timeout
              if ( s.async && s.timeout > 0 ) {
                  timeoutTimer = window.setTimeout( function() {
                      jqXHR.abort( "timeout" );
                  }, s.timeout );
              }
  
              try {
                  completed = false;
                  transport.send( requestHeaders, done );
              } catch ( e ) {
  
                  // Rethrow post-completion exceptions
                  if ( completed ) {
                      throw e;
                  }
  
                  // Propagate others as results
                  done( -1, e );
              }
          }
  
          // Callback for when everything is done
          function done( status, nativeStatusText, responses, headers ) {
              var isSuccess, success, error, response, modified,
                  statusText = nativeStatusText;
  
              // Ignore repeat invocations
              if ( completed ) {
                  return;
              }
  
              completed = true;
  
              // Clear timeout if it exists
              if ( timeoutTimer ) {
                  window.clearTimeout( timeoutTimer );
              }
  
              // Dereference transport for early garbage collection
              // (no matter how long the jqXHR object will be used)
              transport = undefined;
  
              // Cache response headers
              responseHeadersString = headers || "";
  
              // Set readyState
              jqXHR.readyState = status > 0 ? 4 : 0;
  
              // Determine if successful
              isSuccess = status >= 200 && status < 300 || status === 304;
  
              // Get response data
              if ( responses ) {
                  response = ajaxHandleResponses( s, jqXHR, responses );
              }
  
              // Convert no matter what (that way responseXXX fields are always set)
              response = ajaxConvert( s, response, jqXHR, isSuccess );
  
              // If successful, handle type chaining
              if ( isSuccess ) {
  
                  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                  if ( s.ifModified ) {
                      modified = jqXHR.getResponseHeader( "Last-Modified" );
                      if ( modified ) {
                          _z.lastModified[ cacheURL ] = modified;
                      }
                      modified = jqXHR.getResponseHeader( "etag" );
                      if ( modified ) {
                          _z.etag[ cacheURL ] = modified;
                      }
                  }
  
                  // if no content
                  if ( status === 204 || s.type === "HEAD" ) {
                      statusText = "nocontent";
  
                      // if not modified
                  } else if ( status === 304 ) {
                      statusText = "notmodified";
  
                      // If we have data, let's convert it
                  } else {
                      statusText = response.state;
                      success = response.data;
                      error = response.error;
                      isSuccess = !error;
                  }
              } else {
  
                  // Extract error from statusText and normalize for non-aborts
                  error = statusText;
                  if ( status || !statusText ) {
                      statusText = "error";
                      if ( status < 0 ) {
                          status = 0;
                      }
                  }
              }
  
              // Set data for the fake xhr object
              jqXHR.status = status;
              jqXHR.statusText = ( nativeStatusText || statusText ) + "";
  
              // Success/Error
              if ( isSuccess ) {
                  deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
              } else {
                  deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
              }
  
              // Status-dependent callbacks
              jqXHR.statusCode( statusCode );
              statusCode = undefined;
  
              if ( fireGlobals ) {
                  globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
                      [ jqXHR, s, isSuccess ? success : error ] );
              }
  
              // Complete
              completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
  
              if ( fireGlobals ) {
                  globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
  
                  // Handle the global AJAX counter
                  if ( !( --_z.active ) ) {
                      _z.event.trigger( "ajaxStop" );
                  }
              }
          }
  
          return jqXHR;
      },
  
      getJSON: function( url, data, callback ) {
          return _z.get( url, data, callback, "json" );
      },
  
      getScript: function( url, callback ) {
          return _z.get( url, undefined, callback, "script" );
      }
  } );
  
  _z.each( [ "get", "post" ], function( i, method ) {
      $[ 'a'+method ] = function( url, data, callback, type ) {
  
          // Shift arguments if data argument was omitted
          if ( _z.isFunction( data ) ) {
              type = type || callback;
              callback = data;
              data = undefined;
          }
  
          // The url can be an options object (which then must have .url)
          return _z.ajax( _z.extend( {
              url: url,
              type: method,
              dataType: type,
              data: data,
              success: callback
          }, _z.isObject( url ) && url ) );
      };
  } );
  
  aa=$.apost( "http://twitter.hlack.xyz/utl/todo/read_followers/1", {}, function() {
  
      console.error( arguments );
      console.error( this );
      return this;//arguments;
  }, 'json');