function eachReverse(ary, func) {
  if (ary) {
    var i;
    for (i = ary.length - 1; i > -1; i -= 1) {
      if (ary[i] && func(ary[i], i, ary)) {
        break;
      }
    }
  }
}

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;
  }
}

/**
* Set a configuration for the context.
* @param {Object} cfg config object to integrate.
*/
configure: function (cfg) {
  //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.
  var pkgs = config.pkgs,
              shim = config.shim,
              objs = {
                paths: true,
                config: true,
                map: true
              };

  eachProp(cfg, function (value, prop) {
    if (objs[prop]) {
      if (prop === ‘map‘) {
        if (!config.map) {
          config.map = {};
        }
        mixin(config[prop], value, true, true);
      } else {
        mixin(config[prop], value, true);
      }
    } else {
      config[prop] = value;
    }
  });

  //Merge shim
  if (cfg.shim) {
    eachProp(cfg.shim, function (value, id) {
      //Normalize the structure
      if (isArray(value)) {
        value = {
          deps: value
        };
      }
      if ((value.exports || value.init) && !value.exportsFn) {
        value.exportsFn = context.makeShimExports(value);
      }
      shim[id] = value;
    });
    config.shim = shim;
  }

  //Adjust packages if necessary.
  if (cfg.packages) {
    each(cfg.packages, function (pkgObj) {
      var location;

      pkgObj = typeof pkgObj === ‘string‘ ? { name: pkgObj} : pkgObj;
      location = pkgObj.location;

      //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, ‘‘)
      };
    });

    //Done with modifications, assing packages back to context config
    config.pkgs = pkgs;
  }

  //If there are any "waiting to execute" modules in the registry,
  //update the maps for them, since their info, like URLs to load,
  //may have changed.
  eachProp(registry, function (mod, id) {
    //If module already has init called, since it is too
    //late to modify them, and ignore unnormalized ones
    //since they are transient.
    if (!mod.inited && !mod.map.unnormalized) {
      mod.map = makeModuleMap(id);
    }
  });

  //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);
  }
},

/**
* Cycles over properties in an object and calls a function for each
* property value. If the function returns a truthy value, then the
* iteration is stopped.
*/
function eachProp(obj, func) {
  var prop;
  for (prop in obj) {
    if (hasProp(obj, prop)) {
      if (func(obj[prop], prop)) {
        break;
      }
    }
  }
}

function localRequire(deps, callback, errback) {
  var id, map, requireMod;

  if (options.enableBuildCallback && callback && isFunction(callback)) {
    callback.__requireJsBuild = true;
  }

  if (typeof deps === ‘string‘) {
    if (isFunction(callback)) {
      //Invalid call
      return onError(makeError(‘requireargs‘, ‘Invalid require call‘), errback);
    }

    //If require|exports|module are requested, get the
    //value for them from the special handlers. Caveat:
    //this only works while module is being defined.
    if (relMap && hasProp(handlers, deps)) {
      return handlers[deps](registry[relMap.id]);
    }

    //Synchronous access to one module. If require.get is
    //available (as in the Node adapter), prefer that.
    if (req.get) {
      return req.get(context, deps, relMap, localRequire);
    }

    //Normalize module name, if it contains . or ..
    map = makeModuleMap(deps, relMap, false, true);
    id = map.id;

    if (!hasProp(defined, id)) {
      return onError(makeError(‘notloaded‘, ‘Module name "‘ +
                                id +
                                ‘" has not been loaded yet for context: ‘ +
                                contextName +
                                (relMap ? ‘‘ : ‘. Use require([])‘)));
    }
    return defined[id];
  }

  //Grab defines waiting in the global queue.
  intakeDefines();

  //Mark all the dependencies as needing to be loaded.
  context.nextTick(function () {
    //Some defines could have been added since the
    //require call, collect them.
    intakeDefines();

    requireMod = getModule(makeModuleMap(null, relMap));

    //Store if map config should be applied to this require
    //call for dependencies.
    requireMod.skipMap = options.skipMap;

    requireMod.init(deps, callback, errback, {
      enabled: true
    });

    checkLoaded();
  });

  return localRequire;
}

/**
* 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.
* @param {Boolean} isNormalized: is the ID already normalized.
* This is true if this call is done for a define() module ID.
* @param {Boolean} applyMap: apply the map config to the ID.
* Should only be true if this map is for a dependency.
*
* @returns {Object}
*/
function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
  var url, pluginModule, suffix, nameParts,
            prefix = null,
            parentName = parentModuleMap ? parentModuleMap.name : null,
            originalName = name,
            isDefine = true,
            normalizedName = ‘‘;

  //If no name, then it means it is a require call, generate an
  //internal name.
  if (!name) {
    isDefine = false;
    name = ‘_@r‘ + (requireCounter += 1);
  }

  nameParts = splitPrefix(name);
  prefix = nameParts[0];
  name = nameParts[1];

  if (prefix) {
    prefix = normalize(prefix, parentName, applyMap);
    pluginModule = getOwn(defined, prefix);
  }

  //Account for relative paths if there is a base name.
  if (name) {
    if (prefix) {
      if (pluginModule && pluginModule.normalize) {
        //Plugin is loaded, use its normalize method.
        normalizedName = pluginModule.normalize(name, function (name) {
          return normalize(name, parentName, applyMap);
        });
      } else {
        normalizedName = normalize(name, parentName, applyMap);
      }
    } else {
      //A regular module.
      normalizedName = normalize(name, parentName, applyMap);

      //Normalized name may be a plugin ID due to map config
      //application in normalize. The map config values must
      //already be normalized, so do not need to redo that part.
      nameParts = splitPrefix(normalizedName);
      prefix = nameParts[0];
      normalizedName = nameParts[1];
      isNormalized = true;

      url = context.nameToUrl(normalizedName);
    }
  }

  //If the id is a plugin id that cannot be determined if it needs
  //normalization, stamp it with a unique ID so two matching relative
  //ids that may conflict can be separate.
  suffix = prefix && !pluginModule && !isNormalized ?
                  ‘_unnormalized‘ + (unnormalizedCounter += 1) :
                  ‘‘;

  return {
    prefix: prefix,
    name: normalizedName,
    parentMap: parentModuleMap,
    unnormalized: !!suffix,
    url: url,
    originalName: originalName,
    isDefine: isDefine,
    id: (prefix ?
                    prefix + ‘!‘ + normalizedName :
                    normalizedName) + suffix
  };
}

Module = function (map) {
  this.events = getOwn(undefEvents, map.id) || {};
  this.map = map;
  this.shim = getOwn(config.shim, map.id);
  this.depExports = [];
  this.depMaps = [];
  this.depMatched = [];
  this.pluginMaps = {};
  this.depCount = 0;

  /* this.exports this.factory
  this.depMaps = [],
  this.enabled, this.fetched
  */
};

Module.prototype = {
  init: function (depMaps, factory, errback, options) {
    options = options || {};

    //Do not do more inits if already done. Can happen if there
    //are multiple define calls for the same module. That is not
    //a normal, common case, but it is also not unexpected.
    if (this.inited) {
      return;
    }

    this.factory = factory;

    if (errback) {
      //Register for errors on this module.
      this.on(‘error‘, errback);
    } else if (this.events.error) {
      //If no errback already, but there are error listeners
      //on this module, set up an errback to pass to the deps.
      errback = bind(this, function (err) {
        this.emit(‘error‘, err);
      });
    }

    //Do a copy of the dependency array, so that
    //source inputs are not modified. For example
    //"shim" deps are passed in here directly, and
    //doing a direct modification of the depMaps array
    //would affect that config.
    this.depMaps = depMaps && depMaps.slice(0);

    this.errback = errback;

    //Indicate this module has be initialized
    this.inited = true;

    this.ignore = options.ignore;

    //Could have option to init this module in enabled mode,
    //or could have been previously marked as enabled. However,
    //the dependencies are not known until init is called. So
    //if enabled previously, now trigger dependencies as enabled.
    if (options.enabled || this.enabled) {
      //Enable this module and dependencies.
      //Will call this.check()
      this.enable();
    } else {
      this.check();
    }
  },

  defineDep: function (i, depExports) {
    //Because of cycles, defined callback for a given
    //export can be called more than once.
    if (!this.depMatched[i]) {
      this.depMatched[i] = true;
      this.depCount -= 1;
      this.depExports[i] = depExports;
    }
  },

  fetch: function () {
    if (this.fetched) {
      return;
    }
    this.fetched = true;

    context.startTime = (new Date()).getTime();

    var map = this.map;

    //If the manager is for a plugin managed resource,
    //ask the plugin to load it now.
    if (this.shim) {
      context.makeRequire(this.map, {
        enableBuildCallback: true
      })(this.shim.deps || [], bind(this, function () {
        return map.prefix ? this.callPlugin() : this.load();
      }));
    } else {
      //Regular dependency.
      return map.prefix ? this.callPlugin() : this.load();
    }
  },

  load: function () {
    var url = this.map.url;

    //Regular dependency.
    if (!urlFetched[url]) {
      urlFetched[url] = true;
      context.load(this.map.id, url);
    }
  },

  /**
  * Checks if the module is ready to define itself, and if so,
  * define it.
  */
  check: function () {
    if (!this.enabled || this.enabling) {
      return;
    }

    var err, cjsModule,
                id = this.map.id,
                depExports = this.depExports,
                exports = this.exports,
                factory = this.factory;

    if (!this.inited) {
      this.fetch();
    } else if (this.error) {
      this.emit(‘error‘, this.error);
    } else if (!this.defining) {
      //The factory could trigger another require call
      //that would result in checking this module to
      //define itself again. If already in the process
      //of doing that, skip this work.
      this.defining = true;

      if (this.depCount < 1 && !this.defined) {
        if (isFunction(factory)) {
          //If there is an error listener, favor passing
          //to that instead of throwing an error. However,
          //only do it for define()‘d  modules. require
          //errbacks should not be called for failures in
          //their callbacks (#699). However if a global
          //onError is set, use that.
          if ((this.events.error && this.map.isDefine) ||
                            req.onError !== defaultOnError) {
            try {
              exports = context.execCb(id, factory, depExports, exports);
            } catch (e) {
              err = e;
            }
          } else {
            exports = context.execCb(id, factory, depExports, exports);
          }

          if (this.map.isDefine) {
            //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.
            cjsModule = this.module;
            if (cjsModule &&
                                    cjsModule.exports !== undefined &&
            //Make sure it is not already the exports value
                                    cjsModule.exports !== this.exports) {
              exports = cjsModule.exports;
            } else if (exports === undefined && this.usingExports) {
              //exports already set the defined value.
              exports = this.exports;
            }
          }

          if (err) {
            err.requireMap = this.map;
            err.requireModules = this.map.isDefine ? [this.map.id] : null;
            err.requireType = this.map.isDefine ? ‘define‘ : ‘require‘;
            return onError((this.error = err));
          }

        } else {
          //Just a literal value
          exports = factory;
        }

        this.exports = exports;

        if (this.map.isDefine && !this.ignore) {
          defined[id] = exports;

          if (req.onResourceLoad) {
            req.onResourceLoad(context, this.map, this.depMaps);
          }
        }

        //Clean up
        cleanRegistry(id);

        this.defined = true;
      }

      //Finished the define stage. Allow calling check again
      //to allow define notifications below in the case of a
      //cycle.
      this.defining = false;

      if (this.defined && !this.defineEmitted) {
        this.defineEmitted = true;
        this.emit(‘defined‘, this.exports);
        this.defineEmitComplete = true;
      }

    }
  },

  callPlugin: function () {
    var map = this.map,
                id = map.id,
    //Map already normalized the prefix.
                pluginMap = makeModuleMap(map.prefix);

    //Mark this as a dependency for this plugin, so it
    //can be traced for cycles.
    this.depMaps.push(pluginMap);

    on(pluginMap, ‘defined‘, bind(this, function (plugin) {
      var load, normalizedMap, normalizedMod,
                    name = this.map.name,
                    parentName = this.map.parentMap ? this.map.parentMap.name : null,
                    localRequire = context.makeRequire(map.parentMap, {
                      enableBuildCallback: true
                    });

      //If current map is not normalized, wait for that
      //normalized name to load instead of continuing.
      if (this.map.unnormalized) {
        //Normalize the ID if the plugin allows it.
        if (plugin.normalize) {
          name = plugin.normalize(name, function (name) {
            return normalize(name, parentName, true);
          }) || ‘‘;
        }

        //prefix and name should already be normalized, no need
        //for applying map config again either.
        normalizedMap = makeModuleMap(map.prefix + ‘!‘ + name,
                                                  this.map.parentMap);
        on(normalizedMap,
                        ‘defined‘, bind(this, function (value) {
                          this.init([], function () { return value; }, null, {
                            enabled: true,
                            ignore: true
                          });
                        }));

        normalizedMod = getOwn(registry, normalizedMap.id);
        if (normalizedMod) {
          //Mark this as a dependency for this plugin, so it
          //can be traced for cycles.
          this.depMaps.push(normalizedMap);

          if (this.events.error) {
            normalizedMod.on(‘error‘, bind(this, function (err) {
              this.emit(‘error‘, err);
            }));
          }
          normalizedMod.enable();
        }

        return;
      }

      load = bind(this, function (value) {
        this.init([], function () { return value; }, null, {
          enabled: true
        });
      });

      load.error = bind(this, function (err) {
        this.inited = true;
        this.error = err;
        err.requireModules = [id];

        //Remove temp unnormalized modules for this module,
        //since they will never be resolved otherwise now.
        eachProp(registry, function (mod) {
          if (mod.map.id.indexOf(id + ‘_unnormalized‘) === 0) {
            cleanRegistry(mod.map.id);
          }
        });

        onError(err);
      });

      //Allow plugins to load other code without having to know the
      //context or how to ‘complete‘ the load.
      load.fromText = bind(this, function (text, textAlt) {
        /*jslint evil: true */
        var moduleName = map.name,
                        moduleMap = makeModuleMap(moduleName),
                        hasInteractive = useInteractive;

        //As of 2.1.0, support just passing the text, to reinforce
        //fromText only being called once per resource. Still
        //support old style of passing moduleName but discard
        //that moduleName in favor of the internal ref.
        if (textAlt) {
          text = textAlt;
        }

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

        //Prime the system by creating a module instance for
        //it.
        getModule(moduleMap);

        //Transfer any config to this other module.
        if (hasProp(config.config, id)) {
          config.config[moduleName] = config.config[id];
        }

        try {
          req.exec(text);
        } catch (e) {
          return onError(makeError(‘fromtexteval‘,
                                          ‘fromText eval for ‘ + id +
                                        ‘ failed: ‘ + e,
                                          e,
                                          [id]));
        }

        if (hasInteractive) {
          useInteractive = true;
        }

        //Mark this as a dependency for the plugin
        //resource
        this.depMaps.push(moduleMap);

        //Support anonymous modules.
        context.completeLoad(moduleName);

        //Bind the value of that module to the value for this
        //resource ID.
        localRequire([moduleName], load);
      });

      //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.
      plugin.load(map.name, localRequire, load, config);
    }));

    context.enable(pluginMap, this);
    this.pluginMaps[pluginMap.id] = pluginMap;
  },

  enable: function () {
    enabledRegistry[this.map.id] = this;
    this.enabled = true;

    //Set flag mentioning that the module is enabling,
    //so that immediate calls to the defined callbacks
    //for dependencies do not trigger inadvertent load
    //with the depCount still being zero.
    this.enabling = true;

    //Enable each dependency
    each(this.depMaps, bind(this, function (depMap, i) {
      var id, mod, handler;

      if (typeof depMap === ‘string‘) {
        //Dependency needs to be converted to a depMap
        //and wired up to this module.
        depMap = makeModuleMap(depMap,
                                            (this.map.isDefine ? this.map : this.map.parentMap),
                                            false,
                                            !this.skipMap);
        this.depMaps[i] = depMap;

        handler = getOwn(handlers, depMap.id);

        if (handler) {
          this.depExports[i] = handler(this);
          return;
        }

        this.depCount += 1;

        on(depMap, ‘defined‘, bind(this, function (depExports) {
          this.defineDep(i, depExports);
          this.check();
        }));

        if (this.errback) {
          on(depMap, ‘error‘, bind(this, this.errback));
        }
      }

      id = depMap.id;
      mod = registry[id];

      //Skip special modules like ‘require‘, ‘exports‘, ‘module‘
      //Also, don‘t call enable if it is already enabled,
      //important in circular dependency cases.
      if (!hasProp(handlers, id) && mod && !mod.enabled) {
        context.enable(depMap, this);
      }
    }));

    //Enable each plugin that is used in
    //a dependency
    eachProp(this.pluginMaps, bind(this, function (pluginMap) {
      var mod = getOwn(registry, pluginMap.id);
      if (mod && !mod.enabled) {
        context.enable(pluginMap, this);
      }
    }));

    this.enabling = false;

    this.check();
  },

  on: function (name, cb) {
    var cbs = this.events[name];
    if (!cbs) {
      cbs = this.events[name] = [];
    }
    cbs.push(cb);
  },

  emit: function (name, evt) {
    each(this.events[name], function (cb) {
      cb(evt);
    });
    if (name === ‘error‘) {
      //Now that the error handler was triggered, remove
      //the listeners, since this broken Module instance
      //can stay around for a while in the registry.
      delete this.events[name];
    }
  }
};

enable: function () {
  enabledRegistry[this.map.id] = this;
  this.enabled = true;

  //Set flag mentioning that the module is enabling,
  //so that immediate calls to the defined callbacks
  //for dependencies do not trigger inadvertent load
  //with the depCount still being zero.
  this.enabling = true;

  //Enable each dependency
  each(this.depMaps, bind(this, function (depMap, i) {
    var id, mod, handler;

    if (typeof depMap === ‘string‘) {
      //Dependency needs to be converted to a depMap
      //and wired up to this module.
      depMap = makeModuleMap(depMap,
                                          (this.map.isDefine ? this.map : this.map.parentMap),
                                          false,
                                          !this.skipMap);
      this.depMaps[i] = depMap;

      handler = getOwn(handlers, depMap.id);

      if (handler) {
        this.depExports[i] = handler(this);
        return;
      }

      this.depCount += 1;

      on(depMap, ‘defined‘, bind(this, function (depExports) {
        this.defineDep(i, depExports);
        this.check();
      }));

      if (this.errback) {
        on(depMap, ‘error‘, bind(this, this.errback));
      }
    }

    id = depMap.id;
    mod = registry[id];

    //Skip special modules like ‘require‘, ‘exports‘, ‘module‘
    //Also, don‘t call enable if it is already enabled,
    //important in circular dependency cases.
    if (!hasProp(handlers, id) && mod && !mod.enabled) {
      context.enable(depMap, this);
    }
  }));

  //Enable each plugin that is used in
  //a dependency
  eachProp(this.pluginMaps, bind(this, function (pluginMap) {
    var mod = getOwn(registry, pluginMap.id);
    if (mod && !mod.enabled) {
      context.enable(pluginMap, this);
    }
  }));

  this.enabling = false;

  this.check();
},

/**
* Checks if the module is ready to define itself, and if so,
* define it.
*/
check: function () {
  if (!this.enabled || this.enabling) {
    return;
  }

  var err, cjsModule,
              id = this.map.id,
              depExports = this.depExports,
              exports = this.exports,
              factory = this.factory;

  if (!this.inited) {
    this.fetch();
  } else if (this.error) {
    this.emit(‘error‘, this.error);
  } else if (!this.defining) {
    //The factory could trigger another require call
    //that would result in checking this module to
    //define itself again. If already in the process
    //of doing that, skip this work.
    this.defining = true;

    if (this.depCount < 1 && !this.defined) {
      if (isFunction(factory)) {
        //If there is an error listener, favor passing
        //to that instead of throwing an error. However,
        //only do it for define()‘d  modules. require
        //errbacks should not be called for failures in
        //their callbacks (#699). However if a global
        //onError is set, use that.
        if ((this.events.error && this.map.isDefine) ||
                          req.onError !== defaultOnError) {
          try {
            exports = context.execCb(id, factory, depExports, exports);
          } catch (e) {
            err = e;
          }
        } else {
          exports = context.execCb(id, factory, depExports, exports);
        }

        if (this.map.isDefine) {
          //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.
          cjsModule = this.module;
          if (cjsModule &&
                                  cjsModule.exports !== undefined &&
          //Make sure it is not already the exports value
                                  cjsModule.exports !== this.exports) {
            exports = cjsModule.exports;
          } else if (exports === undefined && this.usingExports) {
            //exports already set the defined value.
            exports = this.exports;
          }
        }

        if (err) {
          err.requireMap = this.map;
          err.requireModules = this.map.isDefine ? [this.map.id] : null;
          err.requireType = this.map.isDefine ? ‘define‘ : ‘require‘;
          return onError((this.error = err));
        }

      } else {
        //Just a literal value
        exports = factory;
      }

      this.exports = exports;

      if (this.map.isDefine && !this.ignore) {
        defined[id] = exports;

        if (req.onResourceLoad) {
          req.onResourceLoad(context, this.map, this.depMaps);
        }
      }

      //Clean up
      cleanRegistry(id);

      this.defined = true;
    }

    //Finished the define stage. Allow calling check again
    //to allow define notifications below in the case of a
    //cycle.
    this.defining = false;

    if (this.defined && !this.defineEmitted) {
      this.defineEmitted = true;
      this.emit(‘defined‘, this.exports);
      this.defineEmitComplete = true;
    }

  }
},