/**
                             * Optional automatic rollup logic for reducing http connections
                             * when not using a combo service.
                             * @module loader
                             * @submodule rollup
                             */
                            
                            /**
                             * Look for rollup packages to determine if all of the modules a
                             * rollup supersedes are required.  If so, include the rollup to
                             * help reduce the total number of connections required.  Called
                             * by calculate().  This is an optional feature, and requires the
                             * appropriate submodule to function.
                             * @method _rollup
                             * @for Loader
                             * @private
                             */
                            Y.Loader.prototype._rollup = function() {
                                var i, j, m, s, r = this.required, roll,
                                    info = this.moduleInfo, rolled, c, smod;
                            
                                // find and cache rollup modules
                                if (this.dirty || !this.rollups) {
                                    this.rollups = {};
                                    for (i in info) {
                                        if (info.hasOwnProperty(i)) {
                                            m = this.getModule(i);
                                            // if (m && m.rollup && m.supersedes) {
                                            if (m && m.rollup) {
                                                this.rollups[i] = m;
                                            }
                                        }
                                    }
                                }
                            
                                // make as many passes as needed to pick up rollup rollups
                                for (;;) {
                                    rolled = false;
                            
                                    // go through the rollup candidates
                                    for (i in this.rollups) {
                                        if (this.rollups.hasOwnProperty(i)) {
                                            // there can be only one, unless forced
                                            if (!r[i] && ((!this.loaded[i]) || this.forceMap[i])) {
                                                m = this.getModule(i);
                                                s = m.supersedes || [];
                                                roll = false;
                            
                                                // @TODO remove continue
                                                if (!m.rollup) {
                                                    continue;
                                                }
                            
                                                c = 0;
                            
                                                // check the threshold
                                                for (j = 0; j < s.length; j++) {
                                                    smod = info[s[j]];
                            
                                                    // if the superseded module is loaded, we can't
                                                    // load the rollup unless it has been forced.
                                                    if (this.loaded[s[j]] && !this.forceMap[s[j]]) {
                                                        roll = false;
                                                        break;
                                                    // increment the counter if this module is required.
                                                    // if we are beyond the rollup threshold, we will
                                                    // use the rollup module
                                                    } else if (r[s[j]] && m.type === smod.type) {
                                                        c++;
                                                        // Y.log("adding to thresh: " + c + ", " + s[j]);
                                                        roll = (c >= m.rollup);
                                                        if (roll) {
                                                            // Y.log("over thresh " + c + ", " + s[j]);
                                                            break;
                                                        }
                                                    }
                                                }
                            
                                                if (roll) {
                                                    // Y.log("adding rollup: " +  i);
                                                    // add the rollup
                                                    r[i] = true;
                                                    rolled = true;
                            
                                                    // expand the rollup's dependencies
                                                    this.getRequires(m);
                                                }
                                            }
                                        }
                                    }
                            
                                    // if we made it here w/o rolling up something, we are done
                                    if (!rolled) {
                                        break;
                                    }
                                }
                            };