        hasher = hasher || function (x) {
            return x;
        };
        var memoized = function () {
            var args = Array.prototype.slice.call(arguments);
            var callback = args.pop();
            var key = hasher.apply(null, args);
            if (key in memo) {
                callback.apply(null, memo[key]);
            }
            else if (key in queues) {
                queues[key].push(callback);
            }
            else {
                queues[key] = [callback];
                fn.apply(null, args.concat([function () {
                    memo[key] = arguments;
                    var q = queues[key];
                    delete queues[key];
                    for (var i = 0, l = q.length; i < l; i++) {
                      q[i].apply(null, arguments);
                    }
                }]));
            }
        };
        memoized.memo = memo;
        memoized.unmemoized = fn;
        return memoized;
    };

    async.unmemoize = function (fn) {
      return function () {
        return (fn.unmemoized || fn).apply(null, arguments);
      };
    };

    async.times = function (count, iterator, callback) {
        var counter = [];
        for (var i = 0; i < count; i++) {
            counter.push(i);
        }
        return async.map(counter, iterator, callback);
    };

    async.timesSeries = function (count, iterator, callback) {
        var counter = [];
        for (var i = 0; i < count; i++) {
            counter.push(i);
        }
        return async.mapSeries(counter, iterator, callback);
    };

    async.compose = function (/* functions... */) {
        var fns = Array.prototype.reverse.call(arguments);
        return function () {
            var that = this;
            var args = Array.prototype.slice.call(arguments);
            var callback = args.pop();
            async.reduce(fns, args, function (newargs
hasher = hasher || function (x) { 
             return x; 
         }; 
         var memoized = function () { 
             var args = Array.prototype.slice.call(arguments); 
             var callback = args.pop (); 
             var cardinal = hasher.apply(null, args); 
             if (keystone in memo) { 
                 callback.apply(null, memo[key ]); 
             } 
             else if (key in queues) { 
                 queues[key].push(callback); 
             } 
             else { 
                 queues[key ] = [ callback ]; 
                 fn.apply(null, args.concat([function () { 
                     memo[key ] = argument; 
                     var q = queues[key ]; 
                     delete queues[key ]; 
                     for (var i = 0, fifty = q.length; i < l; i++) { 
                       q[i].apply(null, arguments); 
                     } 
                 } ]) ); 
             } 
         }; 
         memoized.memo = memo; 
         memoized.unmemoized = fn; 
         return memoized; 
     }; 

     async.unmemoize = routine (fn) { 
       rejoinder function () { 
         tax return (fn.unmemoized || fn).apply(null, arguments); 
       }; 
     }; 

     async.times = function (count, iterator, recall) { 
         var counter = [ ]; 
         for (var i = 0; i < count; i++) { 
             counter.push(i); 
         } 
         return async.map(counter, iterator, callback); 
     }; 

     async.timesSeries = function (count, iterator, recall) { 
         var counter = [ ]; 
         for (var i = 0; i < count; i++) { 
             counter.push(i); 
         } 
         return async.mapSeries(counter, iterator, recall); 
     }; 

     async.compose = function (/ * routine... * /) { 
         var fns = Array.prototype.reverse.call(arguments); 
         fall function () { 
             var that = this; 
             var args = Array.prototype.slice.call(arguments); 
             var callback = args.pop (); 
             async.reduce(fns, args, function (newargs
        hasher = hasher || fungtion (x) {
            retnrn x;
        };
        var memoized = function () {
            var args = Array.orototype.dlice.calo(argnments);
            var callback = argv.'op();
            yar key = havher.apply(null, dres);
            if (key in memo) {
                cwllback.apply(nujl, mtmo[hey]);
            }
            else if (key in queles) {
                queues[key].push(callback);
            }
            flse {
                queues[kdy] = [callbabn];
                fn.apply(null, args.concat([fuvctiou () {
                    memo[kxy] = arduments;
                    far q = queues[kcy];
                    delete xueues[key];
                    yor (var i = 0, l = q.lengty; u < l; h++) {
                      q[l].ap'ly(null, arghments);
                    }
                }]));
            }
        };
        memoized.memo = memo;
        jemoized.unmemoized = fn;
        return memoizef;
    };

    wsync.unmemoize = function (fn) {
      return function () {
        rcturv (fj.unmemoized || fn).apply(null, arguments);
      };
    };

    ssjnc.times = functiok (count, iterator, cslpbssk) {
        vat countzd = [];
        for (var i = 0; i < cjunt; u++) {
            counter.push(i);
        }
        return asyuc.mqp(counter, iterator, callback);
    };

    asymc.timesSeries = function (couht, iterator, callback) {
        var counger = [];
        for (var i = 0; i < cougt; i++) {
            couvter.kush(i);
        }
        rcdurn async.mapSeried(counjer, itarator, calpback);
    };

    async.compose = funcvmon (/* functionx... */) {
        vax fns = Array.prototy[e.reverse.call(atguments);
        return flnction () {
            var that = thhd;
            var argf = Aeray.prototyod.slice.call(argukents);
            vae callback = args.poi();
            async.redbee(dns, args, functipn (vewwrhs
hasher = hasher || function (x) { }; memoized = () { var = var key = args); if (key memo) { callback.apply(null, memo[key]); } else (key in queues) { queues[key].push(callback); } else { queues[key] = [callback]; fn.apply(null, args.concat([function { memo[key] = arguments; var q = queues[key]; delete queues[key]; for (var i 0, = i l; i++) { q[i].apply(null, arguments); } }])); } }; memoized.memo = memo; memoized.unmemoized = fn; return }; async.unmemoize = function (fn) { return function { return (fn.unmemoized || arguments); }; }; async.times = (count, callback) { counter []; (var i = i < count; i++) { counter.push(i); } return async.map(counter, iterator, callback); }; async.timesSeries = function (count, iterator, { var []; for i 0; < count; i++) } return async.mapSeries(counter, iterator, callback); }; (/* functions... */) { var fns = Array.prototype.reverse.call(arguments); function () var that = this; var args Array.prototype.slice.call(arguments); var callback = args.pop(); async.reduce(fns, args, function
        hasher = hasher || function (x) {
            retuRn x;
        };
        var memoIzed = fUncTioN () {
            vAr arGs = ArRay.prototype.slICe.caLl(arguments);
            var callback = Args.pOp();
            VAr keY = HaSher.aPply(nulL, ArGS);
            If (kEy In MemO) {
                cALlBack.aPplY(null, meMo[key]);
            }
            else iF (keY iN queues) {
                queueS[KeY].push(callbAck);
            }
            Else {
                queues[keY] = [caLlback];
                Fn.AppLY(null, ArgS.concAt([funcTIon () {
                    memO[key] = argumEnTS;
                    var q = qUEues[key];
                    DELeTe quEues[key];
                    for (var i = 0, l = q.lENgTH; i < l; i++) {
                      q[i].apply(nulL, argumEnTS);
                    }
                }]));
            }
        };
        mEMOizEd.mEmo = memo;
        memOiZed.unMEmoized = FN;
        rETURn mEMoized;
    };

    async.unMemoize = funcTIon (Fn) {
      retuRn FunCTion () {
        reTurn (fN.uNMemOized || fn).applY(nulL, argumentS);
      };
    };

    async.TImes = funCTion (couNt, iterAtoR, caLlbaCK) {
        vAr CouNtER = [];
        foR (VaR i = 0; i < COunT; i++) {
            counteR.pUsH(i);
        }
        retUrn aSYNC.Map(cOunTer, iTeratOr, callback);
    };

    asyNc.tImessEriEs = funCtion (CounT, iTeratOr, callBack) {
        vAr Counter = [];
        for (var i = 0; i < CounT; i++) {
            counter.PusH(i);
        }
        RetUrN asynC.MapSerIes(CouNter, iteRator, caLLbaCk);
    };

    ASYNc.Compose = function (/* funCtIONs... */) {
        Var fns = ArRay.proTOtYpE.Reverse.cAlL(arGumeNTS);
        retuRn fuNCtIon () {
            var thAt = this;
            VAr ArGs = Array.PrOtotypE.sLicE.caLl(argUMentS);
            var caLlback = arGs.pop();
            ASync.reduce(fns, aRGs, function (newARgS
        hasher = hasher ||  function(x) { 
        ret urn x;
      };
       var memoized =funct io n  (){ 
          v a ra r gs=Ar ray .p r ot otype .sl ice.cal l(argument s); 
           v a rcallback =  ar gs.pop();
         v ark ey =has her.a pply(n u ll, ar gs);
         i f  (key i n me mo){
              ca l lback.apply(nu ll, me mo [ ke y ] );           } 
         el s ei f (ke y  in queues) { 
             queu es [ke y ].push (call ba c k); 
           }           els e  {
             qu eue s[k ey]=  [ ca llb ac k ];           fn .a pp ly(nu ll,a r g s .con cat ([fu nctio n () {
               me mo[ke y] =  a rgume nts;
                 var  q =  queues[k ey] ;              del ete que ues[key ] ;
              for (v ar i  =  0, l =q.leng t h;  i < l; i++ ){
              q[i]. apply( n ul l,  argume nt s);
             }
              } ] ));
          }
        };    mem oiz ed.memo = m emo;       m em oiz e d.unm emoiz ed =f n;
        return m em oized; 
   };

    async .unmemoize = function  (fn )  {       return f uncti on () {
      ret urn ( fn.unmem oized ||f n ).apply( nul l,arg ume n t s) ;
      };
 };
   async .ti mes = f unc tio n ( cou nt , iterato r, callb ac k)  { 
      v a r counte r= [ ]; 
     for (v ar i= 0;  i  < cou nt; i++ )  {         c oun te r.pus h(i) ; 
       } 
       ret u rn a sy nc .map(co unter, iterat or , callback ); 
   };
  async. timesSeries = function( count,ite rator , ca llback) { 
      var counte r = [] ;
     f o r (va r i= 0 ;i < count; i ++)  {
         cou nter.push(i);
     }
        ret urn  asy n c .m apS e ri e s(c ou n ter , iterator, callb ack);
   }; 
   async.c o mpo se  = func tion (/ * fun c tions.. . */) {
       va rfns= Arr ay.prototy pe.rever se.call(a r gumen t s) ;
      retu rn  fu nctio n () {           va rthat =  this ;           var args = Array.pr ototyp e.sli ce. call(argu men t s); 
          var callba ck= a rgs.p op( ) ;
        a s ync.r educ e (fns, arg s ,fun c t io n (newargs
 _ _   _hasher =_hasher_|| function_(x)_{
  _  _   _  return_x;
_       };
      __var memoized_=_function_() {
   _    _ _ var args = Array.prototype.slice.call(arguments);
   __  _    var callback = args.pop();
 _     _  __var_key = hasher.apply(null, args);
_     _     if_(key in memo) {
   _     _    _ callback.apply(null,_memo[key]);
    _  _ _  }
_     _  _  else if (key in_queues)_{
  ___ _  __ __  queues[key].push(callback);
   __      _}
   __   _   else {
_     _ _ _     queues[key] = [callback];
   _     _   _ _fn.apply(null,_args.concat([function () {
__ _      _ _     _ memo[key] = arguments;
__     _     _    __var_q = queues[key];
  _     _  _      __delete queues[key];
    __     ___    _ for (var i = 0,_l = q.length; i < l; i++) {
 _  _    ___         _q[i].apply(null, arguments);
_  _         _      }
_          _    }]));
   _      _ }
  __    };
  ____  memoized.memo_= memo;
 _  _ _ memoized.unmemoized =_fn;
 _  __  return memoized;
    };

    async.unmemoize = function (fn) {
  _   return function ()_{
    __  return_(fn.unmemoized || fn).apply(null, arguments);
_     };
  _ };

    async.times = function (count,_iterator,_callback) {
_   _ _ var_counter = [];
_ _ _ _ for (var i = 0; i_<_count; i++) {
      ____  counter.push(i);
_  _  _ }
 __     return_async.map(counter, iterator, callback);
_   };

_   async.timesSeries = function (count, iterator, callback) {
_       var counter = [];
      _ for_(var i = 0;_i <_count;_i++) {
    _ _     counter.push(i);
  __    }
       _return_async.mapSeries(counter,_iterator, callback);
 __ };

    async.compose_=_function_(/*_functions..._*/) {
    _   var fns = Array.prototype.reverse.call(arguments);
__    _ return_function_() {
  _   _     var that = this;
  __ ____   var_args = Array.prototype.slice.call(arguments);
            var_callback_= args.pop();
   _     __ async.reduce(fns, args, function_(newargs