(function (process){ 
global = this; 
global.process = process; 
global.global = global; 
global.GLOBAL = global; 
global.root = global; 
function removed(reason){ 
return function (){ 
throw new Error(reason)
} 
; 
} 
process.debug = removed("process.debug() has moved. Use require('sys') to bring it back."); 
process.error = removed("process.error() has moved. Use require('sys') to bring it back."); 
process.watchFile = removed("process.watchFile() has moved to fs.watchFile()"); 
process.unwatchFile = removed("process.unwatchFile() has moved to fs.unwatchFile()"); 
process.mixin = removed('process.mixin() has been removed.'); 
process.createChildProcess = removed("childProcess API has changed. See doc/api.txt."); 
process.inherits = removed("process.inherits() has moved to sys.inherits."); 
process._byteLength = removed("process._byteLength() has moved to Buffer.byteLength"); 
process.assert = function (x, msg){ 
if (!x) throw new Error(msg || "assertion error")
} 
; 
var writeError = process.binding('stdio').writeError; 
var evals = process.binding('evals'); 
var constants; 
function lazyConstants(){ 
if (!constants) constants = process.binding("constants"); 
return constants; 
} 
var nextTickQueue = [] ; 
process._tickCallback = function (){ 
var l = _AN_Read_length("length", nextTickQueue); 
if (l === 0) return ; 
try { 
for (var i = 0; 
i < l; i++ ){ 
nextTickQueue[i](); 
} 
} 
catch (e) { 
nextTickQueue.splice(0, i + 1); 
if (i + 1 < l) { 
process._needTickCallback(); 
} 
throw e
} 
nextTickQueue.splice(0, l); 
} 
; 
process.nextTick = function (callback){ 
nextTickQueue.push(callback); 
process._needTickCallback(); 
} 
; 
var internalModuleCache = { 
}
; 
var natives = process.binding('natives'); 
function requireNative(id){ 
if (internalModuleCache[id]) return internalModuleCache[id].exports; 
if (!natives[id]) throw new Error('No such native module ' + id)
var fn = evals.Script.runInThisContext("(function (module, exports, require) {" + natives[id] + "\n})", id + '.js'); 
var m = { 
id: id,
exports: { 
}
}
; 
fn(m, m.exports, requireNative); 
m.loaded = true ; 
internalModuleCache[id] = m; 
return m.exports; 
} 
var module = (function (){ 
var exports = { 
}
; 
var contextLoad = false ; 
if (+ process.env.NODE_MODULE_CONTEXTS > 0) contextLoad = true ; 
var moduleCache = { 
}
; 
function Module(id, parent){ 
this.id = id; 
this.exports = { 
}
; 
this.parent = parent; 
this.filename = null ; 
this.loaded = false ; 
this.exited = false ; 
this.children = [] ; 
} 
; 
var debugLevel = parseInt(process.env.NODE_DEBUG, 16); 
function debug(x){ 
if (debugLevel & 1) { 
process.binding('stdio').writeError(x + "\n"); 
} 
} 
var path = requireNative('path'); 
var modulePaths = [path.join(process.execPath, "..", "..", "lib", "node")] ; 
if (process.env.HOME) { 
modulePaths.unshift(path.join(process.env.HOME, ".node_libraries")); 
modulePaths.unshift(path.join(process.env.HOME, ".node_modules")); 
} 
if (process.env.NODE_PATH) { 
modulePaths = process.env.NODE_PATH.split(":").concat(modulePaths); 
} 
var extensions = { 
}
; 
var registerExtension = removed('require.registerExtension() removed. Use require.extensions instead'); 
function traverser(id, dirs){ 
var head = [] , inDir = [] , dirs = dirs.slice(), exts = Object.keys(extensions); 
return function next(){ 
var result = head.shift(); 
if (result) { 
return result; 
} 
var gen = inDir.shift(); 
if (gen) { 
head = gen(); 
return next(); 
} 
var dir = dirs.shift(); 
if (dir !== undefined) { 
function direct(ext){ 
return path.join(dir, id + ext); 
} 
function index(ext){ 
return path.join(dir, id, 'index' + ext); 
} 
inDir = [function (){ 
return exts.map(direct); 
} 
, function (){ 
return exts.map(index); 
} 
] ; 
head = [path.join(dir, id)] ; 
return next(); 
} 
} 
; 
} 
function findModulePath(request, paths){ 
var nextLoc = traverser(request, request.charAt(0) === '/'? [''] : paths); 
var fs = requireNative('fs'); 
var location, stats; 
while (_AN_Write_location('location', window, false , nextLoc())){ 
try { 
stats = fs.statSync(_AN_Read_location('location', window)); 
} 
catch (e) { 
continue ; 
} 
if (stats && !stats.isDirectory()) return _AN_Read_location('location', window); 
} 
return false ; 
} 
function resolveModuleLookupPaths(request, parent){ 
if (natives[request]) return [request, [] ] ; 
var start = request.substring(0, 2); 
if (start !== "./" && start !== "..") { 
return [request, modulePaths] ; 
} 
if (!parent || !parent.id || !parent.filename) { 
return [request, ['.'] .concat(modulePaths)] ; 
} 
var isIndex = /^index\.\w+?$/.test(path.basename(parent.filename)), parentIdPath = isIndex? parent.id: path.dirname(parent.id), id = path.join(parentIdPath, request); 
if (parentIdPath === '.' && id.indexOf('/') === -1) { 
id = './' + id; 
} 
debug("RELATIVE: requested:" + request + " set ID to: " + id + " from " + parent.id); 
return [id, [path.dirname(parent.filename)] ] ; 
} 
function loadModule(request, parent){ 
debug("loadModule REQUEST  " + (request) + " parent: " + parent.id); 
var resolved = resolveModuleFilename(request, parent); 
var id = resolved[0]; 
var filename = resolved[1]; 
if (natives[id]) { 
if (id == 'repl') { 
var replModule = new Module("repl"); 
replModule._compile(natives.repl, 'repl.js'); 
internalModuleCache.repl = replModule; 
return replModule.exports; 
} 
debug('load native module ' + request); 
return requireNative(id); 
} 
var cachedModule = moduleCache[filename]; 
if (cachedModule) return cachedModule.exports; 
var module = new Module(id, parent); 
moduleCache[filename] = module; 
_AN_Call_load('load', module, filename); 
return module.exports; 
} 
; 
function resolveModuleFilename(request, parent){ 
if (natives[request]) return [request, request] ; 
var resolvedModule = resolveModuleLookupPaths(request, parent), id = resolvedModule[0], paths = resolvedModule[1]; 
debug("looking for " + JSON.stringify(id) + " in " + JSON.stringify(paths)); 
var filename = findModulePath(request, paths); 
if (!filename) { 
throw new Error("Cannot find module '" + request + "'")
} 
return [id, filename] ; 
} 
Module.prototype.load = function (filename){ 
debug("load " + JSON.stringify(filename) + " for module " + JSON.stringify(this.id)); 
process.assert(!this.loaded); 
this.filename = filename; 
var extension = path.extname(filename) || '.js'; 
if (!extensions[extension]) extension = '.js'; 
extensions[extension](this, filename); 
this.loaded = true ; 
} 
; 
Module.prototype._compile = function (content, filename){ 
var self = this; 
content = _AN_Call_replace('replace', content, /^\#\!.*/, ''); 
function require(path){ 
return loadModule(path, self); 
} 
require.resolve = function (request){ 
return resolveModuleFilename(request, self)[1]; 
} 
; 
require.paths = modulePaths; 
require.main = process.mainModule; 
require.extensions = extensions; 
require.registerExtension = registerExtension; 
require.cache = moduleCache; 
var dirname = path.dirname(filename); 
if (contextLoad) { 
if (self.id !== ".") { 
debug('load submodule'); 
var sandbox = { 
}
; 
for (var k in global){ 
sandbox[k] = global[k]; 
} 
sandbox.require = require; 
sandbox.exports = self.exports; 
sandbox.__filename = filename; 
sandbox.__dirname = dirname; 
sandbox.module = self; 
sandbox.global = sandbox; 
sandbox.root = root; 
return evals.Script.runInNewContext(content, sandbox, filename); 
} 
 else { 
debug('load root module'); 
global.require = require; 
global.exports = self.exports; 
global.__filename = filename; 
global.__dirname = dirname; 
global.module = self; 
return evals.Script.runInThisContext(content, filename); 
} 
} 
 else { 
var wrapper = "(function (exports, require, module, __filename, __dirname) { " + content + "\n});"; 
var compiledWrapper = evals.Script.runInThisContext(wrapper, filename); 
if (filename === process.argv[1] && global.v8debug) { 
global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0); 
} 
return compiledWrapper.apply(self.exports, [self.exports, require, self, filename, dirname] ); 
} 
} 
; 
extensions[".js"]  = function (module, filename){ 
var content = requireNative('fs').readFileSync(filename, 'utf8'); 
module._compile(content, filename); 
} 
; 
extensions[".node"]  = function (module, filename){ 
process.dlopen(filename, module.exports); 
} 
; 
exports.runMain = function (){ 
process.mainModule = new Module("."); 
try { 
_AN_Call_load("load", process.mainModule, process.argv[1]); 
} 
catch (e) { 
if (e.errno == lazyConstants().ENOENT) { 
console.error("Cannot load '%s'", process.argv[1]); 
process.exit(1); 
} 
 else { 
throw e
} 
} 
} 
; 
exports.requireRepl = function (){ 
return loadModule("repl", "."); 
} 
; 
exports.Module = Module; 
return exports; 
} 
)(); 
var events = requireNative('events'); 
(function (){ 
var signalWatchers = { 
}
; 
var addListener = process.addListener; 
var removeListener = process.removeListener; 
function isSignal(event){ 
return event.slice(0, 3) === 'SIG' && lazyConstants()[event]; 
} 
process.on = process.addListener = function (type, listener){ 
var ret = addListener.apply(this, arguments); 
if (isSignal(type)) { 
if (!signalWatchers.hasOwnProperty(type)) { 
var b = process.binding('signal_watcher'); 
var w = new b.SignalWatcher(lazyConstants()[type]); 
w.callback = function (){ 
process.emit(type); 
} 
; 
signalWatchers[type] = w; 
w.start(); 
} 
 else if (_AN_Read_length('length', this.listeners(type)) === 1) { 
signalWatchers[event].start(); 
} 
} 
return ret; 
} 
; 
process.removeListener = function (type, listener){ 
var ret = removeListener.apply(this, arguments); 
if (isSignal(type)) { 
process.assert(signalWatchers.hasOwnProperty(type)); 
if (_AN_Read_length('length', this.listeners(type)) === 0) { 
signalWatchers[type].stop(); 
} 
} 
return ret; 
} 
; 
} 
)(); 
global.setTimeout = function (){ 
var t = requireNative('timers'); 
return t.setTimeout.apply(this, arguments); 
} 
; 
global.setInterval = function (){ 
var t = requireNative('timers'); 
return t.setInterval.apply(this, arguments); 
} 
; 
global.clearTimeout = function (){ 
var t = requireNative('timers'); 
return t.clearTimeout.apply(this, arguments); 
} 
; 
global.clearInterval = function (){ 
var t = requireNative('timers'); 
return t.clearInterval.apply(this, arguments); 
} 
; 
var stdout; 
process.__defineGetter__('stdout', function (){ 
if (stdout) return stdout; 
var binding = process.binding('stdio'), net = requireNative('net'), fs = requireNative('fs'), fd = binding.stdoutFD; 
if (binding.isStdoutBlocking()) { 
stdout = new fs.WriteStream(null , { 
fd: fd}
); 
} 
 else { 
stdout = new net.Stream(fd); 
stdout.readable = false ; 
} 
return stdout; 
} 
); 
var stdin; 
process.openStdin = function (){ 
if (stdin) return stdin; 
var binding = process.binding('stdio'), net = requireNative('net'), fs = requireNative('fs'), fd = binding.openStdin(); 
if (binding.isStdinBlocking()) { 
stdin = new fs.ReadStream(null , { 
fd: fd}
); 
} 
 else { 
stdin = new net.Stream(fd); 
stdin.readable = true ; 
} 
stdin.resume(); 
return stdin; 
} 
; 
var formatRegExp = /%[sdj]/g; 
function format(f){ 
if (typeof f !== 'string') { 
var objects = [] , util = requireNative('util'); 
for (var i = 0; 
i < _AN_Read_length('length', arguments); i++ ){ 
objects.push(util.inspect(arguments[i])); 
} 
return objects.join(' '); 
} 
var i = 1; 
var args = arguments; 
var str = _AN_Call_replace('replace', String(f), formatRegExp, function (x){ 
switch (x){ 
case '%s': return args[i++ ]; 
case '%d': return + args[i++ ]; 
case '%j': return JSON.stringify(args[i++ ]); 
default : { 
return x; 
} 
} 
} 
); 
for (var len = _AN_Read_length('length', args); 
i < len; ++i){ 
str += ' ' + args[i]; 
} 
return str; 
} 
global.console = { 
}
; 
global.console.log = function (){ 
_AN_Call_write('write', process.stdout, format.apply(this, arguments) + '\n'); 
} 
; 
global.console.info = global.console.log; 
global.console.warn = function (){ 
writeError(format.apply(this, arguments) + '\n'); 
} 
; 
global.console.error = global.console.warn; 
global.console.dir = function (object){ 
var util = requireNative('util'); 
_AN_Call_write('write', process.stdout, util.inspect(object) + '\n'); 
} 
; 
var times = { 
}
; 
global.console.time = function (label){ 
times[label] = Date.now(); 
} 
; 
global.console.timeEnd = function (label){ 
var duration = Date.now() - times[label]; 
global.console.log('%s: %dms', label, duration); 
} 
; 
global.console.trace = function (label){ 
var err = new Error(); 
err.name = 'Trace'; 
err.message = label || ''; 
Error.captureStackTrace(err, arguments.callee); 
console.error(err.stack); 
} 
; 
global.console.assert = function (expression){ 
if (!expression) { 
var arr = Array.prototype.slice.call(arguments, 1); 
process.assert(false , format.apply(this, arr)); 
} 
} 
; 
global.Buffer = requireNative('buffer').Buffer; 
process.exit = function (code){ 
process.emit("exit", code || 0); 
process.reallyExit(code || 0); 
} 
; 
process.kill = function (pid, sig){ 
sig = sig || 'SIGTERM'; 
if (!lazyConstants()[sig]) throw new Error("Unknown signal: " + sig)
process._kill(pid, lazyConstants()[sig]); 
} 
; 
var cwd = process.cwd(); 
var path = requireNative('path'); 
if (process.argv[0].indexOf('/') > 0) { 
process.argv[0] = path.join(cwd, process.argv[0]); 
} 
if (process.argv[1]) { 
if (process.argv[1].charAt(0) != "/" && !(/^http:\/\//).exec(process.argv[1])) { 
process.argv[1] = path.join(cwd, process.argv[1]); 
} 
process.nextTick(module.runMain); 
} 
 else if (process._eval) { 
var rv = new module.Module()._compile('return eval(process._eval)', 'eval'); 
console.log(rv); 
} 
 else { 
module.requireRepl().start(); 
} 
} 
);