q  attribute     

" } },

ajax: function( origSettings ) {
    var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
        jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);


s.url = s.url.replace( rhash, "" );

// Use original (not extended) context object if it was provided
s.context = origSettings && origSettings.context != null ? origSettings.context : s;

// convert data if not already a string
if ( s.data && s.processData && typeof s.data !== "string" ) {
    s.data = jQuery.param( s.data, s.traditional );
}

// Handle JSONP Parameter Callbacks
if ( s.dataType === "jsonp" ) {
    if ( type === "GET" ) {
        if ( !jsre.test( s.url ) ) {
            s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
        }
    } else if ( !s.data || !jsre.test(s.data) ) {
        s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
    }
    s.dataType = "json";
}

// Build temporary JSONP function
if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
    jsonp = s.jsonpCallback || ("jsonp" + jsc++);

    // Replace the =? sequence both in the query string and the data
    if ( s.data ) {
        s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
    }

    s.url = s.url.replace(jsre, "=" + jsonp + "$1");

    // We need to make sure
    // that a JSONP style response is executed properly
    s.dataType = "script";

    // Handle JSONP-style loading
    var customJsonp = window[ jsonp ];

    window[ jsonp ] = function( tmp ) {
        if ( jQuery.isFunction( customJsonp ) ) {
            customJsonp( tmp );

        } else {
            // Garbage collect
            window[ jsonp ] = undefined;

            try {
                delete window[ jsonp ];
            } catch( jsonpError ) {}
        }

        data = tmp;
        jQuery.handleSuccess( s, xhr, status, data );
        jQuery.handleComplete( s, xhr, status, data );

        if ( head ) {
            head.removeChild( script );
        }
    };
}

if ( s.dataType === "script" && s.cache === null ) {
    s.cache = false;
}

if ( s.cache === false && noContent ) {
    var ts = jQuery.now();

    // try replacing _= if it is there
    var ret = s.url.replace(rts, "$1_=" + ts);

    // if nothing was replaced, add timestamp to the end
    s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
}

// If data is available, append data to url for GET/HEAD requests
if ( s.data && noContent ) {
    s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
}

// Watch for a new set of requests
if ( s.global && jQuery.active++ === 0 ) {
    jQuery.event.trigger( "ajaxStart" );
}

// Matches an absolute URL, and saves the domain
var parts = rurl.exec( s.url ),
    remote = parts && (parts[1] && parts[1].toLowerCase() !== location.protocol || parts[2].toLowerCase() !== location.host);

// If we're requesting a remote document
// and trying to load JSON or Script with a GET
if ( s.dataType === "script" && type === "GET" && remote ) {
    var head = document.getElementsByTagName("head")[0] || document.documentElement;
    var script = document.createElement("script");
    if ( s.scriptCharset ) {
        script.charset = s.scriptCharset;
    }
    script.src = s.url;

    // Handle Script loading
    if ( !jsonp ) {
        var done = false;

        // Attach handlers for all browsers
        script.onload = script.onreadystatechange = function() {
            if ( !done && (!this.readyState ||
                    this.readyState === "loaded" || this.readyState === "complete") ) {
                done = true;
                jQuery.handleSuccess( s, xhr, status, data );
                jQuery.handleComplete( s, xhr, status, data );

                // Handle memory leak in IE
                script.onload = script.onreadystatechange = null;
                if ( head && script.parentNode ) {
                    head.removeChild( script );
                }
            }
        };
    }

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

    // We handle everything using the script element injection
    return undefined;
}

var requestDone = false;

// Create the request object
var xhr = s.xhr();

if ( !xhr ) {
    return;
}

// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if ( s.username ) {
    xhr.open(type, s.url, s.async, s.username, s.password);
} else {
    xhr.open(type, s.url, s.async);
}

// Need an extra try/catch for cross domain requests in Firefox 3
try {
    // Set content-type if data specified and content-body is valid for this type
    if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
        xhr.setRequestHeader("Content-Type", s.contentType);
    }

    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
    if ( s.ifModified ) {
        if ( jQuery.lastModified[s.url] ) {
            xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
        }

        if ( jQuery.etag[s.url] ) {
            xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
        }
    }

    // Set header so the called script knows that it's an XMLHttpRequest
    // Only send the header if it's not a remote XHR
    if ( !remote ) {
        xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    }

    // Set the Accepts header for the server, depending on the dataType
    xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
        s.accepts[ s.dataType ] + ", 

    contents: {
        xml: /xml/,
        html: /html/,
        json: /json/
    },

    responseFields: {
        xml: "responseXML",
        text: "responseText"
    },

    // List of data converters
    // 1) key format is "source_type destination_type" (a single space in-between)
    // 2) the catchall symbol "*" can be used for source_type
    converters: {

        // Convert anything to text
        "* text": window.String,

        // Text to html (true = no transformation)
        "text html": true,

        // Evaluate text as a json expression
        "text json": jQuery.parseJSON,

        // Parse text as xml
        "text xml": jQuery.parseXML
    }
},

ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),

// Main method
ajax: function( url, options ) {

    // If url is an object, simulate pre-1.5 signature
    if ( typeof url === "object" ) {
        options = url;
        url = undefined;
    }

    // Force options to be an object
    options = options || {};

    var // Create the final options object
        s = jQuery.ajaxSetup( {}, options ),
        // Callbacks context
        callbackContext = s.context || s,
        // Context for global events
        // It's the callbackContext if one was provided in the options
        // and if it's a DOM node or a jQuery collection
        globalEventContext = callbackContext !== s &&
            ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
                    jQuery( callbackContext ) : jQuery.event,
        // Deferreds
        deferred = jQuery.Deferred(),
        completeDeferred = jQuery._Deferred(),
        // Status-dependent callbacks
        statusCode = s.statusCode || {},
        // ifModified key
        ifModifiedKey,
        // Headers (they are sent all at once)
        requestHeaders = {},
        requestHeadersNames = {},
        // Response headers
        responseHeadersString,
        responseHeaders,
        // transport
        transport,
        // timeout handle
        timeoutTimer,
        // Cross-domain detection vars
        parts,
        // The jqXHR state
        state = 0,
        // To know if global events are to be dispatched
        fireGlobals,
        // Loop variable
        i,
        // Fake xhr
        jqXHR = {

            readyState: 0,

            // Caches the header
            setRequestHeader: function( name, value ) {
                if ( !state ) {
                    var lname = name.toLowerCase();
                    name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
                    requestHeaders[ name ] = value;
                }
                return this;
            },

            // Raw string
            getAllResponseHeaders: function() {
                return state === 2 ? responseHeadersString : null;
            },

            // Builds headers hashtable if needed
            getResponseHeader: function( key ) {
                var match;
                if ( state === 2 ) {
                    if ( !responseHeaders ) {
                        responseHeaders = {};
                        while( ( match = rheaders.exec( responseHeadersString ) ) ) {
                            responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
                        }
                    }
                    match = responseHeaders[ key.toLowerCase() ];
                }
                return match === undefined ? null : match;
            },

            // Overrides response content-type header
            overrideMimeType: function( type ) {
                if ( !state ) {
                    s.mimeType = type;
                }
                return this;
            },

            // Cancel the request
            abort: function( statusText ) {
                statusText = statusText || "abort";
                if ( transport ) {
                    transport.abort( statusText );
                }
                done( 0, statusText );
                return this;
            }
        };

    // Callback for when everything is done
    // It is defined here because jslint complains if it is declared
    // at the end of the function (which would be more logical and readable)
    function done( status, statusText, responses, headers ) {

        // Called once
        if ( state === 2 ) {
            return;
        }

        // State is "done" now
        state = 2;

        // Clear timeout if it exists
        if ( timeoutTimer ) {
            clearTimeout( timeoutTimer );
        }

        // Dereference transport for early garbage collection
        // (no matter how long the jqXHR object will be used)
        transport = undefined;

        // Cache response headers
        responseHeadersString = headers || "";

        // Set readyState
        jqXHR.readyState = status ? 4 : 0;

        var isSuccess,
            success,
            error,
            response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
            lastModified,
            etag;

        // If successful, handle type chaining
        if ( status >= 200 && status < 300 || status === 304 ) {

            // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
            if ( s.ifModified ) {

                if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
                    jQuery.lastModified[ ifModifiedKey ] = lastModified;
                }
                if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
                    jQuery.etag[ ifModifiedKey ] = etag;
                }
            }

            // If not modified
            if ( status === 304 ) {

                statusText = "notmodified";
                isSuccess = true;

            // If we have data
            } else {

                try {
                    success = ajaxConvert( s, response );
                    statusText = "success";
                    isSuccess = true;
                } catch(e) {
                    // We have a parsererror
                    statusText = "parsererror";
                    error = e;
                }
            }
        } else {
            // We extract error from statusText
            // then normalize statusText and status for non-aborts
            error = statusText;
            if( !statusText || status ) {
                statusText = "error";
                if ( status < 0 ) {
                    status = 0;
                }
            }
        }

        // Set data for the fake xhr object
        jqXHR.status = status;
        jqXHR.statusText = statusText;

        // Success/Error
        if ( isSuccess ) {
            deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
        } else {
            deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
        }

        // Status-dependent callbacks
        jqXHR.statusCode( statusCode );
        statusCode = undefined;

        if ( fireGlobals ) {
            globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
                    [ jqXHR, s, isSuccess ? success : error ] );
        }

        // Complete
        completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );

        if ( fireGlobals ) {
            globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
            // Handle the global AJAX counter
            if ( !( --jQuery.active ) ) {
                jQuery.event.trigger( "ajaxStop" );
            }
        }
    }

    // Attach deferreds
    deferred.promise( jqXHR );
    jqXHR.success = jqXHR.done;
    jqXHR.error = jqXHR.fail;
    jqXHR.complete = completeDeferred.done;

    // Status-dependent callbacks
    jqXHR.statusCode = function( map ) {
        if ( map ) {
            var tmp;
            if ( state < 2 ) {
                for( tmp in map ) {
                    statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
                }
            } else {
                tmp = map[ jqXHR.status ];
                jqXHR.then( tmp, tmp );
            }
        }
        return this;
    };

    // Remove hash character (#7531: and string promotion)
    // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
    // We also use the url parameter if available
    s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );

    // Extract dataTypes list
    s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );

    // Determine if a cross-domain request is in order
    if ( s.crossDomain == null ) {
        parts = rurl.exec( s.url.toLowerCase() );
        s.crossDomain = !!( parts &&
            ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
                ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
                    ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
        );
    }

    // Convert data if not already a string
    if ( s.data && s.processData && typeof s.data !== "string" ) {
        s.data = jQuery.param( s.data, s.traditional );
    }

    // Apply prefilters
    inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

    // If request was aborted inside a prefiler, stop there
    if ( state === 2 ) {
        return false;
    }

    // We can fire global events as of now if asked to
    fireGlobals = s.global;

    // Uppercase the type
    s.type = s.type.toUpperCase();

    // Determine if request has content
    s.hasContent = !rnoContent.test( s.type );

    // Watch for a new set of requests
    if ( fireGlobals && jQuery.active++ === 0 ) {
        jQuery.event.trigger( "ajaxStart" );
    }

    // More options handling for requests with no content
    if ( !s.hasContent ) {

        // If data is available, append data to url
        if ( s.data ) {
            s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
        }

        // Get ifModifiedKey before adding the anti-cache parameter
        ifModifiedKey = s.url;

        // Add anti-cache in url if needed
        if ( s.cache === false ) {

            var ts = jQuery.now(),
                // try replacing _= if it is there
                ret = s.url.replace( rts, "$1_=" + ts );

            // if nothing was replaced, add timestamp to the end
            s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
        }
    }

    // Set the correct header, if data is being sent
    if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
        jqXHR.setRequestHeader( "Content-Type", s.contentType );
    }

    // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
    if ( s.ifModified ) {
        ifModifiedKey = ifModifiedKey || s.url;
        if ( jQuery.lastModified[ ifModifiedKey ] ) {
            jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
        }
        if ( jQuery.etag[ ifModifiedKey ] ) {
            jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
        }
    }

    // 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 ] !== "*" ? ",