docs: function clock() {
      var applet,
          options = Benchmark.options,
          template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
          timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
  
      // lazy define for hi-res timers
      clock = function(clone) {
        var deferred;
        if (clone instanceof Deferred) {
          deferred = clone;
          clone = deferred.benchmark;
        }
  
        var bench = clone._original,
            fn = bench.fn,
            fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '',
            stringable = isStringable(fn);
  
        var source = {
          'setup': getSource(bench.setup, preprocess('m$.setup()')),
          'fn': getSource(fn, preprocess('f$(' + fnArg + ')')),
          'fnArg': fnArg,
          'teardown': getSource(bench.teardown, preprocess('m$.teardown()'))
        };
  
        var compiled = bench.compiled,
            count = bench.count = clone.count,
            decompilable = support.decompilation || stringable,
            id = bench.id,
            isEmpty = !(source.fn || stringable),
            name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
            ns = timer.ns,
            result = 0;
  
        // init `minTime` if needed
        clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime);
  
        // repair nanosecond timer
        // (some Chrome builds erase the `ns` variable after millions of executions)
        if (applet) {
          try {
            ns.nanoTime();
          } catch(e) {
            // use non-element to avoid issues with libs that augment them
            ns = timer.ns = new applet.Packages.nano;
          }
        }
  
        if (!compiled) {
          // compile in setup/teardown functions and the test loop
          compiled = bench.compiled = createFunction(preprocess('t$'), interpolate(
            preprocess(deferred
              ? 'var d$=this,#{fnArg}=d$,m$=d$.benchmark._original,f$=m$.fn,su$=m$.setup,td$=m$.teardown;' +
                // when `deferred.cycles` is `0` then...
                'if(!d$.cycles){' +
                // set `deferred.fn`
                'd$.fn=function(){var #{fnArg}=d$;if(typeof f$=="function"){try{#{fn}\n}catch(e$){f$(d$)}}else{#{fn}\n}};' +
                // set `deferred.teardown`
                'd$.teardown=function(){d$.cycles=0;if(typeof td$=="function"){try{#{teardown}\n}catch(e$){td$()}}else{#{teardown}\n}};' +
                // execute the benchmark's `setup`
                'if(typeof su$=="function"){try{#{setup}\n}catch(e$){su$()}}else{#{setup}\n};' +
                // start timer
                't$.start(d$);' +
                // execute `deferred.fn` and return a dummy object
                '}d$.fn();return{}'
  
              : 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count,n$=t$.ns;#{setup}\n#{begin};' +
                'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r$,uid:"#{uid}"}'),
            source
          ));
  
          try {
            if (isEmpty) {
              // Firefox may remove dead code from Function#toString results
              // http://bugzil.la/536085
              throw new Error('The test "' + name + '" is empty. This may be the result of dead code removal.');
            }
            else if (!deferred) {
              // pretest to determine if compiled code is exits early, usually by a
              // rogue `return` statement, by checking for a return object with the uid
              bench.count = 1;
              compiled = (compiled.call(bench, timer) || {}).uid == uid && compiled;
              bench.count = count;
            }
          } catch(e) {
            compiled = null;
            clone.error = e || new Error(String(e));
            bench.count = count;
          }
          // fallback when a test exits early or errors during pretest
          if (decompilable && !compiled && !deferred && !isEmpty) {
            compiled = createFunction(preprocess('t$'), interpolate(
              preprocess(
                (clone.error && !stringable
                  ? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count'
                  : 'function f$(){#{fn}\n}var r$,s$,m$=this,i$=m$.count'
                ) +
                ',n$=t$.ns;#{setup}\n#{begin};m$.f$=f$;while(i$--){m$.f$()}#{end};' +
                'delete m$.f$;#{teardown}\nreturn{elapsed:r$}'
              ),
              source
            ));
  
            try {
              // pretest one more time to check for errors
              bench.count = 1;
              compiled.call(bench, timer);
              bench.compiled = compiled;
              bench.count = count;
              delete clone.error;
            }
            catch(e) {
              bench.count = count;
              if (clone.error) {
                compiled = null;
              } else {
                bench.compiled = compiled;
                clone.error = e || new Error(String(e));
              }
            }
          }
        }
        // assign `compiled` to `clone` before calling in case a deferred benchmark
        // immediately calls `deferred.resolve()`
        clone.compiled = compiled;
        // if no errors run the full test loop
        if (!clone.error) {
          result = compiled.call(deferred || bench, timer).elapsed;
        }
        return result;
      };
  
      /*------------------------------------------------------------------------*/
  
      /**
       * Gets the current timer's minimum resolution (secs).
       */
      function getRes(unit) {
        var measured,
            begin,
            count = 30,
            divisor = 1e3,
            ns = timer.ns,
            sample = [];
  
        // get average smallest measurable time
        while (count--) {
          if (unit == 'us') {
            divisor = 1e6;
            if (ns.stop) {
              ns.start();
              while (!(measured = ns.microseconds())) { }
            } else if (perfName) {
              divisor = 1e3;
              measured = Function('n', 'var r,s=n.' + perfName + '();while(!(r=n.' + perfName + '()-s)){};return r')(ns);
            } else {
              begin = ns();
              while (!(measured = ns() - begin)) { }
            }
          }
          else if (unit == 'ns') {
            divisor = 1e9;
            begin = ns.nanoTime();
            while (!(measured = ns.nanoTime() - begin)) { }
          }
          else {
            begin = new ns;
            while (!(measured = new ns - begin)) { }
          }
          // check for broken timers (nanoTime may have issues)
          // http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
          if (measured > 0) {
            sample.push(measured);
          } else {
            sample.push(Infinity);
            break;
          }
        }
        // convert to seconds
        return getMean(sample) / divisor;
      }
  
      /**
       * Replaces all occurrences of `$` with a unique number and
       * template tokens with content.
       */
      function preprocess(code) {
        return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
      }
  
      /*------------------------------------------------------------------------*/
  
      // detect nanosecond support from a Java applet
      each(doc && doc.applets || [], function(element) {
        return !(timer.ns = applet = 'nanoTime' in element && element);
      });
  
      // check type in case Safari returns an object instead of a number
      try {
        if (typeof timer.ns.nanoTime() == 'number') {
          timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
        }
      } catch(e) { }
  
      // detect Chrome's microsecond timer:
      // enable benchmarking via the --enable-benchmarking command
      // line switch in at least Chrome 7 to use chrome.Interval
      try {
        if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
          timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
        }
      } catch(e) { }
  
      // detect `performance.now` microsecond resolution timer
      if ((timer.ns = perfName && perfObject)) {
        timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
      }
  
      // detect Node's microtime module:
      // npm install microtime
      if ((timer.ns = (req('microtime') || { 'now': 0 }).now)) {
        timers.push({ 'ns': timer.ns,  'res': getRes('us'), 'unit': 'us' });
      }
  
      // pick timer with highest resolution
      timer = reduce(timers, function(timer, other) {
        return other.res < timer.res ? other : timer;
      });
  
      // remove unused applet
      if (timer.unit != 'ns' && applet) {
        applet = destroyElement(applet);
      }
      // error if there are no working timers
      if (timer.res == Infinity) {
        throw new Error('Benchmark.js was unable to find a working timer.');
      }
      // use API of chosen timer
      if (timer.unit == 'ns') {
        extend(template, {
          'begin': 's$=n$.nanoTime()',
          'end': 'r$=(n$.nanoTime()-s$)/1e9'
        });
      }
      else if (timer.unit == 'us') {
        if (timer.ns.stop) {
          extend(template, {
            'begin': 's$=n$.start()',
            'end': 'r$=n$.microseconds()/1e6'
          });
        } else if (perfName) {
          extend(template, {
            'begin': 's$=n$.' + perfName + '()',
            'end': 'r$=(n$.' + perfName + '()-s$)/1e3'
          });
        } else {
          extend(template, {
            'begin': 's$=n$()',
            'end': 'r$=(n$()-s$)/1e6'
          });
        }
      }
  
      // define `timer` methods
      timer.start = createFunction(preprocess('o$'),
        preprocess('var n$=this.ns,#{begin};o$.elapsed=0;o$.timeStamp=s$'));
  
      timer.stop = createFunction(preprocess('o$'),
        preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.elapsed=r$'));
  
      // resolve time span required to achieve a percent uncertainty of at most 1%
      // http://spiff.rit.edu/classes/phys273/uncert/uncert.html
      options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
      return clock.apply(null, arguments);
    }