text: 
  // CommonJS require()
  
  function require(p){
      if ('fs' == p) return {};
      var path = require.resolve(p)
        , mod = require.modules[path];
      if (!mod) throw new Error('failed to require "' + p + '"');
      if (!mod.exports) {
        mod.exports = {};
        mod.call(mod.exports, mod, mod.exports, require.relative(path));
      }
      return mod.exports;
    }
  
  require.modules = {};
  
  require.resolve = function (path){
      var orig = path
        , reg = path + '.js'
        , index = path + '/index.js';
      return require.modules[reg] && reg
        || require.modules[index] && index
        || orig;
    };
  
  require.register = function (path, fn){
      require.modules[path] = fn;
    };
  
  require.relative = function (parent) {
      return function(p){
        if ('.' != p.substr(0, 1)) return require(p);
        
        var path = parent.split('/')
          , segs = p.split('/');
        path.pop();
        
        for (var i = 0; i < segs.length; i++) {
          var seg = segs[i];
          if ('..' == seg) path.pop();
          else if ('.' != seg) path.push(seg);
        }
  
        return require(path.join('/'));
      };
    };
  
  
  require.register("ejs.js", function(module, exports, require){
  
  /*!
   * EJS
   * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
   * MIT Licensed
   */
  
  /**
   * Module dependencies.
   */
  
  var utils = require('./utils')
    , fs = require('fs');
  
  /**
   * Library version.
   */
  
  exports.version = '0.6.1';
  
  /**
   * Filters.
   * 
   * @type Object
   */
  
  var filters = exports.filters = require('./filters');
  
  /**
   * Intermediate js cache.
   * 
   * @type Object
   */
  
  var cache = {};
  
  /**
   * Clear intermediate js cache.
   *
   * @api public
   */
  
  exports.clearCache = function(){
    cache = {};
  };
  
  /**
   * Translate filtered code into function calls.
   *
   * @param {String} js
   * @return {String}
   * @api private
   */
  
  function filtered(js) {
    return js.substr(1).split('|').reduce(function(js, filter){
      var parts = filter.split(':')
        , name = parts.shift()
        , args = parts.shift() || '';
      if (args) args = ', ' + args;
      return 'filters.' + name + '(' + js + args + ')';
    });
  };
  
  /**
   * Re-throw the given `err` in context to the
   * `str` of ejs, `filename`, and `lineno`.
   *
   * @param {Error} err
   * @param {String} str
   * @param {String} filename
   * @param {String} lineno
   * @api private
   */
  
  function rethrow(err, str, filename, lineno){
    var lines = str.split('\n')
      , start = Math.max(lineno - 3, 0)
      , end = Math.min(lines.length, lineno + 3);
  
    // Error context
    var context = lines.slice(start, end).map(function(line, i){
      var curr = i + start + 1;
      return (curr == lineno ? ' >> ' : '    ')
        + curr
        + '| '
        + line;
    }).join('\n');
  
    // Alter exception message
    err.path = filename;
    err.message = (filename || 'ejs') + ':' 
      + lineno + '\n' 
      + context + '\n\n' 
      + err.message;
    
    throw err;
  }
  
  /**
   * Parse the given `str` of ejs, returning the function body.
   *
   * @param {String} str
   * @return {String}
   * @api public
   */
  
  var parse = exports.parse = function(str, options){
    var options = options || {}
      , open = options.open || exports.open || '<%'
      , close = options.close || exports.close || '%>';
  
    var buf = [
        "var buf = [];"
      , "\nwith (locals) {"
      , "\n  buf.push('"
    ];
    
    var lineno = 1;
  
    for (var i = 0, len = str.length; i < len; ++i) {
      if (str.slice(i, open.length + i) == open) {
        i += open.length
    
        var prefix, postfix, line = '__stack.lineno=' + lineno;
        switch (str.substr(i, 1)) {
          case '=':
            prefix = "', escape((" + line + ', ';
            postfix = ")), '";
            ++i;
            break;
          case '-':
            prefix = "', (" + line + ', ';
            postfix = "), '";
            ++i;
            break;
          default:
            prefix = "');" + line + ';';
            postfix = "; buf.push('";
        }
  
        var end = str.indexOf(close, i)
          , js = str.substring(i, end)
          , start = i
          , n = 0;
  
        while (~(n = js.indexOf("\n", n))) n++, lineno++;
        if (js.substr(0, 1) == ':') js = filtered(js);
        buf.push(prefix, js, postfix);
        i += end - start + close.length - 1;
  
      } else if (str.substr(i, 1) == "\\") {
        buf.push("\\\\");
      } else if (str.substr(i, 1) == "'") {
        buf.push("\\'");
      } else if (str.substr(i, 1) == "\r") {
        buf.push(" ");
      } else if (str.substr(i, 1) == "\n") {
        buf.push("\\n");
        lineno++;
      } else {
        buf.push(str.substr(i, 1));
      }
    }
  
    buf.push("');\n}\nreturn buf.join('');");
    return buf.join('');
  };
  
  /**
   * Compile the given `str` of ejs into a `Function`.
   *
   * @param {String} str
   * @param {Object} options
   * @return {Function}
   * @api public
   */
  
  var compile = exports.compile = function(str, options){
    options = options || {};
    
    var input = JSON.stringify(str)
      , filename = options.filename
          ? JSON.stringify(options.filename)
          : 'undefined';
    
    // Adds the fancy stack trace meta info
    str = [
      'var __stack = { lineno: 1, input: ' + input + ', filename: ' + filename + ' };',
      rethrow.toString(),
      'try {',
      exports.parse(str, options),
      '} catch (err) {',
      '  rethrow(err, __stack.input, __stack.filename, __stack.lineno);',
      '}'
    ].join("\n");
    
    if (options.debug) console.log(str);
    var fn = new Function('locals, filters, escape', str);
    return function(locals){
      return fn.call(this, locals, filters, utils.escape);
    }
  };
  
  /**
   * Render the given `str` of ejs.
   *
   * Options:
   *
   *   - `locals`          Local variables object
   *   - `cache`           Compiled functions are cached, requires `filename`
   *   - `filename`        Used by `cache` to key caches
   *   - `scope`           Function execution context
   *   - `debug`           Output generated function body
   *   - `open`            Open tag, defaulting to "<%"
   *   - `close`           Closing tag, defaulting to "%>"
   *
   * @param {String} str
   * @param {Object} options
   * @return {String}
   * @api public
   */
  
  exports.render = function(str, options){
    var fn
      , options = options || {};
  
    if (options.cache) {
      if (options.filename) {
        fn = cache[options.filename] || (cache[options.filename] = compile(str, options));
      } else {
        throw new Error('"cache" option requires "filename".');
      }
    } else {
      fn = compile(str, options);
    }
  
    options.__proto__ = options.locals;
    return fn.call(options.scope, options);
  };
  
  /**
   * Render an EJS file at the given `path` and callback `fn(err, str)`.
   *
   * @param {String} path
   * @param {Object|Function} options or callback
   * @param {Function} fn
   * @api public
   */
  
  exports.renderFile = function(path, options, fn){
    var key = path + ':string';
  
    if ('function' == typeof options) {
      fn = options, options = {};
    }
  
    options.filename = path;
  
    try {
      var str = options.cache
        ? exports.cache[key] || (exports.cache[key] = fs.readFileSync(path, 'utf8'))
        : fs.readFileSync(path, 'utf8');
  
      fn(null, exports.render(str, options));
    } catch (err) {
      fn(err);
    }
  };
  
  // express support
  
  exports.__express = exports.renderFile;
  
  /**
   * Expose to require().
   */
  
  if (require.extensions) {
    require.extensions['.ejs'] = function(module, filename) {
      source = require('fs').readFileSync(filename, 'utf-8');
      module._compile(compile(source, {}), filename);
    };
  } else if (require.registerExtension) {
    require.registerExtension('.ejs', function(src) {
      return compile(src, {});
    });
  }
  
  }); // module: ejs.js
  
  require.register("filters.js", function(module, exports, require){
  
  /*!
   * EJS - Filters
   * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
   * MIT Licensed
   */
  
  /**
   * First element of the target `obj`.
   */
  
  exports.first = function(obj) {
    return obj[0];
  };
  
  /**
   * Last element of the target `obj`.
   */
  
  exports.last = function(obj) {
    return obj[obj.length - 1];
  };
  
  /**
   * Capitalize the first letter of the target `str`.
   */
  
  exports.capitalize = function(str){
    str = String(str);
    return str[0].toUpperCase() + str.substr(1, str.length);
  };
  
  /**
   * Downcase the target `str`.
   */
  
  exports.downcase = function(str){
    return String(str).toLowerCase();
  };
  
  /**
   * Uppercase the target `str`.
   */
  
  exports.upcase = function(str){
    return String(str).toUpperCase();
  };
  
  /**
   * Sort the target `obj`.
   */
  
  exports.sort = function(obj){
    return Object.create(obj).sort();
  };
  
  /**
   * Sort the target `obj` by the given `prop` ascending.
   */
  
  exports.sort_by = function(obj, prop){
    return Object.create(obj).sort(function(a, b){
      a = a[prop], b = b[prop];
      if (a > b) return 1;
      if (a < b) return -1;
      return 0;
    });
  };
  
  /**
   * Size or length of the target `obj`.
   */
  
  exports.size = exports.length = function(obj) {
    return obj.length;
  };
  
  /**
   * Add `a` and `b`.
   */
  
  exports.plus = function(a, b){
    return Number(a) + Number(b);
  };
  
  /**
   * Subtract `b` from `a`.
   */
  
  exports.minus = function(a, b){
    return Number(a) - Number(b);
  };
  
  /**
   * Multiply `a` by `b`.
   */
  
  exports.times = function(a, b){
    return Number(a) * Number(b);
  };
  
  /**
   * Divide `a` by `b`.
   */
  
  exports.divided_by = function(a, b){
    return Number(a) / Number(b);
  };
  
  /**
   * Join `obj` with the given `str`.
   */
  
  exports.join = function(obj, str){
    return obj.join(str || ', ');
  };
  
  /**
   * Truncate `str` to `len`.
   */
  
  exports.truncate = function(str, len){
    str = String(str);
    return str.substr(0, len);
  };
  
  /**
   * Truncate `str` to `n` words.
   */
  
  exports.truncate_words = function(str, n){
    var str = String(str)
      , words = str.split(/ +/);
    return words.slice(0, n).join(' ');
  };
  
  /**
   * Replace `pattern` with `substitution` in `str`.
   */
  
  exports.replace = function(str, pattern, substitution){
    return String(str).replace(pattern, substitution || '');
  };
  
  /**
   * Prepend `val` to `obj`.
   */
  
  exports.prepend = function(obj, val){
    return Array.isArray(obj)
      ? [val].concat(obj)
      : val + obj;
  };
  
  /**
   * Append `val` to `obj`.
   */
  
  exports.append = function(obj, val){
    return Array.isArray(obj)
      ? obj.concat(val)
      : obj + val;
  };
  
  /**
   * Map the given `prop`.
   */
  
  exports.map = function(arr, prop){
    return arr.map(function(obj){
      return obj[prop];
    });
  };
  
  /**
   * Reverse the given `obj`.
   */
  
  exports.reverse = function(obj){
    return Array.isArray(obj)
      ? obj.reverse()
      : String(obj).split('').reverse().join('');
  };
  
  /**
   * Get `prop` of the given `obj`.
   */
  
  exports.get = function(obj, prop){
    return obj[prop];
  };
  
  /**
   * Packs the given `obj` into json string
   */
  exports.json = function(obj){
    return JSON.stringify(obj);
  };
  }); // module: filters.js
  
  require.register("utils.js", function(module, exports, require){
  
  /*!
   * EJS
   * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
   * MIT Licensed
   */
  
  /**
   * Escape the given string of `html`.
   *
   * @param {String} html
   * @return {String}
   * @api private
   */
  
  exports.escape = function(html){
    return String(html)
      .replace(/&(?!\w+;)/g, '&amp;')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;')
      .replace(/"/g, '&quot;');
  };
   
  }); // module: utils.js