text: /** vim: et:ts=4:sw=4:sts=4
   * @license RequireJS 0.26.0 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
   * Available via the MIT or new BSD license.
   * see: http://github.com/jrburke/requirejs for details
   */
  /*jslint strict: false, plusplus: false */
  /*global window: false, navigator: false, document: false, importScripts: false,
    jQuery: false, clearInterval: false, setInterval: false, self: false,
    setTimeout: false, opera: false */
  
  var requirejs, require, define;
  (function () {
      //Change this version number for each release.
      var version = "0.26.0",
          commentRegExp = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
          cjsRequireRegExp = /require\(\s*["']([^'"\s]+)["']\s*\)/g,
          currDirRegExp = /^\.\//,
          jsSuffixRegExp = /\.js$/,
          ostring = Object.prototype.toString,
          ap = Array.prototype,
          aps = ap.slice,
          apsp = ap.splice,
          isBrowser = !!(typeof window !== "undefined" && navigator && document),
          isWebWorker = !isBrowser && typeof importScripts !== "undefined",
          //PS3 indicates loaded and complete, but need to wait for complete
          //specifically. Sequence is "loading", "loaded", execution,
          // then "complete". The UA check is unfortunate, but not sure how
          //to feature test w/o causing perf issues.
          readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                        /^complete$/ : /^(complete|loaded)$/,
          defContextName = "_",
          //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
          isOpera = typeof opera !== "undefined" && opera.toString() === "[object Opera]",
          reqWaitIdPrefix = "_r@@",
          empty = {},
          contexts = {},
          globalDefQueue = [],
          interactiveScript = null,
          isDone = false,
          checkLoadedDepth = 0,
          useInteractive = false,
          req, cfg = {}, currentlyAddingScript, s, head, baseElement, scripts, script,
          src, subPath, mainScript, dataMain, i, scrollIntervalId, setReadyState, ctx,
          jQueryCheck, checkLoadedTimeoutId;
  
      function isFunction(it) {
          return ostring.call(it) === "[object Function]";
      }
  
      function isArray(it) {
          return ostring.call(it) === "[object Array]";
      }
  
      /**
       * Simple function to mix in properties from source into target,
       * but only if target does not already have a property of the same name.
       * This is not robust in IE for transferring methods that match
       * Object.prototype names, but the uses of mixin here seem unlikely to
       * trigger a problem related to that.
       */
      function mixin(target, source, force) {
          for (var prop in source) {
              if (!(prop in empty) && (!(prop in target) || force)) {
                  target[prop] = source[prop];
              }
          }
          return req;
      }
  
      /**
       * Constructs an error with a pointer to an URL with more information.
       * @param {String} id the error ID that maps to an ID on a web page.
       * @param {String} message human readable error.
       * @param {Error} [err] the original error, if there is one.
       *
       * @returns {Error}
       */
      function makeError(id, msg, err) {
          var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
          if (err) {
              e.originalError = err;
          }
          return e;
      }
  
      /**
       * Used to set up package paths from a packagePaths or packages config object.
       * @param {Object} pkgs the object to store the new package config
       * @param {Array} currentPackages an array of packages to configure
       * @param {String} [dir] a prefix dir to use.
       */
      function configurePackageDir(pkgs, currentPackages, dir) {
          var i, location, pkgObj;
  
          for (i = 0; (pkgObj = currentPackages[i]); i++) {
              pkgObj = typeof pkgObj === "string" ? { name: pkgObj } : pkgObj;
              location = pkgObj.location;
  
              //Add dir to the path, but avoid paths that start with a slash
              //or have a colon (indicates a protocol)
              if (dir && (!location || (location.indexOf("/") !== 0 && location.indexOf(":") === -1))) {
                  location = dir + "/" + (location || pkgObj.name);
              }
  
              //Create a brand new object on pkgs, since currentPackages can
              //be passed in again, and config.pkgs is the internal transformed
              //state for all package configs.
              pkgs[pkgObj.name] = {
                  name: pkgObj.name,
                  location: location || pkgObj.name,
                  //Remove leading dot in main, so main paths are normalized,
                  //and remove any trailing .js, since different package
                  //envs have different conventions: some use a module name,
                  //some use a file name.
                  main: (pkgObj.main || "main")
                        .replace(currDirRegExp, '')
                        .replace(jsSuffixRegExp, '')
              };
          }
      }
  
      /**
       * jQuery 1.4.3-1.5.x use a readyWait/ready() pairing to hold DOM
       * ready callbacks, but jQuery 1.6 supports a holdReady() API instead.
       * At some point remove the readyWait/ready() support and just stick
       * with using holdReady.
       */
      function jQueryHoldReady($, shouldHold) {
          if ($.holdReady) {
              $.holdReady(shouldHold);
          } else if (shouldHold) {
              $.readyWait += 1;
          } else {
              $.ready(true);
          }
      }
  
      if (typeof define !== "undefined") {
          //If a define is already in play via another AMD loader,
          //do not overwrite.
          return;
      }
  
      if (typeof requirejs !== "undefined") {
          if (isFunction(requirejs)) {
              //Do not overwrite and existing requirejs instance.
              return;
          } else {
              cfg = requirejs;
              requirejs = undefined;
          }
      }
  
      //Allow for a require config object
      if (typeof require !== "undefined" && !isFunction(require)) {
          //assume it is a config object.
          cfg = require;
          require = undefined;
      }
  
      /**
       * Creates a new context for use in require and define calls.
       * Handle most of the heavy lifting. Do not want to use an object
       * with prototype here to avoid using "this" in require, in case it
       * needs to be used in more super secure envs that do not want this.
       * Also there should not be that many contexts in the page. Usually just
       * one for the default context, but could be extra for multiversion cases
       * or if a package needs a special context for a dependency that conflicts
       * with the standard context.
       */
      function newContext(contextName) {
          var context, resume,
              config = {
                  waitSeconds: 7,
                  baseUrl: s.baseUrl || "./",
                  paths: {},
                  pkgs: {},
                  catchError: {}
              },
              defQueue = [],
              specified = {
                  "require": true,
                  "exports": true,
                  "module": true
              },
              urlMap = {},
              defined = {},
              loaded = {},
              waiting = {},
              waitAry = [],
              waitIdCounter = 0,
              managerCallbacks = {},
              plugins = {},
              pluginsQueue = {},
              resumeDepth = 0,
              normalizedWaiting = {};
  
          /**
           * Trims the . and .. from an array of path segments.
           * It will keep a leading path segment if a .. will become
           * the first path segment, to help with module name lookups,
           * which act like paths, but can be remapped. But the end result,
           * all paths that use this function should look normalized.
           * NOTE: this method MODIFIES the input array.
           * @param {Array} ary the array of path segments.
           */
          function trimDots(ary) {
              var i, part;
              for (i = 0; (part = ary[i]); i++) {
                  if (part === ".") {
                      ary.splice(i, 1);
                      i -= 1;
                  } else if (part === "..") {
                      if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
                          //End of the line. Keep at least one non-dot
                          //path segment at the front so it can be mapped
                          //correctly to disk. Otherwise, there is likely
                          //no path mapping for a path starting with '..'.
                          //This can still fail, but catches the most reasonable
                          //uses of ..
                          break;
                      } else if (i > 0) {
                          ary.splice(i - 1, 2);
                          i -= 2;
                      }
                  }
              }
          }
  
          /**
           * Given a relative module name, like ./something, normalize it to
           * a real name that can be mapped to a path.
           * @param {String} name the relative name
           * @param {String} baseName a real name that the name arg is relative
           * to.
           * @returns {String} normalized name
           */
          function normalize(name, baseName) {
              var pkgName, pkgConfig;
  
              //Adjust any relative paths.
              if (name && name.charAt(0) === ".") {
                  //If have a base name, try to normalize against it,
                  //otherwise, assume it is a top-level require that will
                  //be relative to baseUrl in the end.
                  if (baseName) {
                      if (config.pkgs[baseName]) {
                          //If the baseName is a package name, then just treat it as one
                          //name to concat the name with.
                          baseName = [baseName];
                      } else {
                          //Convert baseName to array, and lop off the last part,
                          //so that . matches that "directory" and not name of the baseName's
                          //module. For instance, baseName of "one/two/three", maps to
                          //"one/two/three.js", but we want the directory, "one/two" for
                          //this normalization.
                          baseName = baseName.split("/");
                          baseName = baseName.slice(0, baseName.length - 1);
                      }
  
                      name = baseName.concat(name.split("/"));
                      trimDots(name);
  
                      //Some use of packages may use a . path to reference the
                      //"main" module name, so normalize for that.
                      pkgConfig = config.pkgs[(pkgName = name[0])];
                      name = name.join("/");
                      if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
                          name = pkgName;
                      }
                  }
              }
              return name;
          }
  
          /**
           * Creates a module mapping that includes plugin prefix, module
           * name, and path. If parentModuleMap is provided it will
           * also normalize the name via require.normalize()
           *
           * @param {String} name the module name
           * @param {String} [parentModuleMap] parent module map
           * for the module name, used to resolve relative names.
           *
           * @returns {Object}
           */
          function makeModuleMap(name, parentModuleMap) {
              var index = name ? name.indexOf("!") : -1,
                  prefix = null,
                  parentName = parentModuleMap ? parentModuleMap.name : null,
                  originalName = name,
                  normalizedName, url, pluginModule;
  
              if (index !== -1) {
                  prefix = name.substring(0, index);
                  name = name.substring(index + 1, name.length);
              }
  
              if (prefix) {
                  prefix = normalize(prefix, parentName);
              }
  
              //Account for relative paths if there is a base name.
              if (name) {
                  if (prefix) {
                      pluginModule = defined[prefix];
                      if (pluginModule) {
                          //Plugin is loaded, use its normalize method, otherwise,
                          //normalize name as usual.
                          if (pluginModule.normalize) {
                              normalizedName = pluginModule.normalize(name, function (name) {
                                  return normalize(name, parentName);
                              });
                          } else {
                              normalizedName = normalize(name, parentName);
                          }
                      } else {
                          //Plugin is not loaded yet, so do not normalize
                          //the name, wait for plugin to load to see if
                          //it has a normalize method. To avoid possible
                          //ambiguity with relative names loaded from another
                          //plugin, use the parent's name as part of this name.
                          normalizedName = '__$p' + parentName + '@' + (name || '');
                      }
                  } else {
                      normalizedName = normalize(name, parentName);
                  }
  
                  url = urlMap[normalizedName];
                  if (!url) {
                      //Calculate url for the module, if it has a name.
                      if (req.toModuleUrl) {
                          //Special logic required for a particular engine,
                          //like Node.
                          url = req.toModuleUrl(context, normalizedName, parentModuleMap);
                      } else {
                          url = context.nameToUrl(normalizedName, null, parentModuleMap);
                      }
  
                      //Store the URL mapping for later.
                      urlMap[normalizedName] = url;
                  }
              }
  
              return {
                  prefix: prefix,
                  name: normalizedName,
                  parentMap: parentModuleMap,
                  url: url,
                  originalName: originalName,
                  fullName: prefix ? prefix + "!" + (normalizedName || '') : normalizedName
              };
          }
  
          /**
           * Determine if priority loading is done. If so clear the priorityWait
           */
          function isPriorityDone() {
              var priorityDone = true,
                  priorityWait = config.priorityWait,
                  priorityName, i;
              if (priorityWait) {
                  for (i = 0; (priorityName = priorityWait[i]); i++) {
                      if (!loaded[priorityName]) {
                          priorityDone = false;
                          break;
                      }
                  }
                  if (priorityDone) {
                      delete config.priorityWait;
                  }
              }
              return priorityDone;
          }
  
          /**
           * Helper function that creates a setExports function for a "module"
           * CommonJS dependency. Do this here to avoid creating a closure that
           * is part of a loop.
           */
          function makeSetExports(moduleObj) {
              return function (exports) {
                  moduleObj.exports = exports;
              };
          }
  
          function makeContextModuleFunc(func, relModuleMap, enableBuildCallback) {
              return function () {
                  //A version of a require function that passes a moduleName
                  //value for items that may need to
                  //look up paths relative to the moduleName
                  var args = [].concat(aps.call(arguments, 0)), lastArg;
                  if (enableBuildCallback &&
                      isFunction((lastArg = args[args.length - 1]))) {
                      lastArg.__requireJsBuild = true;
                  }
                  args.push(relModuleMap);
                  return func.apply(null, args);
              };
          }
  
          /**
           * Helper function that creates a require function object to give to
           * modules that ask for it as a dependency. It needs to be specific
           * per module because of the implication of path mappings that may
           * need to be relative to the module name.
           */
          function makeRequire(relModuleMap, enableBuildCallback) {
              var modRequire = makeContextModuleFunc(context.require, relModuleMap, enableBuildCallback);
  
              mixin(modRequire, {
                  nameToUrl: makeContextModuleFunc(context.nameToUrl, relModuleMap),
                  toUrl: makeContextModuleFunc(context.toUrl, relModuleMap),
                  defined: makeContextModuleFunc(context.requireDefined, relModuleMap),
                  specified: makeContextModuleFunc(context.requireSpecified, relModuleMap),
                  ready: req.ready,
                  isBrowser: req.isBrowser
              });
              //Something used by node.
              if (req.paths) {
                  modRequire.paths = req.paths;
              }
              return modRequire;
          }
  
          /**
           * Used to update the normalized name for plugin-based dependencies
           * after a plugin loads, since it can have its own normalization structure.
           * @param {String} pluginName the normalized plugin module name.
           */
          function updateNormalizedNames(pluginName) {
  
              var oldFullName, oldModuleMap, moduleMap, fullName, callbacks,
                  i, j, k, depArray, existingCallbacks,
                  maps = normalizedWaiting[pluginName];
  
              if (maps) {
                  for (i = 0; (oldModuleMap = maps[i]); i++) {
                      oldFullName = oldModuleMap.fullName;
                      moduleMap = makeModuleMap(oldModuleMap.originalName, oldModuleMap.parentMap);
                      fullName = moduleMap.fullName;
                      //Callbacks could be undefined if the same plugin!name was
                      //required twice in a row, so use empty array in that case.
                      callbacks = managerCallbacks[oldFullName] || [];
                      existingCallbacks = managerCallbacks[fullName];
  
                      if (fullName !== oldFullName) {
                          //Update the specified object, but only if it is already
                          //in there. In sync environments, it may not be yet.
                          if (oldFullName in specified) {
                              delete specified[oldFullName];
                              specified[fullName] = true;
                          }
  
                          //Update managerCallbacks to use the correct normalized name.
                          //If there are already callbacks for the normalized name,
                          //just add to them.
                          if (existingCallbacks) {
                              managerCallbacks[fullName] = existingCallbacks.concat(callbacks);
                          } else {
                              managerCallbacks[fullName] = callbacks;
                          }
                          delete managerCallbacks[oldFullName];
  
                          //In each manager callback, update the normalized name in the depArray.
                          for (j = 0; j < callbacks.length; j++) {
                              depArray = callbacks[j].depArray;
                              for (k = 0; k < depArray.length; k++) {
                                  if (depArray[k] === oldFullName) {
                                      depArray[k] = fullName;
                                  }
                              }
                          }
                      }
                  }
              }
  
              delete normalizedWaiting[pluginName];
          }
  
          /*
           * Queues a dependency for checking after the loader is out of a
           * "paused" state, for example while a script file is being loaded
           * in the browser, where it may have many modules defined in it.
           *
           * depName will be fully qualified, no relative . or .. path.
           */
          function queueDependency(dep) {
              //Make sure to load any plugin and associate the dependency
              //with that plugin.
              var prefix = dep.prefix,
                  fullName = dep.fullName;
  
              //Do not bother if the depName is already in transit
              if (specified[fullName] || fullName in defined) {
                  return;
              }
  
              if (prefix && !plugins[prefix]) {
                  //Queue up loading of the dependency, track it
                  //via context.plugins. Mark it as a plugin so
                  //that the build system will know to treat it
                  //special.
                  plugins[prefix] = undefined;
  
                  //Remember this dep that needs to have normaliztion done
                  //after the plugin loads.
                  (normalizedWaiting[prefix] || (normalizedWaiting[prefix] = []))
                      .push(dep);
  
                  //Register an action to do once the plugin loads, to update
                  //all managerCallbacks to use a properly normalized module
                  //name.
                  (managerCallbacks[prefix] ||
                  (managerCallbacks[prefix] = [])).push({
                      onDep: function (name, value) {
                          if (name === prefix) {
                              updateNormalizedNames(prefix);
                          }
                      }
                  });
  
                  queueDependency(makeModuleMap(prefix));
              }
  
              context.paused.push(dep);
          }
  
          function execManager(manager) {
              var i, ret, waitingCallbacks, err, errFile,
                  cb = manager.callback,
                  fullName = manager.fullName,
                  args = [],
                  ary = manager.depArray;
  
              //Call the callback to define the module, if necessary.
              if (cb && isFunction(cb)) {
                  //Pull out the defined dependencies and pass the ordered
                  //values to the callback.
                  if (ary) {
                      for (i = 0; i < ary.length; i++) {
                          args.push(manager.deps[ary[i]]);
                      }
                  }
  
                  if (config.catchError.define) {
                      try {
                          ret = req.execCb(fullName, manager.callback, args, defined[fullName]);
                      } catch (e) {
                          err = e;
                      }
                  } else {
                      ret = req.execCb(fullName, manager.callback, args, defined[fullName]);
                  }
  
                  if (fullName) {
                      //If setting exports via "module" is in play,
                      //favor that over return value and exports. After that,
                      //favor a non-undefined return value over exports use.
                      if (manager.cjsModule && manager.cjsModule.exports !== undefined) {
                          ret = defined[fullName] = manager.cjsModule.exports;
                      } else if (ret === undefined && manager.usingExports) {
                          //exports already set the defined value.
                          ret = defined[fullName];
                      } else {
                          //Use the return value from the function.
                          defined[fullName] = ret;
                      }
                  }
              } else if (fullName) {
                  //May just be an object definition for the module. Only
                  //worry about defining if have a module name.
                  ret = defined[fullName] = cb;
              }
  
              //Clean up waiting. Do this before error calls, and before
              //calling back waitingCallbacks, so that bookkeeping is correct
              //in the event of an error and error is reported in correct order,
              //since the waitingCallbacks will likely have errors if the
              //onError function does not throw.
              if (waiting[manager.waitId]) {
                  delete waiting[manager.waitId];
                  manager.isDone = true;
                  context.waitCount -= 1;
                  if (context.waitCount === 0) {
                      //Clear the wait array used for cycles.
                      waitAry = [];
                  }
              }
  
              if (err) {
                  errFile = (fullName ? makeModuleMap(fullName).url : '') ||
                             err.fileName || err.sourceURL;
                  err = makeError('defineerror', 'Error evaluating ' +
                                  'module "' + fullName + '" at location "' +
                                  errFile + '":\n' +
                                  err + '\nfileName:' + errFile +
                                  '\nlineNumber: ' + (err.lineNumber || err.line), err);
                  err.moduleName = fullName;
                  return req.onError(err);
              }
  
              if (fullName) {
                  //If anything was waiting for this module to be defined,
                  //notify them now.
                  waitingCallbacks = managerCallbacks[fullName];
                  if (waitingCallbacks) {
                      for (i = 0; i < waitingCallbacks.length; i++) {
                          waitingCallbacks[i].onDep(fullName, ret);
                      }
                      delete managerCallbacks[fullName];
                  }
              }
  
              return undefined;
          }
  
          function main(inName, depArray, callback, relModuleMap) {
              var moduleMap = makeModuleMap(inName, relModuleMap),
                  name = moduleMap.name,
                  fullName = moduleMap.fullName,
                  uniques = {},
                  manager = {
                      //Use a wait ID because some entries are anon
                      //async require calls.
                      waitId: name || reqWaitIdPrefix + (waitIdCounter++),
                      depCount: 0,
                      depMax: 0,
                      prefix: moduleMap.prefix,
                      name: name,
                      fullName: fullName,
                      deps: {},
                      depArray: depArray,
                      callback: callback,
                      onDep: function (depName, value) {
                          if (!(depName in manager.deps)) {
                              manager.deps[depName] = value;
                              manager.depCount += 1;
                              if (manager.depCount === manager.depMax) {
                                  //All done, execute!
                                  execManager(manager);
                              }
                          }
                      }
                  },
                  i, depArg, depName, cjsMod;
  
              if (fullName) {
                  //If module already defined for context, or already loaded,
                  //then leave. Also leave if jQuery is registering but it does
                  //not match the desired version number in the config.
                  if (fullName in defined || loaded[fullName] === true ||
                      (fullName === "jquery" && config.jQuery &&
                       config.jQuery !== callback().fn.jquery)) {
                      return;
                  }
  
                  //Set specified/loaded here for modules that are also loaded
                  //as part of a layer, where onScriptLoad is not fired
                  //for those cases. Do this after the inline define and
                  //dependency tracing is done.
                  specified[fullName] = true;
                  loaded[fullName] = true;
  
                  //If module is jQuery set up delaying its dom ready listeners.
                  if (fullName === "jquery" && callback) {
                      jQueryCheck(callback());
                  }
              }
  
              //Add the dependencies to the deps field, and register for callbacks
              //on the dependencies.
              for (i = 0; i < depArray.length; i++) {
                  depArg = depArray[i];
                  //There could be cases like in IE, where a trailing comma will
                  //introduce a null dependency, so only treat a real dependency
                  //value as a dependency.
                  if (depArg) {
                      //Split the dependency name into plugin and name parts
                      depArg = makeModuleMap(depArg, (name ? moduleMap : relModuleMap));
                      depName = depArg.fullName;
  
                      //Fix the name in depArray to be just the name, since
                      //that is how it will be called back later.
                      depArray[i] = depName;
  
                      //Fast path CommonJS standard dependencies.
                      if (depName === "require") {
                          manager.deps[depName] = makeRequire(moduleMap);
                      } else if (depName === "exports") {
                          //CommonJS module spec 1.1
                          manager.deps[depName] = defined[fullName] = {};
                          manager.usingExports = true;
                      } else if (depName === "module") {
                          //CommonJS module spec 1.1
                          manager.cjsModule = cjsMod = manager.deps[depName] = {
                              id: name,
                              uri: name ? context.nameToUrl(name, null, relModuleMap) : undefined,
                              exports: defined[fullName]
                          };
                          cjsMod.setExports = makeSetExports(cjsMod);
                      } else if (depName in defined && !(depName in waiting)) {
                          //Module already defined, no need to wait for it.
                          manager.deps[depName] = defined[depName];
                      } else if (!uniques[depName]) {
  
                          //A dynamic dependency.
                          manager.depMax += 1;
  
                          queueDependency(depArg);
  
                          //Register to get notification when dependency loads.
                          (managerCallbacks[depName] ||
                          (managerCallbacks[depName] = [])).push(manager);
  
                          uniques[depName] = true;
                      }
                  }
              }
  
              //Do not bother tracking the manager if it is all done.
              if (manager.depCount === manager.depMax) {
                  //All done, execute!
                  execManager(manager);
              } else {
                  waiting[manager.waitId] = manager;
                  waitAry.push(manager);
                  context.waitCount += 1;
              }
          }
  
          /**
           * Convenience method to call main for a define call that was put on
           * hold in the defQueue.
           */
          function callDefMain(args) {
              main.apply(null, args);
              //Mark the module loaded. Must do it here in addition
              //to doing it in define in case a script does
              //not call define
              loaded[args[0]] = true;
          }
  
          /**
           * jQuery 1.4.3+ supports ways to hold off calling
           * calling jQuery ready callbacks until all scripts are loaded. Be sure
           * to track it if the capability exists.. Also, since jQuery 1.4.3 does
           * not register as a module, need to do some global inference checking.
           * Even if it does register as a module, not guaranteed to be the precise
           * name of the global. If a jQuery is tracked for this context, then go
           * ahead and register it as a module too, if not already in process.
           */
          jQueryCheck = function (jqCandidate) {
              if (!context.jQuery) {
                  var $ = jqCandidate || (typeof jQuery !== "undefined" ? jQuery : null);
  
                  if ($) {
                      //If a specific version of jQuery is wanted, make sure to only
                      //use this jQuery if it matches.
                      if (config.jQuery && $.fn.jquery !== config.jQuery) {
                          return;
                      }
  
                      if ("holdReady" in $ || "readyWait" in $) {
                          context.jQuery = $;
  
                          //Manually create a "jquery" module entry if not one already
                          //or in process. Note this could trigger an attempt at
                          //a second jQuery registration, but does no harm since
                          //the first one wins, and it is the same value anyway.
                          callDefMain(["jquery", [], function () {
                              return jQuery;
                          }]);
  
                          //Ask jQuery to hold DOM ready callbacks.
                          if (context.scriptCount) {
                              jQueryHoldReady($, true);
                              context.jQueryIncremented = true;
                          }
                      }
                  }
              }
          };
  
          function forceExec(manager, traced) {
              if (manager.isDone) {
                  return undefined;
              }
  
              var fullName = manager.fullName,
                  depArray = manager.depArray,
                  depName, i;
              if (fullName) {
                  if (traced[fullName]) {
                      return defined[fullName];
                  }
  
                  traced[fullName] = true;
              }
  
              //forceExec all of its dependencies.
              for (i = 0; i < depArray.length; i++) {
                  //Some array members may be null, like if a trailing comma
                  //IE, so do the explicit [i] access and check if it has a value.
                  depName = depArray[i];
                  if (depName) {
                      if (!manager.deps[depName] && waiting[depName]) {
                          manager.onDep(depName, forceExec(waiting[depName], traced));
                      }
                  }
              }
  
              return fullName ? defined[fullName] : undefined;
          }
  
          /**
           * Checks if all modules for a context are loaded, and if so, evaluates the
           * new ones in right dependency order.
           *
           * @private
           */
          function checkLoaded() {
              var waitInterval = config.waitSeconds * 1000,
                  //It is possible to disable the wait interval by using waitSeconds of 0.
                  expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                  noLoads = "", hasLoadedProp = false, stillLoading = false, prop,
                  err, manager;
  
              //If there are items still in the paused queue processing wait.
              //This is particularly important in the sync case where each paused
              //item is processed right away but there may be more waiting.
              if (context.pausedCount > 0) {
                  return undefined;
              }
  
              //Determine if priority loading is done. If so clear the priority. If
              //not, then do not check
              if (config.priorityWait) {
                  if (isPriorityDone()) {
                      //Call resume, since it could have
                      //some waiting dependencies to trace.
                      resume();
                  } else {
                      return undefined;
                  }
              }
  
              //See if anything is still in flight.
              for (prop in loaded) {
                  if (!(prop in empty)) {
                      hasLoadedProp = true;
                      if (!loaded[prop]) {
                          if (expired) {
                              noLoads += prop + " ";
                          } else {
                              stillLoading = true;
                              break;
                          }
                      }
                  }
              }
  
              //Check for exit conditions.
              if (!hasLoadedProp && !context.waitCount) {
                  //If the loaded object had no items, then the rest of
                  //the work below does not need to be done.
                  return undefined;
              }
              if (expired && noLoads) {
                  //If wait time expired, throw error of unloaded modules.
                  err = makeError("timeout", "Load timeout for modules: " + noLoads);
                  err.requireType = "timeout";
                  err.requireModules = noLoads;
                  return req.onError(err);
              }
              if (stillLoading || context.scriptCount) {
                  //Something is still waiting to load. Wait for it, but only
                  //if a timeout is not already in effect.
                  if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                      checkLoadedTimeoutId = setTimeout(function () {
                          checkLoadedTimeoutId = 0;
                          checkLoaded();
                      }, 50);
                  }
                  return undefined;
              }
  
              //If still have items in the waiting cue, but all modules have
              //been loaded, then it means there are some circular dependencies
              //that need to be broken.
              //However, as a waiting thing is fired, then it can add items to
              //the waiting cue, and those items should not be fired yet, so
              //make sure to redo the checkLoaded call after breaking a single
              //cycle, if nothing else loaded then this logic will pick it up
              //again.
              if (context.waitCount) {
                  //Cycle through the waitAry, and call items in sequence.
                  for (i = 0; (manager = waitAry[i]); i++) {
                      forceExec(manager, {});
                  }
  
                  //Only allow this recursion to a certain depth. Only
                  //triggered by errors in calling a module in which its
                  //modules waiting on it cannot finish loading, or some circular
                  //dependencies that then may add more dependencies.
                  //The value of 5 is a bit arbitrary. Hopefully just one extra
                  //pass, or two for the case of circular dependencies generating
                  //more work that gets resolved in the sync node case.
                  if (checkLoadedDepth < 5) {
                      checkLoadedDepth += 1;
                      checkLoaded();
                  }
              }
  
              checkLoadedDepth = 0;
  
              //Check for DOM ready, and nothing is waiting across contexts.
              req.checkReadyState();
  
              return undefined;
          }
  
          function callPlugin(pluginName, dep) {
              var name = dep.name,
                  fullName = dep.fullName,
                  load;
  
              //Do not bother if plugin is already defined or being loaded.
              if (fullName in defined || fullName in loaded) {
                  return;
              }
  
              if (!plugins[pluginName]) {
                  plugins[pluginName] = defined[pluginName];
              }
  
              //Only set loaded to false for tracking if it has not already been set.
              if (!loaded[fullName]) {
                  loaded[fullName] = false;
              }
  
              load = function (ret) {
                  //Allow the build process to register plugin-loaded dependencies.
                  if (req.onPluginLoad) {
                      req.onPluginLoad(context, pluginName, name, ret);
                  }
  
                  execManager({
                      prefix: dep.prefix,
                      name: dep.name,
                      fullName: dep.fullName,
                      callback: function () {
                          return ret;
                      }
                  });
                  loaded[fullName] = true;
              };
  
              //Allow plugins to load other code without having to know the
              //context or how to "complete" the load.
              load.fromText = function (moduleName, text) {
                  /*jslint evil: true */
                  var hasInteractive = useInteractive;
  
                  //Indicate a the module is in process of loading.
                  context.loaded[moduleName] = false;
                  context.scriptCount += 1;
  
                  //Turn off interactive script matching for IE for any define
                  //calls in the text, then turn it back on at the end.
                  if (hasInteractive) {
                      useInteractive = false;
                  }
  
                  req.exec(text);
  
                  if (hasInteractive) {
                      useInteractive = true;
                  }
  
                  //Support anonymous modules.
                  context.completeLoad(moduleName);
              };
  
              //Use parentName here since the plugin's name is not reliable,
              //could be some weird string with no path that actually wants to
              //reference the parentName's path.
              plugins[pluginName].load(name, makeRequire(dep.parentMap, true), load, config);
          }
  
          function loadPaused(dep) {
              //Renormalize dependency if its name was waiting on a plugin
              //to load, which as since loaded.
              if (dep.prefix && dep.name && dep.name.indexOf('__$p') === 0 && defined[dep.prefix]) {
                  dep = makeModuleMap(dep.originalName, dep.parentMap);
              }
  
              var pluginName = dep.prefix,
                  fullName = dep.fullName,
                  urlFetched = context.urlFetched;
  
              //Do not bother if the dependency has already been specified.
              if (specified[fullName] || loaded[fullName]) {
                  return;
              } else {
                  specified[fullName] = true;
              }
  
              if (pluginName) {
                  //If plugin not loaded, wait for it.
                  //set up callback list. if no list, then register
                  //managerCallback for that plugin.
                  if (defined[pluginName]) {
                      callPlugin(pluginName, dep);
                  } else {
                      if (!pluginsQueue[pluginName]) {
                          pluginsQueue[pluginName] = [];
                          (managerCallbacks[pluginName] ||
                          (managerCallbacks[pluginName] = [])).push({
                              onDep: function (name, value) {
                                  if (name === pluginName) {
                                      var i, oldModuleMap, ary = pluginsQueue[pluginName];
  
                                      //Now update all queued plugin actions.
                                      for (i = 0; i < ary.length; i++) {
                                          oldModuleMap = ary[i];
                                          //Update the moduleMap since the
                                          //module name may be normalized
                                          //differently now.
                                          callPlugin(pluginName,
                                                     makeModuleMap(oldModuleMap.originalName, oldModuleMap.parentMap));
                                      }
                                      delete pluginsQueue[pluginName];
                                  }
                              }
                          });
                      }
                      pluginsQueue[pluginName].push(dep);
                  }
              } else {
                  if (!urlFetched[dep.url]) {
                      req.load(context, fullName, dep.url);
                      urlFetched[dep.url] = true;
                  }
              }
          }
  
          /**
           * Resumes tracing of dependencies and then checks if everything is loaded.
           */
          resume = function () {
              var args, i, p;
  
              resumeDepth += 1;
  
              if (context.scriptCount <= 0) {
                  //Synchronous envs will push the number below zero with the
                  //decrement above, be sure to set it back to zero for good measure.
                  //require() calls that also do not end up loading scripts could
                  //push the number negative too.
                  context.scriptCount = 0;
              }
  
              //Make sure any remaining defQueue items get properly processed.
              while (defQueue.length) {
                  args = defQueue.shift();
                  if (args[0] === null) {
                      return req.onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
                  } else {
                      callDefMain(args);
                  }
              }
  
              //Skip the resume of paused dependencies
              //if current context is in priority wait.
              if (!config.priorityWait || isPriorityDone()) {
                  while (context.paused.length) {
                      p = context.paused;
                      context.pausedCount += p.length;
                      //Reset paused list
                      context.paused = [];
  
                      for (i = 0; (args = p[i]); i++) {
                          loadPaused(args);
                      }
                      //Move the start time for timeout forward.
                      context.startTime = (new Date()).getTime();
                      context.pausedCount -= p.length;
                  }
              }
  
              //Only check if loaded when resume depth is 1. It is likely that
              //it is only greater than 1 in sync environments where a factory
              //function also then calls the callback-style require. In those
              //cases, the checkLoaded should not occur until the resume
              //depth is back at the top level.
              if (resumeDepth === 1) {
                  checkLoaded();
              }
  
              resumeDepth -= 1;
  
              return undefined;
          };
  
          //Define the context object. Many of these fields are on here
          //just to make debugging easier.
          context = {
              contextName: contextName,
              config: config,
              defQueue: defQueue,
              waiting: waiting,
              waitCount: 0,
              specified: specified,
              loaded: loaded,
              urlMap: urlMap,
              scriptCount: 0,
              urlFetched: {},
              defined: defined,
              paused: [],
              pausedCount: 0,
              plugins: plugins,
              managerCallbacks: managerCallbacks,
              makeModuleMap: makeModuleMap,
              normalize: normalize,
              /**
               * Set a configuration for the context.
               * @param {Object} cfg config object to integrate.
               */
              configure: function (cfg) {
                  var paths, prop, packages, pkgs, packagePaths, requireWait;
  
                  //Make sure the baseUrl ends in a slash.
                  if (cfg.baseUrl) {
                      if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== "/") {
                          cfg.baseUrl += "/";
                      }
                  }
  
                  //Save off the paths and packages since they require special processing,
                  //they are additive.
                  paths = config.paths;
                  packages = config.packages;
                  pkgs = config.pkgs;
  
                  //Mix in the config values, favoring the new values over
                  //existing ones in context.config.
                  mixin(config, cfg, true);
  
                  //Adjust paths if necessary.
                  if (cfg.paths) {
                      for (prop in cfg.paths) {
                          if (!(prop in empty)) {
                              paths[prop] = cfg.paths[prop];
                          }
                      }
                      config.paths = paths;
                  }
  
                  packagePaths = cfg.packagePaths;
                  if (packagePaths || cfg.packages) {
                      //Convert packagePaths into a packages config.
                      if (packagePaths) {
                          for (prop in packagePaths) {
                              if (!(prop in empty)) {
                                  configurePackageDir(pkgs, packagePaths[prop], prop);
                              }
                          }
                      }
  
                      //Adjust packages if necessary.
                      if (cfg.packages) {
                          configurePackageDir(pkgs, cfg.packages);
                      }
  
                      //Done with modifications, assing packages back to context config
                      config.pkgs = pkgs;
                  }
  
                  //If priority loading is in effect, trigger the loads now
                  if (cfg.priority) {
                      //Hold on to requireWait value, and reset it after done
                      requireWait = context.requireWait;
  
                      //Allow tracing some require calls to allow the fetching
                      //of the priority config.
                      context.requireWait = false;
  
                      //But first, call resume to register any defined modules that may
                      //be in a data-main built file before the priority config
                      //call. Also grab any waiting define calls for this context.
                      context.takeGlobalQueue();
                      resume();
  
                      context.require(cfg.priority);
  
                      //Trigger a resume right away, for the case when
                      //the script with the priority load is done as part
                      //of a data-main call. In that case the normal resume
                      //call will not happen because the scriptCount will be
                      //at 1, since the script for data-main is being processed.
                      resume();
  
                      //Restore previous state.
                      context.requireWait = requireWait;
                      config.priorityWait = cfg.priority;
                  }
  
                  //If a deps array or a config callback is specified, then call
                  //require with those args. This is useful when require is defined as a
                  //config object before require.js is loaded.
                  if (cfg.deps || cfg.callback) {
                      context.require(cfg.deps || [], cfg.callback);
                  }
  
                  //Set up ready callback, if asked. Useful when require is defined as a
                  //config object before require.js is loaded.
                  if (cfg.ready) {
                      req.ready(cfg.ready);
                  }
              },
  
              requireDefined: function (moduleName, relModuleMap) {
                  return makeModuleMap(moduleName, relModuleMap).fullName in defined;
              },
  
              requireSpecified: function (moduleName, relModuleMap) {
                  return makeModuleMap(moduleName, relModuleMap).fullName in specified;
              },
  
              require: function (deps, callback, relModuleMap) {
                  var moduleName, fullName, moduleMap;
                  if (typeof deps === "string") {
                      //Synchronous access to one module. If require.get is
                      //available (as in the Node adapter), prefer that.
                      //In this case deps is the moduleName and callback is
                      //the relModuleMap
                      if (req.get) {
                          return req.get(context, deps, callback);
                      }
  
                      //Just return the module wanted. In this scenario, the
                      //second arg (if passed) is just the relModuleMap.
                      moduleName = deps;
                      relModuleMap = callback;
  
                      //Normalize module name, if it contains . or ..
                      moduleMap = makeModuleMap(moduleName, relModuleMap);
                      fullName = moduleMap.fullName;
  
                      if (!(fullName in defined)) {
                          return req.onError(makeError("notloaded", "Module name '" +
                                      moduleMap.fullName +
                                      "' has not been loaded yet for context: " +
                                      contextName));
                      }
                      return defined[fullName];
                  }
  
                  main(null, deps, callback, relModuleMap);
  
                  //If the require call does not trigger anything new to load,
                  //then resume the dependency processing.
                  if (!context.requireWait) {
                      while (!context.scriptCount && context.paused.length) {
                          //For built layers, there can be some defined
                          //modules waiting for intake into the context,
                          //in particular module plugins. Take them.
                          context.takeGlobalQueue();
                          resume();
                      }
                  }
                  return context.require;
              },
  
              /**
               * Internal method to transfer globalQueue items to this context's
               * defQueue.
               */
              takeGlobalQueue: function () {
                  //Push all the globalDefQueue items into the context's defQueue
                  if (globalDefQueue.length) {
                      //Array splice in the values since the context code has a
                      //local var ref to defQueue, so cannot just reassign the one
                      //on context.
                      apsp.apply(context.defQueue,
                                 [context.defQueue.length - 1, 0].concat(globalDefQueue));
                      globalDefQueue = [];
                  }
              },
  
              /**
               * Internal method used by environment adapters to complete a load event.
               * A load event could be a script load or just a load pass from a synchronous
               * load call.
               * @param {String} moduleName the name of the module to potentially complete.
               */
              completeLoad: function (moduleName) {
                  var args;
  
                  context.takeGlobalQueue();
  
                  while (defQueue.length) {
                      args = defQueue.shift();
  
                      if (args[0] === null) {
                          args[0] = moduleName;
                          break;
                      } else if (args[0] === moduleName) {
                          //Found matching define call for this script!
                          break;
                      } else {
                          //Some other named define call, most likely the result
                          //of a build layer that included many define calls.
                          callDefMain(args);
                          args = null;
                      }
                  }
                  if (args) {
                      callDefMain(args);
                  } else {
                      //A script that does not call define(), so just simulate
                      //the call for it. Special exception for jQuery dynamic load.
                      callDefMain([moduleName, [],
                                  moduleName === "jquery" && typeof jQuery !== "undefined" ?
                                  function () {
                                      return jQuery;
                                  } : null]);
                  }
  
                  //Mark the script as loaded. Note that this can be different from a
                  //moduleName that maps to a define call. This line is important
                  //for traditional browser scripts.
                  loaded[moduleName] = true;
  
                  //If a global jQuery is defined, check for it. Need to do it here
                  //instead of main() since stock jQuery does not register as
                  //a module via define.
                  jQueryCheck();
  
                  //Doing this scriptCount decrement branching because sync envs
                  //need to decrement after resume, otherwise it looks like
                  //loading is complete after the first dependency is fetched.
                  //For browsers, it works fine to decrement after, but it means
                  //the checkLoaded setTimeout 50 ms cost is taken. To avoid
                  //that cost, decrement beforehand.
                  if (req.isAsync) {
                      context.scriptCount -= 1;
                  }
                  resume();
                  if (!req.isAsync) {
                      context.scriptCount -= 1;
                  }
              },
  
              /**
               * Converts a module name + .extension into an URL path.
               * *Requires* the use of a module name. It does not support using
               * plain URLs like nameToUrl.
               */
              toUrl: function (moduleNamePlusExt, relModuleMap) {
                  var index = moduleNamePlusExt.lastIndexOf("."),
                      ext = null;
  
                  if (index !== -1) {
                      ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                      moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                  }
  
                  return context.nameToUrl(moduleNamePlusExt, ext, relModuleMap);
              },
  
              /**
               * Converts a module name to a file path. Supports cases where
               * moduleName may actually be just an URL.
               */
              nameToUrl: function (moduleName, ext, relModuleMap) {
                  var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
                      config = context.config;
  
                  //Normalize module name if have a base relative module name to work from.
                  moduleName = normalize(moduleName, relModuleMap && relModuleMap.fullName);
  
                  //If a colon is in the URL, it indicates a protocol is used and it is just
                  //an URL to a file, or if it starts with a slash or ends with .js, it is just a plain file.
                  //The slash is important for protocol-less URLs as well as full paths.
                  if (req.jsExtRegExp.test(moduleName)) {
                      //Just a plain path, not module name lookup, so just return it.
                      //Add extension if it is included. This is a bit wonky, only non-.js things pass
                      //an extension, this method probably needs to be reworked.
                      url = moduleName + (ext ? ext : "");
                  } else {
                      //A module that needs to be converted to a path.
                      paths = config.paths;
                      pkgs = config.pkgs;
  
                      syms = moduleName.split("/");
                      //For each module name segment, see if there is a path
                      //registered for it. Start with most specific name
                      //and work up from it.
                      for (i = syms.length; i > 0; i--) {
                          parentModule = syms.slice(0, i).join("/");
                          if (paths[parentModule]) {
                              syms.splice(0, i, paths[parentModule]);
                              break;
                          } else if ((pkg = pkgs[parentModule])) {
                              //If module name is just the package name, then looking
                              //for the main module.
                              if (moduleName === pkg.name) {
                                  pkgPath = pkg.location + '/' + pkg.main;
                              } else {
                                  pkgPath = pkg.location;
                              }
                              syms.splice(0, i, pkgPath);
                              break;
                          }
                      }
  
                      //Join the path parts together, then figure out if baseUrl is needed.
                      url = syms.join("/") + (ext || ".js");
                      url = (url.charAt(0) === '/' || url.match(/^\w+:/) ? "" : config.baseUrl) + url;
                  }
  
                  return config.urlArgs ? url +
                                          ((url.indexOf('?') === -1 ? '?' : '&') +
                                           config.urlArgs) : url;
              }
          };
  
          //Make these visible on the context so can be called at the very
          //end of the file to bootstrap
          context.jQueryCheck = jQueryCheck;
          context.resume = resume;
  
          return context;
      }
  
      /**
       * Main entry point.
       *
       * If the only argument to require is a string, then the module that
       * is represented by that string is fetched for the appropriate context.
       *
       * If the first argument is an array, then it will be treated as an array
       * of dependency string names to fetch. An optional function callback can
       * be specified to execute when all of those dependencies are available.
       *
       * Make a local req variable to help Caja compliance (it assumes things
       * on a require that are not standardized), and to give a short
       * name for minification/local scope use.
       */
      req = requirejs = function (deps, callback) {
  
          //Find the right context, use default
          var contextName = defContextName,
              context, config;
  
          // Determine if have config object in the call.
          if (!isArray(deps) && typeof deps !== "string") {
              // deps is a config object
              config = deps;
              if (isArray(callback)) {
                  // Adjust args if there are dependencies
                  deps = callback;
                  callback = arguments[2];
              } else {
                  deps = [];
              }
          }
  
          if (config && config.context) {
              contextName = config.context;
          }
  
          context = contexts[contextName] ||
                    (contexts[contextName] = newContext(contextName));
  
          if (config) {
              context.configure(config);
          }
  
          return context.require(deps, callback);
      };
  
      /**
       * Support require.config() to make it easier to cooperate with other
       * AMD loaders on globally agreed names.
       */
      req.config = function (config) {
          return req(config);
      };
  
      /**
       * Export require as a global, but only if it does not already exist.
       */
      if (typeof require === "undefined") {
          require = req;
      }
  
      /**
       * Global require.toUrl(), to match global require, mostly useful
       * for debugging/work in the global space.
       */
      req.toUrl = function (moduleNamePlusExt) {
          return contexts[defContextName].toUrl(moduleNamePlusExt);
      };
  
      req.version = version;
      req.isArray = isArray;
      req.isFunction = isFunction;
      req.mixin = mixin;
      //Used to filter out dependencies that are already paths.
      req.jsExtRegExp = /^\/|:|\?|\.js$/;
      s = req.s = {
          contexts: contexts,
          //Stores a list of URLs that should not get async script tag treatment.
          skipAsync: {},
          isPageLoaded: !isBrowser,
          readyCalls: []
      };
  
      req.isAsync = req.isBrowser = isBrowser;
      if (isBrowser) {
          head = s.head = document.getElementsByTagName("head")[0];
          //If BASE tag is in play, using appendChild is a problem for IE6.
          //When that browser dies, this can be removed. Details in this jQuery bug:
          //http://dev.jquery.com/ticket/2709
          baseElement = document.getElementsByTagName("base")[0];
          if (baseElement) {
              head = s.head = baseElement.parentNode;
          }
      }
  
      /**
       * Any errors that require explicitly generates will be passed to this
       * function. Intercept/override it if you want custom error handling.
       * @param {Error} err the error object.
       */
      req.onError = function (err) {
          throw err;
      };
  
      /**
       * Does the request to load a module for the browser case.
       * Make this a separate function to allow other environments
       * to override it.
       *
       * @param {Object} context the require context to find state.
       * @param {String} moduleName the name of the module.
       * @param {Object} url the URL to the module.
       */
      req.load = function (context, moduleName, url) {
          var loaded = context.loaded;
  
          isDone = false;
  
          //Only set loaded to false for tracking if it has not already been set.
          if (!loaded[moduleName]) {
              loaded[moduleName] = false;
          }
  
          context.scriptCount += 1;
          req.attach(url, context, moduleName);
  
          //If tracking a jQuery, then make sure its ready callbacks
          //are put on hold to prevent its ready callbacks from
          //triggering too soon.
          if (context.jQuery && !context.jQueryIncremented) {
              jQueryHoldReady(context.jQuery, true);
              context.jQueryIncremented = true;
          }
      };
  
      function getInteractiveScript() {
          var scripts, i, script;
          if (interactiveScript && interactiveScript.readyState === 'interactive') {
              return interactiveScript;
          }
  
          scripts = document.getElementsByTagName('script');
          for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
              if (script.readyState === 'interactive') {
                  return (interactiveScript = script);
              }
          }
  
          return null;
      }
  
      /**
       * The function that handles definitions of modules. Differs from
       * require() in that a string for the module should be the first argument,
       * and the function to execute after dependencies are loaded should
       * return a value to define the module corresponding to the first argument's
       * name.
       */
      define = req.def = function (name, deps, callback) {
          var node, context;
  
          //Allow for anonymous functions
          if (typeof name !== 'string') {
              //Adjust args appropriately
              callback = deps;
              deps = name;
              name = null;
          }
  
          //This module may not have dependencies
          if (!req.isArray(deps)) {
              callback = deps;
              deps = [];
          }
  
          //If no name, and callback is a function, then figure out if it a
          //CommonJS thing with dependencies.
          if (!name && !deps.length && req.isFunction(callback)) {
              //Remove comments from the callback string,
              //look for require calls, and pull them into the dependencies,
              //but only if there are function args.
              if (callback.length) {
                  callback
                      .toString()
                      .replace(commentRegExp, "")
                      .replace(cjsRequireRegExp, function (match, dep) {
                          deps.push(dep);
                      });
  
                  //May be a CommonJS thing even without require calls, but still
                  //could use exports, and module. Avoid doing exports and module
                  //work though if it just needs require.
                  //REQUIRES the function to expect the CommonJS variables in the
                  //order listed below.
                  deps = (callback.length === 1 ? ["require"] : ["require", "exports", "module"]).concat(deps);
              }
          }
  
          //If in IE 6-8 and hit an anonymous define() call, do the interactive
          //work.
          if (useInteractive) {
              node = currentlyAddingScript || getInteractiveScript();
              if (node) {
                  if (!name) {
                      name = node.getAttribute("data-requiremodule");
                  }
                  context = contexts[node.getAttribute("data-requirecontext")];
              }
          }
  
          //Always save off evaluating the def call until the script onload handler.
          //This allows multiple modules to be in a file without prematurely
          //tracing dependencies, and allows for anonymous module support,
          //where the module name is not known until the script onload event
          //occurs. If no context, use the global queue, and get it processed
          //in the onscript load callback.
          (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
  
          return undefined;
      };
  
      define.amd = {
          multiversion: true,
          plugins: true,
          jQuery: true
      };
  
      /**
       * Executes the text. Normally just uses eval, but can be modified
       * to use a more environment specific call.
       * @param {String} text the text to execute/evaluate.
       */
      req.exec = function (text) {
          return eval(text);
      };
  
      /**
       * Executes a module callack function. Broken out as a separate function
       * solely to allow the build system to sequence the files in the built
       * layer in the right sequence.
       *
       * @private
       */
      req.execCb = function (name, callback, args, exports) {
          return callback.apply(exports, args);
      };
  
      /**
       * callback for script loads, used to check status of loading.
       *
       * @param {Event} evt the event from the browser for the script
       * that was loaded.
       *
       * @private
       */
      req.onScriptLoad = function (evt) {
          //Using currentTarget instead of target for Firefox 2.0's sake. Not
          //all old browsers will be supported, but this one was easy enough
          //to support and still makes sense.
          var node = evt.currentTarget || evt.srcElement, contextName, moduleName,
              context;
  
          if (evt.type === "load" || readyRegExp.test(node.readyState)) {
              //Reset interactive script so a script node is not held onto for
              //to long.
              interactiveScript = null;
  
              //Pull out the name of the module and the context.
              contextName = node.getAttribute("data-requirecontext");
              moduleName = node.getAttribute("data-requiremodule");
              context = contexts[contextName];
  
              contexts[contextName].completeLoad(moduleName);
  
              //Clean up script binding. Favor detachEvent because of IE9
              //issue, see attachEvent/addEventListener comment elsewhere
              //in this file.
              if (node.detachEvent && !isOpera) {
                  //Probably IE. If not it will throw an error, which will be
                  //useful to know.
                  node.detachEvent("onreadystatechange", req.onScriptLoad);
              } else {
                  node.removeEventListener("load", req.onScriptLoad, false);
              }
          }
      };
  
      /**
       * Attaches the script represented by the URL to the current
       * environment. Right now only supports browser loading,
       * but can be redefined in other environments to do the right thing.
       * @param {String} url the url of the script to attach.
       * @param {Object} context the context that wants the script.
       * @param {moduleName} the name of the module that is associated with the script.
       * @param {Function} [callback] optional callback, defaults to require.onScriptLoad
       * @param {String} [type] optional type, defaults to text/javascript
       */
      req.attach = function (url, context, moduleName, callback, type) {
          var node, loaded;
          if (isBrowser) {
              //In the browser so use a script tag
              callback = callback || req.onScriptLoad;
              node = context && context.config && context.config.xhtml ?
                      document.createElementNS("http://www.w3.org/1999/xhtml", "html:script") :
                      document.createElement("script");
              node.type = type || "text/javascript";
              node.charset = "utf-8";
              //Use async so Gecko does not block on executing the script if something
              //like a long-polling comet tag is being run first. Gecko likes
              //to evaluate scripts in DOM order, even for dynamic scripts.
              //It will fetch them async, but only evaluate the contents in DOM
              //order, so a long-polling script tag can delay execution of scripts
              //after it. But telling Gecko we expect async gets us the behavior
              //we want -- execute it whenever it is finished downloading. Only
              //Helps Firefox 3.6+
              //Allow some URLs to not be fetched async. Mostly helps the order!
              //plugin
              node.async = !s.skipAsync[url];
  
              if (context) {
                  node.setAttribute("data-requirecontext", context.contextName);
              }
              node.setAttribute("data-requiremodule", moduleName);
  
              //Set up load listener. Test attachEvent first because IE9 has
              //a subtle issue in its addEventListener and script onload firings
              //that do not match the behavior of all other browsers with
              //addEventListener support, which fire the onload event for a
              //script right after the script execution. See:
              //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
              //UNFORTUNATELY Opera implements attachEvent but does not follow the script
              //script execution mode.
              if (node.attachEvent && !isOpera) {
                  //Probably IE. IE (at least 6-8) do not fire
                  //script onload right after executing the script, so
                  //we cannot tie the anonymous define call to a name.
                  //However, IE reports the script as being in "interactive"
                  //readyState at the time of the define call.
                  useInteractive = true;
                  node.attachEvent("onreadystatechange", callback);
              } else {
                  node.addEventListener("load", callback, false);
              }
              node.src = url;
  
              //For some cache cases in IE 6-8, the script executes before the end
              //of the appendChild execution, so to tie an anonymous define
              //call to the module name (which is stored on the node), hold on
              //to a reference to this node, but clear after the DOM insertion.
              currentlyAddingScript = node;
              if (baseElement) {
                  head.insertBefore(node, baseElement);
              } else {
                  head.appendChild(node);
              }
              currentlyAddingScript = null;
              return node;
          } else if (isWebWorker) {
              //In a web worker, use importScripts. This is not a very
              //efficient use of importScripts, importScripts will block until
              //its script is downloaded and evaluated. However, if web workers
              //are in play, the expectation that a build has been done so that
              //only one script needs to be loaded anyway. This may need to be
              //reevaluated if other use cases become common.
              loaded = context.loaded;
              loaded[moduleName] = false;
  
              importScripts(url);
  
              //Account for anonymous modules
              context.completeLoad(moduleName);
          }
          return null;
      };
  
      //Look for a data-main script attribute, which could also adjust the baseUrl.
      if (isBrowser) {
          //Figure out baseUrl. Get it from the script tag with require.js in it.
          scripts = document.getElementsByTagName("script");
  
          for (i = scripts.length - 1; i > -1 && (script = scripts[i]); i--) {
              //Set the "head" where we can append children by
              //using the script's parent.
              if (!head) {
                  head = script.parentNode;
              }
  
              //Look for a data-main attribute to set main script for the page
              //to load. If it is there, the path to data main becomes the
              //baseUrl, if it is not already set.
              if ((dataMain = script.getAttribute('data-main'))) {
                  if (!cfg.baseUrl) {
                      //Pull off the directory of data-main for use as the
                      //baseUrl.
                      src = dataMain.split('/');
                      mainScript = src.pop();
                      subPath = src.length ? src.join('/')  + '/' : './';
  
                      //Set final config.
                      cfg.baseUrl = subPath;
                      //Strip off any trailing .js since dataMain is now
                      //like a module name.
                      dataMain = mainScript.replace(jsSuffixRegExp, '');
                  }
  
                  //Put the data-main script in the files to load.
                  cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
  
                  break;
              }
          }
      }
  
      //Set baseUrl based on config.
      s.baseUrl = cfg.baseUrl;
  
      //****** START page load functionality ****************
      /**
       * Sets the page as loaded and triggers check for all modules loaded.
       */
      req.pageLoaded = function () {
          if (!s.isPageLoaded) {
              s.isPageLoaded = true;
              if (scrollIntervalId) {
                  clearInterval(scrollIntervalId);
              }
  
              //Part of a fix for FF < 3.6 where readyState was not set to
              //complete so libraries like jQuery that check for readyState
              //after page load where not getting initialized correctly.
              //Original approach suggested by Andrea Giammarchi:
              //http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
              //see other setReadyState reference for the rest of the fix.
              if (setReadyState) {
                  document.readyState = "complete";
              }
  
              req.callReady();
          }
      };
  
      //See if there is nothing waiting across contexts, and if not, trigger
      //callReady.
      req.checkReadyState = function () {
          var contexts = s.contexts, prop;
          for (prop in contexts) {
              if (!(prop in empty)) {
                  if (contexts[prop].waitCount) {
                      return;
                  }
              }
          }
          s.isDone = true;
          req.callReady();
      };
  
      /**
       * Internal function that calls back any ready functions. If you are
       * integrating RequireJS with another library without require.ready support,
       * you can define this method to call your page ready code instead.
       */
      req.callReady = function () {
          var callbacks = s.readyCalls, i, callback, contexts, context, prop;
  
          if (s.isPageLoaded && s.isDone) {
              if (callbacks.length) {
                  s.readyCalls = [];
                  for (i = 0; (callback = callbacks[i]); i++) {
                      callback();
                  }
              }
  
              //If jQuery with DOM ready delayed, release it now.
              contexts = s.contexts;
              for (prop in contexts) {
                  if (!(prop in empty)) {
                      context = contexts[prop];
                      if (context.jQueryIncremented) {
                          jQueryHoldReady(context.jQuery, false);
                          context.jQueryIncremented = false;
                      }
                  }
              }
          }
      };
  
      /**
       * Registers functions to call when the page is loaded
       */
      req.ready = function (callback) {
          if (s.isPageLoaded && s.isDone) {
              callback();
          } else {
              s.readyCalls.push(callback);
          }
          return req;
      };
  
      if (isBrowser) {
          if (document.addEventListener) {
              //Standards. Hooray! Assumption here that if standards based,
              //it knows about DOMContentLoaded.
              document.addEventListener("DOMContentLoaded", req.pageLoaded, false);
              window.addEventListener("load", req.pageLoaded, false);
              //Part of FF < 3.6 readystate fix (see setReadyState refs for more info)
              if (!document.readyState) {
                  setReadyState = true;
                  document.readyState = "loading";
              }
          } else if (window.attachEvent) {
              window.attachEvent("onload", req.pageLoaded);
  
              //DOMContentLoaded approximation, as found by Diego Perini:
              //http://javascript.nwbox.com/IEContentLoaded/
              if (self === self.top) {
                  scrollIntervalId = setInterval(function () {
                      try {
                          //From this ticket:
                          //http://bugs.dojotoolkit.org/ticket/11106,
                          //In IE HTML Application (HTA), such as in a selenium test,
                          //javascript in the iframe can't see anything outside
                          //of it, so self===self.top is true, but the iframe is
                          //not the top window and doScroll will be available
                          //before document.body is set. Test document.body
                          //before trying the doScroll trick.
                          if (document.body) {
                              document.documentElement.doScroll("left");
                              req.pageLoaded();
                          }
                      } catch (e) {}
                  }, 30);
              }
          }
  
          //Check if document already complete, and if so, just trigger page load
          //listeners. NOTE: does not work with Firefox before 3.6. To support
          //those browsers, manually call require.pageLoaded().
          if (document.readyState === "complete") {
              req.pageLoaded();
          }
      }
      //****** END page load functionality ****************
  
      //Set up default context. If require was a configuration object, use that as base config.
      req(cfg);
  
      //If modules are built into require.js, then need to make sure dependencies are
      //traced. Use a setTimeout in the browser world, to allow all the modules to register
      //themselves. In a non-browser env, assume that modules are not built into require.js,
      //which seems odd to do on the server.
      if (req.isAsync && typeof setTimeout !== "undefined") {
          ctx = s.contexts[(cfg.context || defContextName)];
          //Indicate that the script that includes require() is still loading,
          //so that require()'d dependencies are not traced until the end of the
          //file is parsed (approximated via the setTimeout call).
          ctx.requireWait = true;
          setTimeout(function () {
              ctx.requireWait = false;
  
              //Any modules included with the require.js file will be in the
              //global queue, assign them to this context.
              ctx.takeGlobalQueue();
  
              //Allow for jQuery to be loaded/already in the page, and if jQuery 1.4.3,
              //make sure to hold onto it for readyWait triggering.
              ctx.jQueryCheck();
  
              if (!ctx.scriptCount) {
                  ctx.resume();
              }
              req.checkReadyState();
          }, 0);
      }
  }());
  
  
  