Godeps, vendor: convert dependency management to trash (#3198)

This commit converts the dependency management from Godeps to the vendor
folder, also switching the tool from godep to trash. Since the upstream tool
lacks a few features proposed via a few PRs, until those PRs are merged in
(if), use github.com/karalabe/trash.

You can update dependencies via trash --update.

All dependencies have been updated to their latest version.

Parts of the build system are reworked to drop old notions of Godeps and
invocation of the go vet command so that it doesn't run against the vendor
folder, as that will just blow up during vetting.

The conversion drops OpenCL (and hence GPU mining support) from ethash and our
codebase. The short reasoning is that there's noone to maintain and having
opencl libs in our deps messes up builds as go install ./... tries to build
them, failing with unsatisfied link errors for the C OpenCL deps.

golang.org/x/net/context is not vendored in. We expect it to be fetched by the
user (i.e. using go get). To keep ci.go builds reproducible the package is
"vendored" in build/_vendor.

93 files changed, 0 insertions, 32493 deletions

diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/.gitignore b/Godeps/_workspace/src/github.com/robertkrimen/otto/.gitignore
deleted file mode 100644
index 8c2a16949..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-/.test
-/otto/otto
-/otto/otto-*
-/test/test-*.js
-/test/tester
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/DESIGN.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/DESIGN.markdown
deleted file mode 100644
index 288752987..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/DESIGN.markdown
+++ /dev/null
@@ -1 +0,0 @@
-* Designate the filename of "anonymous" source code by the hash (md5/sha1, etc.)
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/LICENSE b/Godeps/_workspace/src/github.com/robertkrimen/otto/LICENSE
deleted file mode 100644
index b6179fe38..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/LICENSE
+++ /dev/null
@@ -1,7 +0,0 @@
-Copyright (c) 2012 Robert Krimen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/Makefile
deleted file mode 100644
index 8d74038eb..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/Makefile
+++ /dev/null
@@ -1,63 +0,0 @@
-.PHONY: test test-race test-release release release-check test-262
-.PHONY: parser
-.PHONY: otto assets underscore
-
-TESTS := \
-	~
-
-TEST := -v --run
-TEST := -v
-TEST := -v --run Test\($(subst $(eval) ,\|,$(TESTS))\)
-TEST := .
-
-test: parser inline.go
-	go test -i
-	go test $(TEST)
-	@echo PASS
-
-parser:
-	$(MAKE) -C parser
-
-inline.go: inline
-	./$< > $@
-
-#################
-# release, test #
-#################
-
-release: test-race test-release
-	for package in . parser token ast file underscore registry; do (cd $$package && godocdown --signature > README.markdown); done
-	@echo \*\*\* make release-check
-	@echo PASS
-
-release-check: .test
-	$(MAKE) -C test build test
-	$(MAKE) -C .test/test262 build test
-	@echo PASS
-
-test-262: .test
-	$(MAKE) -C .test/test262 build test
-	@echo PASS
-
-test-release:
-	go test -i
-	go test
-
-test-race:
-	go test -race -i
-	go test -race
-
-#################################
-# otto, assets, underscore, ... #
-#################################
-
-otto:
-	$(MAKE) -C otto
-
-assets:
-	mkdir -p .assets
-	for file in underscore/test/*.js; do tr "\`" "_" < $$file > .assets/`basename $$file`; done
-
-underscore:
-	$(MAKE) -C $@
-
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/README.markdown
deleted file mode 100644
index fe8e1bd4a..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/README.markdown
+++ /dev/null
@@ -1,827 +0,0 @@
-# otto
---
-    import "github.com/robertkrimen/otto"
-
-Package otto is a JavaScript parser and interpreter written natively in Go.
-
-http://godoc.org/github.com/robertkrimen/otto
-
-    import (
-        "github.com/robertkrimen/otto"
-    )
-
-Run something in the VM
-
-    vm := otto.New()
-    vm.Run(`
-        abc = 2 + 2;
-    	console.log("The value of abc is " + abc); // 4
-    `)
-
-Get a value out of the VM
-
-    if value, err := vm.Get("abc"); err == nil {
-    	if value_int, err := value.ToInteger(); err == nil {
-    	    fmt.Printf("", value_int, err)
-    	}
-    }
-
-Set a number
-
-    vm.Set("def", 11)
-    vm.Run(`
-    	console.log("The value of def is " + def);
-    	// The value of def is 11
-    `)
-
-Set a string
-
-    vm.Set("xyzzy", "Nothing happens.")
-    vm.Run(`
-    	console.log(xyzzy.length); // 16
-    `)
-
-Get the value of an expression
-
-    value, _ = vm.Run("xyzzy.length")
-    {
-    	// value is an int64 with a value of 16
-    	value, _ := value.ToInteger()
-    }
-
-An error happens
-
-    value, err = vm.Run("abcdefghijlmnopqrstuvwxyz.length")
-    if err != nil {
-    	// err = ReferenceError: abcdefghijlmnopqrstuvwxyz is not defined
-    	// If there is an error, then value.IsUndefined() is true
-    	...
-    }
-
-Set a Go function
-
-    vm.Set("sayHello", func(call otto.FunctionCall) otto.Value {
-        fmt.Printf("Hello, %s.\n", call.Argument(0).String())
-        return otto.Value{}
-    })
-
-Set a Go function that returns something useful
-
-    vm.Set("twoPlus", func(call otto.FunctionCall) otto.Value {
-        right, _ := call.Argument(0).ToInteger()
-        result, _ := vm.ToValue(2 + right)
-        return result
-    })
-
-Use the functions in JavaScript
-
-    result, _ = vm.Run(`
-        sayHello("Xyzzy");      // Hello, Xyzzy.
-        sayHello();             // Hello, undefined
-
-        result = twoPlus(2.0); // 4
-    `)
-
-
-### Parser
-
-A separate parser is available in the parser package if you're just interested
-in building an AST.
-
-http://godoc.org/github.com/robertkrimen/otto/parser
-
-Parse and return an AST
-
-    filename := "" // A filename is optional
-    src := `
-        // Sample xyzzy example
-        (function(){
-            if (3.14159 > 0) {
-                console.log("Hello, World.");
-                return;
-            }
-
-            var xyzzy = NaN;
-            console.log("Nothing happens.");
-            return xyzzy;
-        })();
-    `
-
-    // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-    program, err := parser.ParseFile(nil, filename, src, 0)
-
-### otto
-
-You can run (Go) JavaScript from the commandline with:
-http://github.com/robertkrimen/otto/tree/master/otto
-
-    $ go get -v github.com/robertkrimen/otto/otto
-
-Run JavaScript by entering some source on stdin or by giving otto a filename:
-
-    $ otto example.js
-
-### underscore
-
-Optionally include the JavaScript utility-belt library, underscore, with this
-import:
-
-    import (
-    	"github.com/robertkrimen/otto"
-    	_ "github.com/robertkrimen/otto/underscore"
-    )
-
-    // Now every otto runtime will come loaded with underscore
-
-For more information: http://github.com/robertkrimen/otto/tree/master/underscore
-
-
-### Caveat Emptor
-
-The following are some limitations with otto:
-
-    * "use strict" will parse, but does nothing.
-    * The regular expression engine (re2/regexp) is not fully compatible with the ECMA5 specification.
-
-
-### Regular Expression Incompatibility
-
-Go translates JavaScript-style regular expressions into something that is
-"regexp" compatible via `parser.TransformRegExp`. Unfortunately, RegExp requires
-backtracking for some patterns, and backtracking is not supported by the
-standard Go engine: https://code.google.com/p/re2/wiki/Syntax
-
-Therefore, the following syntax is incompatible:
-
-    (?=)  // Lookahead (positive), currently a parsing error
-    (?!)  // Lookahead (backhead), currently a parsing error
-    \1    // Backreference (\1, \2, \3, ...), currently a parsing error
-
-A brief discussion of these limitations: "Regexp (?!re)"
-https://groups.google.com/forum/?fromgroups=#%21topic/golang-nuts/7qgSDWPIh_E
-
-More information about re2: https://code.google.com/p/re2/
-
-In addition to the above, re2 (Go) has a different definition for \s: [\t\n\f\r
-]. The JavaScript definition, on the other hand, also includes \v, Unicode
-"Separator, Space", etc.
-
-
-### Halting Problem
-
-If you want to stop long running executions (like third-party code), you can use
-the interrupt channel to do this:
-
-    package main
-
-    import (
-        "errors"
-        "fmt"
-        "os"
-        "time"
-
-        "github.com/robertkrimen/otto"
-    )
-
-    var halt = errors.New("Stahp")
-
-    func main() {
-        runUnsafe(`var abc = [];`)
-        runUnsafe(`
-        while (true) {
-            // Loop forever
-        }`)
-    }
-
-    func runUnsafe(unsafe string) {
-        start := time.Now()
-        defer func() {
-            duration := time.Since(start)
-            if caught := recover(); caught != nil {
-                if caught == halt {
-                    fmt.Fprintf(os.Stderr, "Some code took to long! Stopping after: %v\n", duration)
-                    return
-                }
-                panic(caught) // Something else happened, repanic!
-            }
-            fmt.Fprintf(os.Stderr, "Ran code successfully: %v\n", duration)
-        }()
-
-        vm := otto.New()
-        vm.Interrupt = make(chan func(), 1) // The buffer prevents blocking
-
-        go func() {
-            time.Sleep(2 * time.Second) // Stop after two seconds
-            vm.Interrupt <- func() {
-                panic(halt)
-            }
-        }()
-
-        vm.Run(unsafe) // Here be dragons (risky code)
-    }
-
-Where is setTimeout/setInterval?
-
-These timing functions are not actually part of the ECMA-262 specification.
-Typically, they belong to the `window` object (in the browser). It would not be
-difficult to provide something like these via Go, but you probably want to wrap
-otto in an event loop in that case.
-
-For an example of how this could be done in Go with otto, see natto:
-
-http://github.com/robertkrimen/natto
-
-Here is some more discussion of the issue:
-
-* http://book.mixu.net/node/ch2.html
-
-* http://en.wikipedia.org/wiki/Reentrancy_%28computing%29
-
-* http://aaroncrane.co.uk/2009/02/perl_safe_signals/
-
-## Usage
-
-```go
-var ErrVersion = errors.New("version mismatch")
-```
-
-#### type Error
-
-```go
-type Error struct {
-}
-```
-
-An Error represents a runtime error, e.g. a TypeError, a ReferenceError, etc.
-
-#### func (Error) Error
-
-```go
-func (err Error) Error() string
-```
-Error returns a description of the error
-
-    TypeError: 'def' is not a function
-
-#### func (Error) String
-
-```go
-func (err Error) String() string
-```
-String returns a description of the error and a trace of where the error
-occurred.
-
-    TypeError: 'def' is not a function
-        at xyz (<anonymous>:3:9)
-        at <anonymous>:7:1/
-
-#### type FunctionCall
-
-```go
-type FunctionCall struct {
-	This         Value
-	ArgumentList []Value
-	Otto         *Otto
-}
-```
-
-FunctionCall is an encapsulation of a JavaScript function call.
-
-#### func (FunctionCall) Argument
-
-```go
-func (self FunctionCall) Argument(index int) Value
-```
-Argument will return the value of the argument at the given index.
-
-If no such argument exists, undefined is returned.
-
-#### type Object
-
-```go
-type Object struct {
-}
-```
-
-Object is the representation of a JavaScript object.
-
-#### func (Object) Call
-
-```go
-func (self Object) Call(name string, argumentList ...interface{}) (Value, error)
-```
-Call a method on the object.
-
-It is essentially equivalent to:
-
-    var method, _ := object.Get(name)
-    method.Call(object, argumentList...)
-
-An undefined value and an error will result if:
-
-    1. There is an error during conversion of the argument list
-    2. The property is not actually a function
-    3. An (uncaught) exception is thrown
-
-#### func (Object) Class
-
-```go
-func (self Object) Class() string
-```
-Class will return the class string of the object.
-
-The return value will (generally) be one of:
-
-    Object
-    Function
-    Array
-    String
-    Number
-    Boolean
-    Date
-    RegExp
-
-#### func (Object) Get
-
-```go
-func (self Object) Get(name string) (Value, error)
-```
-Get the value of the property with the given name.
-
-#### func (Object) Keys
-
-```go
-func (self Object) Keys() []string
-```
-Get the keys for the object
-
-Equivalent to calling Object.keys on the object
-
-#### func (Object) Set
-
-```go
-func (self Object) Set(name string, value interface{}) error
-```
-Set the property of the given name to the given value.
-
-An error will result if the setting the property triggers an exception (i.e.
-read-only), or there is an error during conversion of the given value.
-
-#### func (Object) Value
-
-```go
-func (self Object) Value() Value
-```
-Value will return self as a value.
-
-#### type Otto
-
-```go
-type Otto struct {
-	// Interrupt is a channel for interrupting the runtime. You can use this to halt a long running execution, for example.
-	// See "Halting Problem" for more information.
-	Interrupt chan func()
-}
-```
-
-Otto is the representation of the JavaScript runtime. Each instance of Otto has
-a self-contained namespace.
-
-#### func  New
-
-```go
-func New() *Otto
-```
-New will allocate a new JavaScript runtime
-
-#### func  Run
-
-```go
-func Run(src interface{}) (*Otto, Value, error)
-```
-Run will allocate a new JavaScript runtime, run the given source on the
-allocated runtime, and return the runtime, resulting value, and error (if any).
-
-src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST
-always be in UTF-8.
-
-src may also be a Script.
-
-src may also be a Program, but if the AST has been modified, then runtime
-behavior is undefined.
-
-#### func (Otto) Call
-
-```go
-func (self Otto) Call(source string, this interface{}, argumentList ...interface{}) (Value, error)
-```
-Call the given JavaScript with a given this and arguments.
-
-If this is nil, then some special handling takes place to determine the proper
-this value, falling back to a "standard" invocation if necessary (where this is
-undefined).
-
-If source begins with "new " (A lowercase new followed by a space), then Call
-will invoke the function constructor rather than performing a function call. In
-this case, the this argument has no effect.
-
-    // value is a String object
-    value, _ := vm.Call("Object", nil, "Hello, World.")
-
-    // Likewise...
-    value, _ := vm.Call("new Object", nil, "Hello, World.")
-
-    // This will perform a concat on the given array and return the result
-    // value is [ 1, 2, 3, undefined, 4, 5, 6, 7, "abc" ]
-    value, _ := vm.Call(`[ 1, 2, 3, undefined, 4 ].concat`, nil, 5, 6, 7, "abc")
-
-#### func (*Otto) Compile
-
-```go
-func (self *Otto) Compile(filename string, src interface{}) (*Script, error)
-```
-Compile will parse the given source and return a Script value or nil and an
-error if there was a problem during compilation.
-
-    script, err := vm.Compile("", `var abc; if (!abc) abc = 0; abc += 2; abc;`)
-    vm.Run(script)
-
-#### func (*Otto) Copy
-
-```go
-func (in *Otto) Copy() *Otto
-```
-Copy will create a copy/clone of the runtime.
-
-Copy is useful for saving some time when creating many similar runtimes.
-
-This method works by walking the original runtime and cloning each object,
-scope, stash, etc. into a new runtime.
-
-Be on the lookout for memory leaks or inadvertent sharing of resources.
-
-#### func (Otto) Get
-
-```go
-func (self Otto) Get(name string) (Value, error)
-```
-Get the value of the top-level binding of the given name.
-
-If there is an error (like the binding does not exist), then the value will be
-undefined.
-
-#### func (Otto) Object
-
-```go
-func (self Otto) Object(source string) (*Object, error)
-```
-Object will run the given source and return the result as an object.
-
-For example, accessing an existing object:
-
-    object, _ := vm.Object(`Number`)
-
-Or, creating a new object:
-
-    object, _ := vm.Object(`({ xyzzy: "Nothing happens." })`)
-
-Or, creating and assigning an object:
-
-    object, _ := vm.Object(`xyzzy = {}`)
-    object.Set("volume", 11)
-
-If there is an error (like the source does not result in an object), then nil
-and an error is returned.
-
-#### func (Otto) Run
-
-```go
-func (self Otto) Run(src interface{}) (Value, error)
-```
-Run will run the given source (parsing it first if necessary), returning the
-resulting value and error (if any)
-
-src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST
-always be in UTF-8.
-
-If the runtime is unable to parse source, then this function will return
-undefined and the parse error (nothing will be evaluated in this case).
-
-src may also be a Script.
-
-src may also be a Program, but if the AST has been modified, then runtime
-behavior is undefined.
-
-#### func (Otto) Set
-
-```go
-func (self Otto) Set(name string, value interface{}) error
-```
-Set the top-level binding of the given name to the given value.
-
-Set will automatically apply ToValue to the given value in order to convert it
-to a JavaScript value (type Value).
-
-If there is an error (like the binding is read-only, or the ToValue conversion
-fails), then an error is returned.
-
-If the top-level binding does not exist, it will be created.
-
-#### func (Otto) ToValue
-
-```go
-func (self Otto) ToValue(value interface{}) (Value, error)
-```
-ToValue will convert an interface{} value to a value digestible by
-otto/JavaScript.
-
-#### type Script
-
-```go
-type Script struct {
-}
-```
-
-Script is a handle for some (reusable) JavaScript. Passing a Script value to a
-run method will evaluate the JavaScript.
-
-#### func (*Script) String
-
-```go
-func (self *Script) String() string
-```
-
-#### type Value
-
-```go
-type Value struct {
-}
-```
-
-Value is the representation of a JavaScript value.
-
-#### func  FalseValue
-
-```go
-func FalseValue() Value
-```
-FalseValue will return a value representing false.
-
-It is equivalent to:
-
-    ToValue(false)
-
-#### func  NaNValue
-
-```go
-func NaNValue() Value
-```
-NaNValue will return a value representing NaN.
-
-It is equivalent to:
-
-    ToValue(math.NaN())
-
-#### func  NullValue
-
-```go
-func NullValue() Value
-```
-NullValue will return a Value representing null.
-
-#### func  ToValue
-
-```go
-func ToValue(value interface{}) (Value, error)
-```
-ToValue will convert an interface{} value to a value digestible by
-otto/JavaScript
-
-This function will not work for advanced types (struct, map, slice/array, etc.)
-and you should use Otto.ToValue instead.
-
-#### func  TrueValue
-
-```go
-func TrueValue() Value
-```
-TrueValue will return a value representing true.
-
-It is equivalent to:
-
-    ToValue(true)
-
-#### func  UndefinedValue
-
-```go
-func UndefinedValue() Value
-```
-UndefinedValue will return a Value representing undefined.
-
-#### func (Value) Call
-
-```go
-func (value Value) Call(this Value, argumentList ...interface{}) (Value, error)
-```
-Call the value as a function with the given this value and argument list and
-return the result of invocation. It is essentially equivalent to:
-
-    value.apply(thisValue, argumentList)
-
-An undefined value and an error will result if:
-
-    1. There is an error during conversion of the argument list
-    2. The value is not actually a function
-    3. An (uncaught) exception is thrown
-
-#### func (Value) Class
-
-```go
-func (value Value) Class() string
-```
-Class will return the class string of the value or the empty string if value is
-not an object.
-
-The return value will (generally) be one of:
-
-    Object
-    Function
-    Array
-    String
-    Number
-    Boolean
-    Date
-    RegExp
-
-#### func (Value) Export
-
-```go
-func (self Value) Export() (interface{}, error)
-```
-Export will attempt to convert the value to a Go representation and return it
-via an interface{} kind.
-
-Export returns an error, but it will always be nil. It is present for backwards
-compatibility.
-
-If a reasonable conversion is not possible, then the original value is returned.
-
-    undefined   -> nil (FIXME?: Should be Value{})
-    null        -> nil
-    boolean     -> bool
-    number      -> A number type (int, float32, uint64, ...)
-    string      -> string
-    Array       -> []interface{}
-    Object      -> map[string]interface{}
-
-#### func (Value) IsBoolean
-
-```go
-func (value Value) IsBoolean() bool
-```
-IsBoolean will return true if value is a boolean (primitive).
-
-#### func (Value) IsDefined
-
-```go
-func (value Value) IsDefined() bool
-```
-IsDefined will return false if the value is undefined, and true otherwise.
-
-#### func (Value) IsFunction
-
-```go
-func (value Value) IsFunction() bool
-```
-IsFunction will return true if value is a function.
-
-#### func (Value) IsNaN
-
-```go
-func (value Value) IsNaN() bool
-```
-IsNaN will return true if value is NaN (or would convert to NaN).
-
-#### func (Value) IsNull
-
-```go
-func (value Value) IsNull() bool
-```
-IsNull will return true if the value is null, and false otherwise.
-
-#### func (Value) IsNumber
-
-```go
-func (value Value) IsNumber() bool
-```
-IsNumber will return true if value is a number (primitive).
-
-#### func (Value) IsObject
-
-```go
-func (value Value) IsObject() bool
-```
-IsObject will return true if value is an object.
-
-#### func (Value) IsPrimitive
-
-```go
-func (value Value) IsPrimitive() bool
-```
-IsPrimitive will return true if value is a primitive (any kind of primitive).
-
-#### func (Value) IsString
-
-```go
-func (value Value) IsString() bool
-```
-IsString will return true if value is a string (primitive).
-
-#### func (Value) IsUndefined
-
-```go
-func (value Value) IsUndefined() bool
-```
-IsUndefined will return true if the value is undefined, and false otherwise.
-
-#### func (Value) Object
-
-```go
-func (value Value) Object() *Object
-```
-Object will return the object of the value, or nil if value is not an object.
-
-This method will not do any implicit conversion. For example, calling this
-method on a string primitive value will not return a String object.
-
-#### func (Value) String
-
-```go
-func (value Value) String() string
-```
-String will return the value as a string.
-
-This method will make return the empty string if there is an error.
-
-#### func (Value) ToBoolean
-
-```go
-func (value Value) ToBoolean() (bool, error)
-```
-ToBoolean will convert the value to a boolean (bool).
-
-    ToValue(0).ToBoolean() => false
-    ToValue("").ToBoolean() => false
-    ToValue(true).ToBoolean() => true
-    ToValue(1).ToBoolean() => true
-    ToValue("Nothing happens").ToBoolean() => true
-
-If there is an error during the conversion process (like an uncaught exception),
-then the result will be false and an error.
-
-#### func (Value) ToFloat
-
-```go
-func (value Value) ToFloat() (float64, error)
-```
-ToFloat will convert the value to a number (float64).
-
-    ToValue(0).ToFloat() => 0.
-    ToValue(1.1).ToFloat() => 1.1
-    ToValue("11").ToFloat() => 11.
-
-If there is an error during the conversion process (like an uncaught exception),
-then the result will be 0 and an error.
-
-#### func (Value) ToInteger
-
-```go
-func (value Value) ToInteger() (int64, error)
-```
-ToInteger will convert the value to a number (int64).
-
-    ToValue(0).ToInteger() => 0
-    ToValue(1.1).ToInteger() => 1
-    ToValue("11").ToInteger() => 11
-
-If there is an error during the conversion process (like an uncaught exception),
-then the result will be 0 and an error.
-
-#### func (Value) ToString
-
-```go
-func (value Value) ToString() (string, error)
-```
-ToString will convert the value to a string (string).
-
-    ToValue(0).ToString() => "0"
-    ToValue(false).ToString() => "false"
-    ToValue(1.1).ToString() => "1.1"
-    ToValue("11").ToString() => "11"
-    ToValue('Nothing happens.').ToString() => "Nothing happens."
-
-If there is an error during the conversion process (like an uncaught exception),
-then the result will be the empty string ("") and an error.
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/README.markdown
deleted file mode 100644
index a785da911..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/README.markdown
+++ /dev/null
@@ -1,1068 +0,0 @@
-# ast
---
-    import "github.com/robertkrimen/otto/ast"
-
-Package ast declares types representing a JavaScript AST.
-
-
-### Warning
-
-The parser and AST interfaces are still works-in-progress (particularly where
-node types are concerned) and may change in the future.
-
-## Usage
-
-#### type ArrayLiteral
-
-```go
-type ArrayLiteral struct {
-	LeftBracket  file.Idx
-	RightBracket file.Idx
-	Value        []Expression
-}
-```
-
-
-#### func (*ArrayLiteral) Idx0
-
-```go
-func (self *ArrayLiteral) Idx0() file.Idx
-```
-
-#### func (*ArrayLiteral) Idx1
-
-```go
-func (self *ArrayLiteral) Idx1() file.Idx
-```
-
-#### type AssignExpression
-
-```go
-type AssignExpression struct {
-	Operator token.Token
-	Left     Expression
-	Right    Expression
-}
-```
-
-
-#### func (*AssignExpression) Idx0
-
-```go
-func (self *AssignExpression) Idx0() file.Idx
-```
-
-#### func (*AssignExpression) Idx1
-
-```go
-func (self *AssignExpression) Idx1() file.Idx
-```
-
-#### type BadExpression
-
-```go
-type BadExpression struct {
-	From file.Idx
-	To   file.Idx
-}
-```
-
-
-#### func (*BadExpression) Idx0
-
-```go
-func (self *BadExpression) Idx0() file.Idx
-```
-
-#### func (*BadExpression) Idx1
-
-```go
-func (self *BadExpression) Idx1() file.Idx
-```
-
-#### type BadStatement
-
-```go
-type BadStatement struct {
-	From file.Idx
-	To   file.Idx
-}
-```
-
-
-#### func (*BadStatement) Idx0
-
-```go
-func (self *BadStatement) Idx0() file.Idx
-```
-
-#### func (*BadStatement) Idx1
-
-```go
-func (self *BadStatement) Idx1() file.Idx
-```
-
-#### type BinaryExpression
-
-```go
-type BinaryExpression struct {
-	Operator   token.Token
-	Left       Expression
-	Right      Expression
-	Comparison bool
-}
-```
-
-
-#### func (*BinaryExpression) Idx0
-
-```go
-func (self *BinaryExpression) Idx0() file.Idx
-```
-
-#### func (*BinaryExpression) Idx1
-
-```go
-func (self *BinaryExpression) Idx1() file.Idx
-```
-
-#### type BlockStatement
-
-```go
-type BlockStatement struct {
-	LeftBrace  file.Idx
-	List       []Statement
-	RightBrace file.Idx
-}
-```
-
-
-#### func (*BlockStatement) Idx0
-
-```go
-func (self *BlockStatement) Idx0() file.Idx
-```
-
-#### func (*BlockStatement) Idx1
-
-```go
-func (self *BlockStatement) Idx1() file.Idx
-```
-
-#### type BooleanLiteral
-
-```go
-type BooleanLiteral struct {
-	Idx     file.Idx
-	Literal string
-	Value   bool
-}
-```
-
-
-#### func (*BooleanLiteral) Idx0
-
-```go
-func (self *BooleanLiteral) Idx0() file.Idx
-```
-
-#### func (*BooleanLiteral) Idx1
-
-```go
-func (self *BooleanLiteral) Idx1() file.Idx
-```
-
-#### type BracketExpression
-
-```go
-type BracketExpression struct {
-	Left         Expression
-	Member       Expression
-	LeftBracket  file.Idx
-	RightBracket file.Idx
-}
-```
-
-
-#### func (*BracketExpression) Idx0
-
-```go
-func (self *BracketExpression) Idx0() file.Idx
-```
-
-#### func (*BracketExpression) Idx1
-
-```go
-func (self *BracketExpression) Idx1() file.Idx
-```
-
-#### type BranchStatement
-
-```go
-type BranchStatement struct {
-	Idx   file.Idx
-	Token token.Token
-	Label *Identifier
-}
-```
-
-
-#### func (*BranchStatement) Idx0
-
-```go
-func (self *BranchStatement) Idx0() file.Idx
-```
-
-#### func (*BranchStatement) Idx1
-
-```go
-func (self *BranchStatement) Idx1() file.Idx
-```
-
-#### type CallExpression
-
-```go
-type CallExpression struct {
-	Callee           Expression
-	LeftParenthesis  file.Idx
-	ArgumentList     []Expression
-	RightParenthesis file.Idx
-}
-```
-
-
-#### func (*CallExpression) Idx0
-
-```go
-func (self *CallExpression) Idx0() file.Idx
-```
-
-#### func (*CallExpression) Idx1
-
-```go
-func (self *CallExpression) Idx1() file.Idx
-```
-
-#### type CaseStatement
-
-```go
-type CaseStatement struct {
-	Case       file.Idx
-	Test       Expression
-	Consequent []Statement
-}
-```
-
-
-#### func (*CaseStatement) Idx0
-
-```go
-func (self *CaseStatement) Idx0() file.Idx
-```
-
-#### func (*CaseStatement) Idx1
-
-```go
-func (self *CaseStatement) Idx1() file.Idx
-```
-
-#### type CatchStatement
-
-```go
-type CatchStatement struct {
-	Catch     file.Idx
-	Parameter *Identifier
-	Body      Statement
-}
-```
-
-
-#### func (*CatchStatement) Idx0
-
-```go
-func (self *CatchStatement) Idx0() file.Idx
-```
-
-#### func (*CatchStatement) Idx1
-
-```go
-func (self *CatchStatement) Idx1() file.Idx
-```
-
-#### type ConditionalExpression
-
-```go
-type ConditionalExpression struct {
-	Test       Expression
-	Consequent Expression
-	Alternate  Expression
-}
-```
-
-
-#### func (*ConditionalExpression) Idx0
-
-```go
-func (self *ConditionalExpression) Idx0() file.Idx
-```
-
-#### func (*ConditionalExpression) Idx1
-
-```go
-func (self *ConditionalExpression) Idx1() file.Idx
-```
-
-#### type DebuggerStatement
-
-```go
-type DebuggerStatement struct {
-	Debugger file.Idx
-}
-```
-
-
-#### func (*DebuggerStatement) Idx0
-
-```go
-func (self *DebuggerStatement) Idx0() file.Idx
-```
-
-#### func (*DebuggerStatement) Idx1
-
-```go
-func (self *DebuggerStatement) Idx1() file.Idx
-```
-
-#### type Declaration
-
-```go
-type Declaration interface {
-	// contains filtered or unexported methods
-}
-```
-
-All declaration nodes implement the Declaration interface.
-
-#### type DoWhileStatement
-
-```go
-type DoWhileStatement struct {
-	Do   file.Idx
-	Test Expression
-	Body Statement
-}
-```
-
-
-#### func (*DoWhileStatement) Idx0
-
-```go
-func (self *DoWhileStatement) Idx0() file.Idx
-```
-
-#### func (*DoWhileStatement) Idx1
-
-```go
-func (self *DoWhileStatement) Idx1() file.Idx
-```
-
-#### type DotExpression
-
-```go
-type DotExpression struct {
-	Left       Expression
-	Identifier Identifier
-}
-```
-
-
-#### func (*DotExpression) Idx0
-
-```go
-func (self *DotExpression) Idx0() file.Idx
-```
-
-#### func (*DotExpression) Idx1
-
-```go
-func (self *DotExpression) Idx1() file.Idx
-```
-
-#### type EmptyStatement
-
-```go
-type EmptyStatement struct {
-	Semicolon file.Idx
-}
-```
-
-
-#### func (*EmptyStatement) Idx0
-
-```go
-func (self *EmptyStatement) Idx0() file.Idx
-```
-
-#### func (*EmptyStatement) Idx1
-
-```go
-func (self *EmptyStatement) Idx1() file.Idx
-```
-
-#### type Expression
-
-```go
-type Expression interface {
-	Node
-	// contains filtered or unexported methods
-}
-```
-
-All expression nodes implement the Expression interface.
-
-#### type ExpressionStatement
-
-```go
-type ExpressionStatement struct {
-	Expression Expression
-}
-```
-
-
-#### func (*ExpressionStatement) Idx0
-
-```go
-func (self *ExpressionStatement) Idx0() file.Idx
-```
-
-#### func (*ExpressionStatement) Idx1
-
-```go
-func (self *ExpressionStatement) Idx1() file.Idx
-```
-
-#### type ForInStatement
-
-```go
-type ForInStatement struct {
-	For    file.Idx
-	Into   Expression
-	Source Expression
-	Body   Statement
-}
-```
-
-
-#### func (*ForInStatement) Idx0
-
-```go
-func (self *ForInStatement) Idx0() file.Idx
-```
-
-#### func (*ForInStatement) Idx1
-
-```go
-func (self *ForInStatement) Idx1() file.Idx
-```
-
-#### type ForStatement
-
-```go
-type ForStatement struct {
-	For         file.Idx
-	Initializer Expression
-	Update      Expression
-	Test        Expression
-	Body        Statement
-}
-```
-
-
-#### func (*ForStatement) Idx0
-
-```go
-func (self *ForStatement) Idx0() file.Idx
-```
-
-#### func (*ForStatement) Idx1
-
-```go
-func (self *ForStatement) Idx1() file.Idx
-```
-
-#### type FunctionDeclaration
-
-```go
-type FunctionDeclaration struct {
-	Function *FunctionLiteral
-}
-```
-
-
-#### type FunctionLiteral
-
-```go
-type FunctionLiteral struct {
-	Function      file.Idx
-	Name          *Identifier
-	ParameterList *ParameterList
-	Body          Statement
-	Source        string
-
-	DeclarationList []Declaration
-}
-```
-
-
-#### func (*FunctionLiteral) Idx0
-
-```go
-func (self *FunctionLiteral) Idx0() file.Idx
-```
-
-#### func (*FunctionLiteral) Idx1
-
-```go
-func (self *FunctionLiteral) Idx1() file.Idx
-```
-
-#### type Identifier
-
-```go
-type Identifier struct {
-	Name string
-	Idx  file.Idx
-}
-```
-
-
-#### func (*Identifier) Idx0
-
-```go
-func (self *Identifier) Idx0() file.Idx
-```
-
-#### func (*Identifier) Idx1
-
-```go
-func (self *Identifier) Idx1() file.Idx
-```
-
-#### type IfStatement
-
-```go
-type IfStatement struct {
-	If         file.Idx
-	Test       Expression
-	Consequent Statement
-	Alternate  Statement
-}
-```
-
-
-#### func (*IfStatement) Idx0
-
-```go
-func (self *IfStatement) Idx0() file.Idx
-```
-
-#### func (*IfStatement) Idx1
-
-```go
-func (self *IfStatement) Idx1() file.Idx
-```
-
-#### type LabelledStatement
-
-```go
-type LabelledStatement struct {
-	Label     *Identifier
-	Colon     file.Idx
-	Statement Statement
-}
-```
-
-
-#### func (*LabelledStatement) Idx0
-
-```go
-func (self *LabelledStatement) Idx0() file.Idx
-```
-
-#### func (*LabelledStatement) Idx1
-
-```go
-func (self *LabelledStatement) Idx1() file.Idx
-```
-
-#### type NewExpression
-
-```go
-type NewExpression struct {
-	New              file.Idx
-	Callee           Expression
-	LeftParenthesis  file.Idx
-	ArgumentList     []Expression
-	RightParenthesis file.Idx
-}
-```
-
-
-#### func (*NewExpression) Idx0
-
-```go
-func (self *NewExpression) Idx0() file.Idx
-```
-
-#### func (*NewExpression) Idx1
-
-```go
-func (self *NewExpression) Idx1() file.Idx
-```
-
-#### type Node
-
-```go
-type Node interface {
-	Idx0() file.Idx // The index of the first character belonging to the node
-	Idx1() file.Idx // The index of the first character immediately after the node
-}
-```
-
-All nodes implement the Node interface.
-
-#### type NullLiteral
-
-```go
-type NullLiteral struct {
-	Idx     file.Idx
-	Literal string
-}
-```
-
-
-#### func (*NullLiteral) Idx0
-
-```go
-func (self *NullLiteral) Idx0() file.Idx
-```
-
-#### func (*NullLiteral) Idx1
-
-```go
-func (self *NullLiteral) Idx1() file.Idx
-```
-
-#### type NumberLiteral
-
-```go
-type NumberLiteral struct {
-	Idx     file.Idx
-	Literal string
-	Value   interface{}
-}
-```
-
-
-#### func (*NumberLiteral) Idx0
-
-```go
-func (self *NumberLiteral) Idx0() file.Idx
-```
-
-#### func (*NumberLiteral) Idx1
-
-```go
-func (self *NumberLiteral) Idx1() file.Idx
-```
-
-#### type ObjectLiteral
-
-```go
-type ObjectLiteral struct {
-	LeftBrace  file.Idx
-	RightBrace file.Idx
-	Value      []Property
-}
-```
-
-
-#### func (*ObjectLiteral) Idx0
-
-```go
-func (self *ObjectLiteral) Idx0() file.Idx
-```
-
-#### func (*ObjectLiteral) Idx1
-
-```go
-func (self *ObjectLiteral) Idx1() file.Idx
-```
-
-#### type ParameterList
-
-```go
-type ParameterList struct {
-	Opening file.Idx
-	List    []*Identifier
-	Closing file.Idx
-}
-```
-
-
-#### type Program
-
-```go
-type Program struct {
-	Body []Statement
-
-	DeclarationList []Declaration
-
-	File *file.File
-}
-```
-
-
-#### func (*Program) Idx0
-
-```go
-func (self *Program) Idx0() file.Idx
-```
-
-#### func (*Program) Idx1
-
-```go
-func (self *Program) Idx1() file.Idx
-```
-
-#### type Property
-
-```go
-type Property struct {
-	Key   string
-	Kind  string
-	Value Expression
-}
-```
-
-
-#### type RegExpLiteral
-
-```go
-type RegExpLiteral struct {
-	Idx     file.Idx
-	Literal string
-	Pattern string
-	Flags   string
-	Value   string
-}
-```
-
-
-#### func (*RegExpLiteral) Idx0
-
-```go
-func (self *RegExpLiteral) Idx0() file.Idx
-```
-
-#### func (*RegExpLiteral) Idx1
-
-```go
-func (self *RegExpLiteral) Idx1() file.Idx
-```
-
-#### type ReturnStatement
-
-```go
-type ReturnStatement struct {
-	Return   file.Idx
-	Argument Expression
-}
-```
-
-
-#### func (*ReturnStatement) Idx0
-
-```go
-func (self *ReturnStatement) Idx0() file.Idx
-```
-
-#### func (*ReturnStatement) Idx1
-
-```go
-func (self *ReturnStatement) Idx1() file.Idx
-```
-
-#### type SequenceExpression
-
-```go
-type SequenceExpression struct {
-	Sequence []Expression
-}
-```
-
-
-#### func (*SequenceExpression) Idx0
-
-```go
-func (self *SequenceExpression) Idx0() file.Idx
-```
-
-#### func (*SequenceExpression) Idx1
-
-```go
-func (self *SequenceExpression) Idx1() file.Idx
-```
-
-#### type Statement
-
-```go
-type Statement interface {
-	Node
-	// contains filtered or unexported methods
-}
-```
-
-All statement nodes implement the Statement interface.
-
-#### type StringLiteral
-
-```go
-type StringLiteral struct {
-	Idx     file.Idx
-	Literal string
-	Value   string
-}
-```
-
-
-#### func (*StringLiteral) Idx0
-
-```go
-func (self *StringLiteral) Idx0() file.Idx
-```
-
-#### func (*StringLiteral) Idx1
-
-```go
-func (self *StringLiteral) Idx1() file.Idx
-```
-
-#### type SwitchStatement
-
-```go
-type SwitchStatement struct {
-	Switch       file.Idx
-	Discriminant Expression
-	Default      int
-	Body         []*CaseStatement
-}
-```
-
-
-#### func (*SwitchStatement) Idx0
-
-```go
-func (self *SwitchStatement) Idx0() file.Idx
-```
-
-#### func (*SwitchStatement) Idx1
-
-```go
-func (self *SwitchStatement) Idx1() file.Idx
-```
-
-#### type ThisExpression
-
-```go
-type ThisExpression struct {
-	Idx file.Idx
-}
-```
-
-
-#### func (*ThisExpression) Idx0
-
-```go
-func (self *ThisExpression) Idx0() file.Idx
-```
-
-#### func (*ThisExpression) Idx1
-
-```go
-func (self *ThisExpression) Idx1() file.Idx
-```
-
-#### type ThrowStatement
-
-```go
-type ThrowStatement struct {
-	Throw    file.Idx
-	Argument Expression
-}
-```
-
-
-#### func (*ThrowStatement) Idx0
-
-```go
-func (self *ThrowStatement) Idx0() file.Idx
-```
-
-#### func (*ThrowStatement) Idx1
-
-```go
-func (self *ThrowStatement) Idx1() file.Idx
-```
-
-#### type TryStatement
-
-```go
-type TryStatement struct {
-	Try     file.Idx
-	Body    Statement
-	Catch   *CatchStatement
-	Finally Statement
-}
-```
-
-
-#### func (*TryStatement) Idx0
-
-```go
-func (self *TryStatement) Idx0() file.Idx
-```
-
-#### func (*TryStatement) Idx1
-
-```go
-func (self *TryStatement) Idx1() file.Idx
-```
-
-#### type UnaryExpression
-
-```go
-type UnaryExpression struct {
-	Operator token.Token
-	Idx      file.Idx // If a prefix operation
-	Operand  Expression
-	Postfix  bool
-}
-```
-
-
-#### func (*UnaryExpression) Idx0
-
-```go
-func (self *UnaryExpression) Idx0() file.Idx
-```
-
-#### func (*UnaryExpression) Idx1
-
-```go
-func (self *UnaryExpression) Idx1() file.Idx
-```
-
-#### type VariableDeclaration
-
-```go
-type VariableDeclaration struct {
-	Var  file.Idx
-	List []*VariableExpression
-}
-```
-
-
-#### type VariableExpression
-
-```go
-type VariableExpression struct {
-	Name        string
-	Idx         file.Idx
-	Initializer Expression
-}
-```
-
-
-#### func (*VariableExpression) Idx0
-
-```go
-func (self *VariableExpression) Idx0() file.Idx
-```
-
-#### func (*VariableExpression) Idx1
-
-```go
-func (self *VariableExpression) Idx1() file.Idx
-```
-
-#### type VariableStatement
-
-```go
-type VariableStatement struct {
-	Var  file.Idx
-	List []Expression
-}
-```
-
-
-#### func (*VariableStatement) Idx0
-
-```go
-func (self *VariableStatement) Idx0() file.Idx
-```
-
-#### func (*VariableStatement) Idx1
-
-```go
-func (self *VariableStatement) Idx1() file.Idx
-```
-
-#### type WhileStatement
-
-```go
-type WhileStatement struct {
-	While file.Idx
-	Test  Expression
-	Body  Statement
-}
-```
-
-
-#### func (*WhileStatement) Idx0
-
-```go
-func (self *WhileStatement) Idx0() file.Idx
-```
-
-#### func (*WhileStatement) Idx1
-
-```go
-func (self *WhileStatement) Idx1() file.Idx
-```
-
-#### type WithStatement
-
-```go
-type WithStatement struct {
-	With   file.Idx
-	Object Expression
-	Body   Statement
-}
-```
-
-
-#### func (*WithStatement) Idx0
-
-```go
-func (self *WithStatement) Idx0() file.Idx
-```
-
-#### func (*WithStatement) Idx1
-
-```go
-func (self *WithStatement) Idx1() file.Idx
-```
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/comments.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/comments.go
deleted file mode 100644
index 227e34ecb..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/comments.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package ast
-
-import (
-	"fmt"
-	"github.com/robertkrimen/otto/file"
-)
-
-// CommentPosition determines where the comment is in a given context
-type CommentPosition int
-
-const (
-	_        CommentPosition = iota
-	LEADING                  // Before the pertinent expression
-	TRAILING                 // After the pertinent expression
-	KEY                      // After a key or keyword
-	COLON                    // After a colon in a field declaration
-	FINAL                    // Final comments in a block, not belonging to a specific expression or the comment after a trailing , in an array or object literal
-	TBD
-)
-
-// Comment contains the data of the comment
-type Comment struct {
-	Begin    file.Idx
-	Text     string
-	Position CommentPosition
-}
-
-// String returns a stringified version of the position
-func (cp CommentPosition) String() string {
-	switch cp {
-	case LEADING:
-		return "Leading"
-	case TRAILING:
-		return "Trailing"
-	case KEY:
-		return "Key"
-	case COLON:
-		return "Colon"
-	case FINAL:
-		return "Final"
-	default:
-		return "???"
-	}
-}
-
-// String returns a stringified version of the comment
-func (c Comment) String() string {
-	return fmt.Sprintf("Comment: %v", c.Text)
-}
-
-// CommentMap is the data structure where all found comments are stored
-type CommentMap map[Node][]*Comment
-
-// AddComment adds a single comment to the map
-func (cm CommentMap) AddComment(node Node, comment *Comment) {
-	list := cm[node]
-	list = append(list, comment)
-
-	cm[node] = list
-}
-
-// AddComments adds a slice of comments, given a node and an updated position
-func (cm CommentMap) AddComments(node Node, comments []*Comment, position CommentPosition) {
-	for _, comment := range comments {
-		comment.Position = position
-		cm.AddComment(node, comment)
-	}
-}
-
-// Size returns the size of the map
-func (cm CommentMap) Size() int {
-	size := 0
-	for _, comments := range cm {
-		size += len(comments)
-	}
-
-	return size
-}
-
-// MoveComments moves comments with a given position from a node to another
-func (cm CommentMap) MoveComments(from, to Node, position CommentPosition) {
-	for i, c := range cm[from] {
-		if c.Position == position {
-			cm.AddComment(to, c)
-
-			// Remove the comment from the "from" slice
-			cm[from][i] = cm[from][len(cm[from])-1]
-			cm[from][len(cm[from])-1] = nil
-			cm[from] = cm[from][:len(cm[from])-1]
-		}
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/node.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/node.go
deleted file mode 100644
index 8a651dc2f..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/ast/node.go
+++ /dev/null
@@ -1,506 +0,0 @@
-/*
-Package ast declares types representing a JavaScript AST.
-
-Warning
-
-The parser and AST interfaces are still works-in-progress (particularly where
-node types are concerned) and may change in the future.
-
-*/
-package ast
-
-import (
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-// All nodes implement the Node interface.
-type Node interface {
-	Idx0() file.Idx // The index of the first character belonging to the node
-	Idx1() file.Idx // The index of the first character immediately after the node
-}
-
-// ========== //
-// Expression //
-// ========== //
-
-type (
-	// All expression nodes implement the Expression interface.
-	Expression interface {
-		Node
-		_expressionNode()
-	}
-
-	ArrayLiteral struct {
-		LeftBracket  file.Idx
-		RightBracket file.Idx
-		Value        []Expression
-	}
-
-	AssignExpression struct {
-		Operator token.Token
-		Left     Expression
-		Right    Expression
-	}
-
-	BadExpression struct {
-		From file.Idx
-		To   file.Idx
-	}
-
-	BinaryExpression struct {
-		Operator   token.Token
-		Left       Expression
-		Right      Expression
-		Comparison bool
-	}
-
-	BooleanLiteral struct {
-		Idx     file.Idx
-		Literal string
-		Value   bool
-	}
-
-	BracketExpression struct {
-		Left         Expression
-		Member       Expression
-		LeftBracket  file.Idx
-		RightBracket file.Idx
-	}
-
-	CallExpression struct {
-		Callee           Expression
-		LeftParenthesis  file.Idx
-		ArgumentList     []Expression
-		RightParenthesis file.Idx
-	}
-
-	ConditionalExpression struct {
-		Test       Expression
-		Consequent Expression
-		Alternate  Expression
-	}
-
-	DotExpression struct {
-		Left       Expression
-		Identifier Identifier
-	}
-
-	EmptyExpression struct {
-		Begin file.Idx
-		End   file.Idx
-	}
-
-	FunctionLiteral struct {
-		Function      file.Idx
-		Name          *Identifier
-		ParameterList *ParameterList
-		Body          Statement
-		Source        string
-
-		DeclarationList []Declaration
-	}
-
-	Identifier struct {
-		Name string
-		Idx  file.Idx
-	}
-
-	NewExpression struct {
-		New              file.Idx
-		Callee           Expression
-		LeftParenthesis  file.Idx
-		ArgumentList     []Expression
-		RightParenthesis file.Idx
-	}
-
-	NullLiteral struct {
-		Idx     file.Idx
-		Literal string
-	}
-
-	NumberLiteral struct {
-		Idx     file.Idx
-		Literal string
-		Value   interface{}
-	}
-
-	ObjectLiteral struct {
-		LeftBrace  file.Idx
-		RightBrace file.Idx
-		Value      []Property
-	}
-
-	ParameterList struct {
-		Opening file.Idx
-		List    []*Identifier
-		Closing file.Idx
-	}
-
-	Property struct {
-		Key   string
-		Kind  string
-		Value Expression
-	}
-
-	RegExpLiteral struct {
-		Idx     file.Idx
-		Literal string
-		Pattern string
-		Flags   string
-		Value   string
-	}
-
-	SequenceExpression struct {
-		Sequence []Expression
-	}
-
-	StringLiteral struct {
-		Idx     file.Idx
-		Literal string
-		Value   string
-	}
-
-	ThisExpression struct {
-		Idx file.Idx
-	}
-
-	UnaryExpression struct {
-		Operator token.Token
-		Idx      file.Idx // If a prefix operation
-		Operand  Expression
-		Postfix  bool
-	}
-
-	VariableExpression struct {
-		Name        string
-		Idx         file.Idx
-		Initializer Expression
-	}
-)
-
-// _expressionNode
-
-func (*ArrayLiteral) _expressionNode()          {}
-func (*AssignExpression) _expressionNode()      {}
-func (*BadExpression) _expressionNode()         {}
-func (*BinaryExpression) _expressionNode()      {}
-func (*BooleanLiteral) _expressionNode()        {}
-func (*BracketExpression) _expressionNode()     {}
-func (*CallExpression) _expressionNode()        {}
-func (*ConditionalExpression) _expressionNode() {}
-func (*DotExpression) _expressionNode()         {}
-func (*EmptyExpression) _expressionNode()       {}
-func (*FunctionLiteral) _expressionNode()       {}
-func (*Identifier) _expressionNode()            {}
-func (*NewExpression) _expressionNode()         {}
-func (*NullLiteral) _expressionNode()           {}
-func (*NumberLiteral) _expressionNode()         {}
-func (*ObjectLiteral) _expressionNode()         {}
-func (*RegExpLiteral) _expressionNode()         {}
-func (*SequenceExpression) _expressionNode()    {}
-func (*StringLiteral) _expressionNode()         {}
-func (*ThisExpression) _expressionNode()        {}
-func (*UnaryExpression) _expressionNode()       {}
-func (*VariableExpression) _expressionNode()    {}
-
-// ========= //
-// Statement //
-// ========= //
-
-type (
-	// All statement nodes implement the Statement interface.
-	Statement interface {
-		Node
-		_statementNode()
-	}
-
-	BadStatement struct {
-		From file.Idx
-		To   file.Idx
-	}
-
-	BlockStatement struct {
-		LeftBrace  file.Idx
-		List       []Statement
-		RightBrace file.Idx
-	}
-
-	BranchStatement struct {
-		Idx   file.Idx
-		Token token.Token
-		Label *Identifier
-	}
-
-	CaseStatement struct {
-		Case       file.Idx
-		Test       Expression
-		Consequent []Statement
-	}
-
-	CatchStatement struct {
-		Catch     file.Idx
-		Parameter *Identifier
-		Body      Statement
-	}
-
-	DebuggerStatement struct {
-		Debugger file.Idx
-	}
-
-	DoWhileStatement struct {
-		Do   file.Idx
-		Test Expression
-		Body Statement
-	}
-
-	EmptyStatement struct {
-		Semicolon file.Idx
-	}
-
-	ExpressionStatement struct {
-		Expression Expression
-	}
-
-	ForInStatement struct {
-		For    file.Idx
-		Into   Expression
-		Source Expression
-		Body   Statement
-	}
-
-	ForStatement struct {
-		For         file.Idx
-		Initializer Expression
-		Update      Expression
-		Test        Expression
-		Body        Statement
-	}
-
-	IfStatement struct {
-		If         file.Idx
-		Test       Expression
-		Consequent Statement
-		Alternate  Statement
-	}
-
-	LabelledStatement struct {
-		Label     *Identifier
-		Colon     file.Idx
-		Statement Statement
-	}
-
-	ReturnStatement struct {
-		Return   file.Idx
-		Argument Expression
-	}
-
-	SwitchStatement struct {
-		Switch       file.Idx
-		Discriminant Expression
-		Default      int
-		Body         []*CaseStatement
-	}
-
-	ThrowStatement struct {
-		Throw    file.Idx
-		Argument Expression
-	}
-
-	TryStatement struct {
-		Try     file.Idx
-		Body    Statement
-		Catch   *CatchStatement
-		Finally Statement
-	}
-
-	VariableStatement struct {
-		Var  file.Idx
-		List []Expression
-	}
-
-	WhileStatement struct {
-		While file.Idx
-		Test  Expression
-		Body  Statement
-	}
-
-	WithStatement struct {
-		With   file.Idx
-		Object Expression
-		Body   Statement
-	}
-)
-
-// _statementNode
-
-func (*BadStatement) _statementNode()        {}
-func (*BlockStatement) _statementNode()      {}
-func (*BranchStatement) _statementNode()     {}
-func (*CaseStatement) _statementNode()       {}
-func (*CatchStatement) _statementNode()      {}
-func (*DebuggerStatement) _statementNode()   {}
-func (*DoWhileStatement) _statementNode()    {}
-func (*EmptyStatement) _statementNode()      {}
-func (*ExpressionStatement) _statementNode() {}
-func (*ForInStatement) _statementNode()      {}
-func (*ForStatement) _statementNode()        {}
-func (*IfStatement) _statementNode()         {}
-func (*LabelledStatement) _statementNode()   {}
-func (*ReturnStatement) _statementNode()     {}
-func (*SwitchStatement) _statementNode()     {}
-func (*ThrowStatement) _statementNode()      {}
-func (*TryStatement) _statementNode()        {}
-func (*VariableStatement) _statementNode()   {}
-func (*WhileStatement) _statementNode()      {}
-func (*WithStatement) _statementNode()       {}
-
-// =========== //
-// Declaration //
-// =========== //
-
-type (
-	// All declaration nodes implement the Declaration interface.
-	Declaration interface {
-		_declarationNode()
-	}
-
-	FunctionDeclaration struct {
-		Function *FunctionLiteral
-	}
-
-	VariableDeclaration struct {
-		Var  file.Idx
-		List []*VariableExpression
-	}
-)
-
-// _declarationNode
-
-func (*FunctionDeclaration) _declarationNode() {}
-func (*VariableDeclaration) _declarationNode() {}
-
-// ==== //
-// Node //
-// ==== //
-
-type Program struct {
-	Body []Statement
-
-	DeclarationList []Declaration
-
-	File *file.File
-}
-
-// ==== //
-// Idx0 //
-// ==== //
-
-func (self *ArrayLiteral) Idx0() file.Idx          { return self.LeftBracket }
-func (self *AssignExpression) Idx0() file.Idx      { return self.Left.Idx0() }
-func (self *BadExpression) Idx0() file.Idx         { return self.From }
-func (self *BinaryExpression) Idx0() file.Idx      { return self.Left.Idx0() }
-func (self *BooleanLiteral) Idx0() file.Idx        { return self.Idx }
-func (self *BracketExpression) Idx0() file.Idx     { return self.Left.Idx0() }
-func (self *CallExpression) Idx0() file.Idx        { return self.Callee.Idx0() }
-func (self *ConditionalExpression) Idx0() file.Idx { return self.Test.Idx0() }
-func (self *DotExpression) Idx0() file.Idx         { return self.Left.Idx0() }
-func (self *EmptyExpression) Idx0() file.Idx       { return self.Begin }
-func (self *FunctionLiteral) Idx0() file.Idx       { return self.Function }
-func (self *Identifier) Idx0() file.Idx            { return self.Idx }
-func (self *NewExpression) Idx0() file.Idx         { return self.New }
-func (self *NullLiteral) Idx0() file.Idx           { return self.Idx }
-func (self *NumberLiteral) Idx0() file.Idx         { return self.Idx }
-func (self *ObjectLiteral) Idx0() file.Idx         { return self.LeftBrace }
-func (self *RegExpLiteral) Idx0() file.Idx         { return self.Idx }
-func (self *SequenceExpression) Idx0() file.Idx    { return self.Sequence[0].Idx0() }
-func (self *StringLiteral) Idx0() file.Idx         { return self.Idx }
-func (self *ThisExpression) Idx0() file.Idx        { return self.Idx }
-func (self *UnaryExpression) Idx0() file.Idx       { return self.Idx }
-func (self *VariableExpression) Idx0() file.Idx    { return self.Idx }
-
-func (self *BadStatement) Idx0() file.Idx        { return self.From }
-func (self *BlockStatement) Idx0() file.Idx      { return self.LeftBrace }
-func (self *BranchStatement) Idx0() file.Idx     { return self.Idx }
-func (self *CaseStatement) Idx0() file.Idx       { return self.Case }
-func (self *CatchStatement) Idx0() file.Idx      { return self.Catch }
-func (self *DebuggerStatement) Idx0() file.Idx   { return self.Debugger }
-func (self *DoWhileStatement) Idx0() file.Idx    { return self.Do }
-func (self *EmptyStatement) Idx0() file.Idx      { return self.Semicolon }
-func (self *ExpressionStatement) Idx0() file.Idx { return self.Expression.Idx0() }
-func (self *ForInStatement) Idx0() file.Idx      { return self.For }
-func (self *ForStatement) Idx0() file.Idx        { return self.For }
-func (self *IfStatement) Idx0() file.Idx         { return self.If }
-func (self *LabelledStatement) Idx0() file.Idx   { return self.Label.Idx0() }
-func (self *Program) Idx0() file.Idx             { return self.Body[0].Idx0() }
-func (self *ReturnStatement) Idx0() file.Idx     { return self.Return }
-func (self *SwitchStatement) Idx0() file.Idx     { return self.Switch }
-func (self *ThrowStatement) Idx0() file.Idx      { return self.Throw }
-func (self *TryStatement) Idx0() file.Idx        { return self.Try }
-func (self *VariableStatement) Idx0() file.Idx   { return self.Var }
-func (self *WhileStatement) Idx0() file.Idx      { return self.While }
-func (self *WithStatement) Idx0() file.Idx       { return self.With }
-
-// ==== //
-// Idx1 //
-// ==== //
-
-func (self *ArrayLiteral) Idx1() file.Idx          { return self.RightBracket }
-func (self *AssignExpression) Idx1() file.Idx      { return self.Right.Idx1() }
-func (self *BadExpression) Idx1() file.Idx         { return self.To }
-func (self *BinaryExpression) Idx1() file.Idx      { return self.Right.Idx1() }
-func (self *BooleanLiteral) Idx1() file.Idx        { return file.Idx(int(self.Idx) + len(self.Literal)) }
-func (self *BracketExpression) Idx1() file.Idx     { return self.RightBracket + 1 }
-func (self *CallExpression) Idx1() file.Idx        { return self.RightParenthesis + 1 }
-func (self *ConditionalExpression) Idx1() file.Idx { return self.Test.Idx1() }
-func (self *DotExpression) Idx1() file.Idx         { return self.Identifier.Idx1() }
-func (self *EmptyExpression) Idx1() file.Idx       { return self.End }
-func (self *FunctionLiteral) Idx1() file.Idx       { return self.Body.Idx1() }
-func (self *Identifier) Idx1() file.Idx            { return file.Idx(int(self.Idx) + len(self.Name)) }
-func (self *NewExpression) Idx1() file.Idx         { return self.RightParenthesis + 1 }
-func (self *NullLiteral) Idx1() file.Idx           { return file.Idx(int(self.Idx) + 4) } // "null"
-func (self *NumberLiteral) Idx1() file.Idx         { return file.Idx(int(self.Idx) + len(self.Literal)) }
-func (self *ObjectLiteral) Idx1() file.Idx         { return self.RightBrace }
-func (self *RegExpLiteral) Idx1() file.Idx         { return file.Idx(int(self.Idx) + len(self.Literal)) }
-func (self *SequenceExpression) Idx1() file.Idx    { return self.Sequence[0].Idx1() }
-func (self *StringLiteral) Idx1() file.Idx         { return file.Idx(int(self.Idx) + len(self.Literal)) }
-func (self *ThisExpression) Idx1() file.Idx        { return self.Idx }
-func (self *UnaryExpression) Idx1() file.Idx {
-	if self.Postfix {
-		return self.Operand.Idx1() + 2 // ++ --
-	}
-	return self.Operand.Idx1()
-}
-func (self *VariableExpression) Idx1() file.Idx {
-	if self.Initializer == nil {
-		return file.Idx(int(self.Idx) + len(self.Name) + 1)
-	}
-	return self.Initializer.Idx1()
-}
-
-func (self *BadStatement) Idx1() file.Idx        { return self.To }
-func (self *BlockStatement) Idx1() file.Idx      { return self.RightBrace + 1 }
-func (self *BranchStatement) Idx1() file.Idx     { return self.Idx }
-func (self *CaseStatement) Idx1() file.Idx       { return self.Consequent[len(self.Consequent)-1].Idx1() }
-func (self *CatchStatement) Idx1() file.Idx      { return self.Body.Idx1() }
-func (self *DebuggerStatement) Idx1() file.Idx   { return self.Debugger + 8 }
-func (self *DoWhileStatement) Idx1() file.Idx    { return self.Test.Idx1() }
-func (self *EmptyStatement) Idx1() file.Idx      { return self.Semicolon + 1 }
-func (self *ExpressionStatement) Idx1() file.Idx { return self.Expression.Idx1() }
-func (self *ForInStatement) Idx1() file.Idx      { return self.Body.Idx1() }
-func (self *ForStatement) Idx1() file.Idx        { return self.Body.Idx1() }
-func (self *IfStatement) Idx1() file.Idx {
-	if self.Alternate != nil {
-		return self.Alternate.Idx1()
-	}
-	return self.Consequent.Idx1()
-}
-func (self *LabelledStatement) Idx1() file.Idx { return self.Colon + 1 }
-func (self *Program) Idx1() file.Idx           { return self.Body[len(self.Body)-1].Idx1() }
-func (self *ReturnStatement) Idx1() file.Idx   { return self.Return }
-func (self *SwitchStatement) Idx1() file.Idx   { return self.Body[len(self.Body)-1].Idx1() }
-func (self *ThrowStatement) Idx1() file.Idx    { return self.Throw }
-func (self *TryStatement) Idx1() file.Idx      { return self.Try }
-func (self *VariableStatement) Idx1() file.Idx { return self.List[len(self.List)-1].Idx1() }
-func (self *WhileStatement) Idx1() file.Idx    { return self.Body.Idx1() }
-func (self *WithStatement) Idx1() file.Idx     { return self.Body.Idx1() }
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin.go
deleted file mode 100644
index c3375a108..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin.go
+++ /dev/null
@@ -1,353 +0,0 @@
-package otto
-
-import (
-	"encoding/hex"
-	"math"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode/utf16"
-	"unicode/utf8"
-)
-
-// Global
-func builtinGlobal_eval(call FunctionCall) Value {
-	src := call.Argument(0)
-	if !src.IsString() {
-		return src
-	}
-	runtime := call.runtime
-	program := runtime.cmpl_parseOrThrow(src.string())
-	if !call.eval {
-		// Not a direct call to eval, so we enter the global ExecutionContext
-		runtime.enterGlobalScope()
-		defer runtime.leaveScope()
-	}
-	returnValue := runtime.cmpl_evaluate_nodeProgram(program, true)
-	if returnValue.isEmpty() {
-		return Value{}
-	}
-	return returnValue
-}
-
-func builtinGlobal_isNaN(call FunctionCall) Value {
-	value := call.Argument(0).float64()
-	return toValue_bool(math.IsNaN(value))
-}
-
-func builtinGlobal_isFinite(call FunctionCall) Value {
-	value := call.Argument(0).float64()
-	return toValue_bool(!math.IsNaN(value) && !math.IsInf(value, 0))
-}
-
-// radix 3 => 2 (ASCII 50) +47
-// radix 11 => A/a (ASCII 65/97) +54/+86
-var parseInt_alphabetTable = func() []string {
-	table := []string{"", "", "01"}
-	for radix := 3; radix <= 36; radix += 1 {
-		alphabet := table[radix-1]
-		if radix <= 10 {
-			alphabet += string(radix + 47)
-		} else {
-			alphabet += string(radix+54) + string(radix+86)
-		}
-		table = append(table, alphabet)
-	}
-	return table
-}()
-
-func digitValue(chr rune) int {
-	switch {
-	case '0' <= chr && chr <= '9':
-		return int(chr - '0')
-	case 'a' <= chr && chr <= 'z':
-		return int(chr - 'a' + 10)
-	case 'A' <= chr && chr <= 'Z':
-		return int(chr - 'A' + 10)
-	}
-	return 36 // Larger than any legal digit value
-}
-
-func builtinGlobal_parseInt(call FunctionCall) Value {
-	input := strings.TrimSpace(call.Argument(0).string())
-	if len(input) == 0 {
-		return NaNValue()
-	}
-
-	radix := int(toInt32(call.Argument(1)))
-
-	negative := false
-	switch input[0] {
-	case '+':
-		input = input[1:]
-	case '-':
-		negative = true
-		input = input[1:]
-	}
-
-	strip := true
-	if radix == 0 {
-		radix = 10
-	} else {
-		if radix < 2 || radix > 36 {
-			return NaNValue()
-		} else if radix != 16 {
-			strip = false
-		}
-	}
-
-	switch len(input) {
-	case 0:
-		return NaNValue()
-	case 1:
-	default:
-		if strip {
-			if input[0] == '0' && (input[1] == 'x' || input[1] == 'X') {
-				input = input[2:]
-				radix = 16
-			}
-		}
-	}
-
-	base := radix
-	index := 0
-	for ; index < len(input); index++ {
-		digit := digitValue(rune(input[index])) // If not ASCII, then an error anyway
-		if digit >= base {
-			break
-		}
-	}
-	input = input[0:index]
-
-	value, err := strconv.ParseInt(input, radix, 64)
-	if err != nil {
-		if err.(*strconv.NumError).Err == strconv.ErrRange {
-			base := float64(base)
-			// Could just be a very large number (e.g. 0x8000000000000000)
-			var value float64
-			for _, chr := range input {
-				digit := float64(digitValue(chr))
-				if digit >= base {
-					goto error
-				}
-				value = value*base + digit
-			}
-			if negative {
-				value *= -1
-			}
-			return toValue_float64(value)
-		}
-	error:
-		return NaNValue()
-	}
-	if negative {
-		value *= -1
-	}
-
-	return toValue_int64(value)
-}
-
-var parseFloat_matchBadSpecial = regexp.MustCompile(`[\+\-]?(?:[Ii]nf$|infinity)`)
-var parseFloat_matchValid = regexp.MustCompile(`[0-9eE\+\-\.]|Infinity`)
-
-func builtinGlobal_parseFloat(call FunctionCall) Value {
-	// Caveat emptor: This implementation does NOT match the specification
-	input := strings.TrimSpace(call.Argument(0).string())
-	if parseFloat_matchBadSpecial.MatchString(input) {
-		return NaNValue()
-	}
-	value, err := strconv.ParseFloat(input, 64)
-	if err != nil {
-		for end := len(input); end > 0; end -= 1 {
-			input := input[0:end]
-			if !parseFloat_matchValid.MatchString(input) {
-				return NaNValue()
-			}
-			value, err = strconv.ParseFloat(input, 64)
-			if err == nil {
-				break
-			}
-		}
-		if err != nil {
-			return NaNValue()
-		}
-	}
-	return toValue_float64(value)
-}
-
-// encodeURI/decodeURI
-
-func _builtinGlobal_encodeURI(call FunctionCall, escape *regexp.Regexp) Value {
-	value := call.Argument(0)
-	var input []uint16
-	switch vl := value.value.(type) {
-	case []uint16:
-		input = vl
-	default:
-		input = utf16.Encode([]rune(value.string()))
-	}
-	if len(input) == 0 {
-		return toValue_string("")
-	}
-	output := []byte{}
-	length := len(input)
-	encode := make([]byte, 4)
-	for index := 0; index < length; {
-		value := input[index]
-		decode := utf16.Decode(input[index : index+1])
-		if value >= 0xDC00 && value <= 0xDFFF {
-			panic(call.runtime.panicURIError("URI malformed"))
-		}
-		if value >= 0xD800 && value <= 0xDBFF {
-			index += 1
-			if index >= length {
-				panic(call.runtime.panicURIError("URI malformed"))
-			}
-			// input = ..., value, value1, ...
-			value1 := input[index]
-			if value1 < 0xDC00 || value1 > 0xDFFF {
-				panic(call.runtime.panicURIError("URI malformed"))
-			}
-			decode = []rune{((rune(value) - 0xD800) * 0x400) + (rune(value1) - 0xDC00) + 0x10000}
-		}
-		index += 1
-		size := utf8.EncodeRune(encode, decode[0])
-		encode := encode[0:size]
-		output = append(output, encode...)
-	}
-	{
-		value := escape.ReplaceAllFunc(output, func(target []byte) []byte {
-			// Probably a better way of doing this
-			if target[0] == ' ' {
-				return []byte("%20")
-			}
-			return []byte(url.QueryEscape(string(target)))
-		})
-		return toValue_string(string(value))
-	}
-}
-
-var encodeURI_Regexp = regexp.MustCompile(`([^~!@#$&*()=:/,;?+'])`)
-
-func builtinGlobal_encodeURI(call FunctionCall) Value {
-	return _builtinGlobal_encodeURI(call, encodeURI_Regexp)
-}
-
-var encodeURIComponent_Regexp = regexp.MustCompile(`([^~!*()'])`)
-
-func builtinGlobal_encodeURIComponent(call FunctionCall) Value {
-	return _builtinGlobal_encodeURI(call, encodeURIComponent_Regexp)
-}
-
-// 3B/2F/3F/3A/40/26/3D/2B/24/2C/23
-var decodeURI_guard = regexp.MustCompile(`(?i)(?:%)(3B|2F|3F|3A|40|26|3D|2B|24|2C|23)`)
-
-func _decodeURI(input string, reserve bool) (string, bool) {
-	if reserve {
-		input = decodeURI_guard.ReplaceAllString(input, "%25$1")
-	}
-	input = strings.Replace(input, "+", "%2B", -1) // Ugly hack to make QueryUnescape work with our use case
-	output, err := url.QueryUnescape(input)
-	if err != nil || !utf8.ValidString(output) {
-		return "", true
-	}
-	return output, false
-}
-
-func builtinGlobal_decodeURI(call FunctionCall) Value {
-	output, err := _decodeURI(call.Argument(0).string(), true)
-	if err {
-		panic(call.runtime.panicURIError("URI malformed"))
-	}
-	return toValue_string(output)
-}
-
-func builtinGlobal_decodeURIComponent(call FunctionCall) Value {
-	output, err := _decodeURI(call.Argument(0).string(), false)
-	if err {
-		panic(call.runtime.panicURIError("URI malformed"))
-	}
-	return toValue_string(output)
-}
-
-// escape/unescape
-
-func builtin_shouldEscape(chr byte) bool {
-	if 'A' <= chr && chr <= 'Z' || 'a' <= chr && chr <= 'z' || '0' <= chr && chr <= '9' {
-		return false
-	}
-	return !strings.ContainsRune("*_+-./", rune(chr))
-}
-
-const escapeBase16 = "0123456789ABCDEF"
-
-func builtin_escape(input string) string {
-	output := make([]byte, 0, len(input))
-	length := len(input)
-	for index := 0; index < length; {
-		if builtin_shouldEscape(input[index]) {
-			chr, width := utf8.DecodeRuneInString(input[index:])
-			chr16 := utf16.Encode([]rune{chr})[0]
-			if 256 > chr16 {
-				output = append(output, '%',
-					escapeBase16[chr16>>4],
-					escapeBase16[chr16&15],
-				)
-			} else {
-				output = append(output, '%', 'u',
-					escapeBase16[chr16>>12],
-					escapeBase16[(chr16>>8)&15],
-					escapeBase16[(chr16>>4)&15],
-					escapeBase16[chr16&15],
-				)
-			}
-			index += width
-
-		} else {
-			output = append(output, input[index])
-			index += 1
-		}
-	}
-	return string(output)
-}
-
-func builtin_unescape(input string) string {
-	output := make([]rune, 0, len(input))
-	length := len(input)
-	for index := 0; index < length; {
-		if input[index] == '%' {
-			if index <= length-6 && input[index+1] == 'u' {
-				byte16, err := hex.DecodeString(input[index+2 : index+6])
-				if err == nil {
-					value := uint16(byte16[0])<<8 + uint16(byte16[1])
-					chr := utf16.Decode([]uint16{value})[0]
-					output = append(output, chr)
-					index += 6
-					continue
-				}
-			}
-			if index <= length-3 {
-				byte8, err := hex.DecodeString(input[index+1 : index+3])
-				if err == nil {
-					value := uint16(byte8[0])
-					chr := utf16.Decode([]uint16{value})[0]
-					output = append(output, chr)
-					index += 3
-					continue
-				}
-			}
-		}
-		output = append(output, rune(input[index]))
-		index += 1
-	}
-	return string(output)
-}
-
-func builtinGlobal_escape(call FunctionCall) Value {
-	return toValue_string(builtin_escape(call.Argument(0).string()))
-}
-
-func builtinGlobal_unescape(call FunctionCall) Value {
-	return toValue_string(builtin_unescape(call.Argument(0).string()))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_array.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_array.go
deleted file mode 100644
index 160a251c6..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_array.go
+++ /dev/null
@@ -1,672 +0,0 @@
-package otto
-
-import (
-	"strconv"
-	"strings"
-)
-
-// Array
-
-func builtinArray(call FunctionCall) Value {
-	return toValue_object(builtinNewArrayNative(call.runtime, call.ArgumentList))
-}
-
-func builtinNewArray(self *_object, argumentList []Value) Value {
-	return toValue_object(builtinNewArrayNative(self.runtime, argumentList))
-}
-
-func builtinNewArrayNative(runtime *_runtime, argumentList []Value) *_object {
-	if len(argumentList) == 1 {
-		firstArgument := argumentList[0]
-		if firstArgument.IsNumber() {
-			return runtime.newArray(arrayUint32(runtime, firstArgument))
-		}
-	}
-	return runtime.newArrayOf(argumentList)
-}
-
-func builtinArray_toString(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	join := thisObject.get("join")
-	if join.isCallable() {
-		join := join._object()
-		return join.call(call.This, call.ArgumentList, false, nativeFrame)
-	}
-	return builtinObject_toString(call)
-}
-
-func builtinArray_toLocaleString(call FunctionCall) Value {
-	separator := ","
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-	if length == 0 {
-		return toValue_string("")
-	}
-	stringList := make([]string, 0, length)
-	for index := int64(0); index < length; index += 1 {
-		value := thisObject.get(arrayIndexToString(index))
-		stringValue := ""
-		switch value.kind {
-		case valueEmpty, valueUndefined, valueNull:
-		default:
-			object := call.runtime.toObject(value)
-			toLocaleString := object.get("toLocaleString")
-			if !toLocaleString.isCallable() {
-				panic(call.runtime.panicTypeError())
-			}
-			stringValue = toLocaleString.call(call.runtime, toValue_object(object)).string()
-		}
-		stringList = append(stringList, stringValue)
-	}
-	return toValue_string(strings.Join(stringList, separator))
-}
-
-func builtinArray_concat(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	valueArray := []Value{}
-	source := append([]Value{toValue_object(thisObject)}, call.ArgumentList...)
-	for _, item := range source {
-		switch item.kind {
-		case valueObject:
-			object := item._object()
-			if isArray(object) {
-				length := object.get("length").number().int64
-				for index := int64(0); index < length; index += 1 {
-					name := strconv.FormatInt(index, 10)
-					if object.hasProperty(name) {
-						valueArray = append(valueArray, object.get(name))
-					} else {
-						valueArray = append(valueArray, Value{})
-					}
-				}
-				continue
-			}
-			fallthrough
-		default:
-			valueArray = append(valueArray, item)
-		}
-	}
-	return toValue_object(call.runtime.newArrayOf(valueArray))
-}
-
-func builtinArray_shift(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-	if 0 == length {
-		thisObject.put("length", toValue_int64(0), true)
-		return Value{}
-	}
-	first := thisObject.get("0")
-	for index := int64(1); index < length; index++ {
-		from := arrayIndexToString(index)
-		to := arrayIndexToString(index - 1)
-		if thisObject.hasProperty(from) {
-			thisObject.put(to, thisObject.get(from), true)
-		} else {
-			thisObject.delete(to, true)
-		}
-	}
-	thisObject.delete(arrayIndexToString(length-1), true)
-	thisObject.put("length", toValue_int64(length-1), true)
-	return first
-}
-
-func builtinArray_push(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	itemList := call.ArgumentList
-	index := int64(toUint32(thisObject.get("length")))
-	for len(itemList) > 0 {
-		thisObject.put(arrayIndexToString(index), itemList[0], true)
-		itemList = itemList[1:]
-		index += 1
-	}
-	length := toValue_int64(index)
-	thisObject.put("length", length, true)
-	return length
-}
-
-func builtinArray_pop(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-	if 0 == length {
-		thisObject.put("length", toValue_uint32(0), true)
-		return Value{}
-	}
-	last := thisObject.get(arrayIndexToString(length - 1))
-	thisObject.delete(arrayIndexToString(length-1), true)
-	thisObject.put("length", toValue_int64(length-1), true)
-	return last
-}
-
-func builtinArray_join(call FunctionCall) Value {
-	separator := ","
-	{
-		argument := call.Argument(0)
-		if argument.IsDefined() {
-			separator = argument.string()
-		}
-	}
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-	if length == 0 {
-		return toValue_string("")
-	}
-	stringList := make([]string, 0, length)
-	for index := int64(0); index < length; index += 1 {
-		value := thisObject.get(arrayIndexToString(index))
-		stringValue := ""
-		switch value.kind {
-		case valueEmpty, valueUndefined, valueNull:
-		default:
-			stringValue = value.string()
-		}
-		stringList = append(stringList, stringValue)
-	}
-	return toValue_string(strings.Join(stringList, separator))
-}
-
-func builtinArray_splice(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-
-	start := valueToRangeIndex(call.Argument(0), length, false)
-	deleteCount := valueToRangeIndex(call.Argument(1), int64(length)-start, true)
-	valueArray := make([]Value, deleteCount)
-
-	for index := int64(0); index < deleteCount; index++ {
-		indexString := arrayIndexToString(int64(start + index))
-		if thisObject.hasProperty(indexString) {
-			valueArray[index] = thisObject.get(indexString)
-		}
-	}
-
-	// 0, <1, 2, 3, 4>, 5, 6, 7
-	// a, b
-	// length 8 - delete 4 @ start 1
-
-	itemList := []Value{}
-	itemCount := int64(len(call.ArgumentList))
-	if itemCount > 2 {
-		itemCount -= 2 // Less the first two arguments
-		itemList = call.ArgumentList[2:]
-	} else {
-		itemCount = 0
-	}
-	if itemCount < deleteCount {
-		// The Object/Array is shrinking
-		stop := int64(length) - deleteCount
-		// The new length of the Object/Array before
-		// appending the itemList remainder
-		// Stopping at the lower bound of the insertion:
-		// Move an item from the after the deleted portion
-		// to a position after the inserted portion
-		for index := start; index < stop; index++ {
-			from := arrayIndexToString(index + deleteCount) // Position just after deletion
-			to := arrayIndexToString(index + itemCount)     // Position just after splice (insertion)
-			if thisObject.hasProperty(from) {
-				thisObject.put(to, thisObject.get(from), true)
-			} else {
-				thisObject.delete(to, true)
-			}
-		}
-		// Delete off the end
-		// We don't bother to delete below <stop + itemCount> (if any) since those
-		// will be overwritten anyway
-		for index := int64(length); index > (stop + itemCount); index-- {
-			thisObject.delete(arrayIndexToString(index-1), true)
-		}
-	} else if itemCount > deleteCount {
-		// The Object/Array is growing
-		// The itemCount is greater than the deleteCount, so we do
-		// not have to worry about overwriting what we should be moving
-		// ---
-		// Starting from the upper bound of the deletion:
-		// Move an item from the after the deleted portion
-		// to a position after the inserted portion
-		for index := int64(length) - deleteCount; index > start; index-- {
-			from := arrayIndexToString(index + deleteCount - 1)
-			to := arrayIndexToString(index + itemCount - 1)
-			if thisObject.hasProperty(from) {
-				thisObject.put(to, thisObject.get(from), true)
-			} else {
-				thisObject.delete(to, true)
-			}
-		}
-	}
-
-	for index := int64(0); index < itemCount; index++ {
-		thisObject.put(arrayIndexToString(index+start), itemList[index], true)
-	}
-	thisObject.put("length", toValue_int64(int64(length)+itemCount-deleteCount), true)
-
-	return toValue_object(call.runtime.newArrayOf(valueArray))
-}
-
-func builtinArray_slice(call FunctionCall) Value {
-	thisObject := call.thisObject()
-
-	length := int64(toUint32(thisObject.get("length")))
-	start, end := rangeStartEnd(call.ArgumentList, length, false)
-
-	if start >= end {
-		// Always an empty array
-		return toValue_object(call.runtime.newArray(0))
-	}
-	sliceLength := end - start
-	sliceValueArray := make([]Value, sliceLength)
-
-	for index := int64(0); index < sliceLength; index++ {
-		from := arrayIndexToString(index + start)
-		if thisObject.hasProperty(from) {
-			sliceValueArray[index] = thisObject.get(from)
-		}
-	}
-
-	return toValue_object(call.runtime.newArrayOf(sliceValueArray))
-}
-
-func builtinArray_unshift(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-	itemList := call.ArgumentList
-	itemCount := int64(len(itemList))
-
-	for index := length; index > 0; index-- {
-		from := arrayIndexToString(index - 1)
-		to := arrayIndexToString(index + itemCount - 1)
-		if thisObject.hasProperty(from) {
-			thisObject.put(to, thisObject.get(from), true)
-		} else {
-			thisObject.delete(to, true)
-		}
-	}
-
-	for index := int64(0); index < itemCount; index++ {
-		thisObject.put(arrayIndexToString(index), itemList[index], true)
-	}
-
-	newLength := toValue_int64(length + itemCount)
-	thisObject.put("length", newLength, true)
-	return newLength
-}
-
-func builtinArray_reverse(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := int64(toUint32(thisObject.get("length")))
-
-	lower := struct {
-		name   string
-		index  int64
-		exists bool
-	}{}
-	upper := lower
-
-	lower.index = 0
-	middle := length / 2 // Division will floor
-
-	for lower.index != middle {
-		lower.name = arrayIndexToString(lower.index)
-		upper.index = length - lower.index - 1
-		upper.name = arrayIndexToString(upper.index)
-
-		lower.exists = thisObject.hasProperty(lower.name)
-		upper.exists = thisObject.hasProperty(upper.name)
-
-		if lower.exists && upper.exists {
-			lowerValue := thisObject.get(lower.name)
-			upperValue := thisObject.get(upper.name)
-			thisObject.put(lower.name, upperValue, true)
-			thisObject.put(upper.name, lowerValue, true)
-		} else if !lower.exists && upper.exists {
-			value := thisObject.get(upper.name)
-			thisObject.delete(upper.name, true)
-			thisObject.put(lower.name, value, true)
-		} else if lower.exists && !upper.exists {
-			value := thisObject.get(lower.name)
-			thisObject.delete(lower.name, true)
-			thisObject.put(upper.name, value, true)
-		} else {
-			// Nothing happens.
-		}
-
-		lower.index += 1
-	}
-
-	return call.This
-}
-
-func sortCompare(thisObject *_object, index0, index1 uint, compare *_object) int {
-	j := struct {
-		name    string
-		exists  bool
-		defined bool
-		value   string
-	}{}
-	k := j
-	j.name = arrayIndexToString(int64(index0))
-	j.exists = thisObject.hasProperty(j.name)
-	k.name = arrayIndexToString(int64(index1))
-	k.exists = thisObject.hasProperty(k.name)
-
-	if !j.exists && !k.exists {
-		return 0
-	} else if !j.exists {
-		return 1
-	} else if !k.exists {
-		return -1
-	}
-
-	x := thisObject.get(j.name)
-	y := thisObject.get(k.name)
-	j.defined = x.IsDefined()
-	k.defined = y.IsDefined()
-
-	if !j.defined && !k.defined {
-		return 0
-	} else if !j.defined {
-		return 1
-	} else if !k.defined {
-		return -1
-	}
-
-	if compare == nil {
-		j.value = x.string()
-		k.value = y.string()
-
-		if j.value == k.value {
-			return 0
-		} else if j.value < k.value {
-			return -1
-		}
-
-		return 1
-	}
-
-	return int(toInt32(compare.call(Value{}, []Value{x, y}, false, nativeFrame)))
-}
-
-func arraySortSwap(thisObject *_object, index0, index1 uint) {
-
-	j := struct {
-		name   string
-		exists bool
-	}{}
-	k := j
-
-	j.name = arrayIndexToString(int64(index0))
-	j.exists = thisObject.hasProperty(j.name)
-	k.name = arrayIndexToString(int64(index1))
-	k.exists = thisObject.hasProperty(k.name)
-
-	if j.exists && k.exists {
-		jValue := thisObject.get(j.name)
-		kValue := thisObject.get(k.name)
-		thisObject.put(j.name, kValue, true)
-		thisObject.put(k.name, jValue, true)
-	} else if !j.exists && k.exists {
-		value := thisObject.get(k.name)
-		thisObject.delete(k.name, true)
-		thisObject.put(j.name, value, true)
-	} else if j.exists && !k.exists {
-		value := thisObject.get(j.name)
-		thisObject.delete(j.name, true)
-		thisObject.put(k.name, value, true)
-	} else {
-		// Nothing happens.
-	}
-}
-
-func arraySortQuickPartition(thisObject *_object, left, right, pivot uint, compare *_object) uint {
-	arraySortSwap(thisObject, pivot, right) // Right is now the pivot value
-	cursor := left
-	for index := left; index < right; index++ {
-		if sortCompare(thisObject, index, right, compare) < 0 { // Compare to the pivot value
-			arraySortSwap(thisObject, index, cursor)
-			cursor += 1
-		}
-	}
-	arraySortSwap(thisObject, cursor, right)
-	return cursor
-}
-
-func arraySortQuickSort(thisObject *_object, left, right uint, compare *_object) {
-	if left < right {
-		pivot := left + (right-left)/2
-		pivot = arraySortQuickPartition(thisObject, left, right, pivot, compare)
-		if pivot > 0 {
-			arraySortQuickSort(thisObject, left, pivot-1, compare)
-		}
-		arraySortQuickSort(thisObject, pivot+1, right, compare)
-	}
-}
-
-func builtinArray_sort(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	length := uint(toUint32(thisObject.get("length")))
-	compareValue := call.Argument(0)
-	compare := compareValue._object()
-	if compareValue.IsUndefined() {
-	} else if !compareValue.isCallable() {
-		panic(call.runtime.panicTypeError())
-	}
-	if length > 1 {
-		arraySortQuickSort(thisObject, 0, length-1, compare)
-	}
-	return call.This
-}
-
-func builtinArray_isArray(call FunctionCall) Value {
-	return toValue_bool(isArray(call.Argument(0)._object()))
-}
-
-func builtinArray_indexOf(call FunctionCall) Value {
-	thisObject, matchValue := call.thisObject(), call.Argument(0)
-	if length := int64(toUint32(thisObject.get("length"))); length > 0 {
-		index := int64(0)
-		if len(call.ArgumentList) > 1 {
-			index = call.Argument(1).number().int64
-		}
-		if index < 0 {
-			if index += length; index < 0 {
-				index = 0
-			}
-		} else if index >= length {
-			index = -1
-		}
-		for ; index >= 0 && index < length; index++ {
-			name := arrayIndexToString(int64(index))
-			if !thisObject.hasProperty(name) {
-				continue
-			}
-			value := thisObject.get(name)
-			if strictEqualityComparison(matchValue, value) {
-				return toValue_uint32(uint32(index))
-			}
-		}
-	}
-	return toValue_int(-1)
-}
-
-func builtinArray_lastIndexOf(call FunctionCall) Value {
-	thisObject, matchValue := call.thisObject(), call.Argument(0)
-	length := int64(toUint32(thisObject.get("length")))
-	index := length - 1
-	if len(call.ArgumentList) > 1 {
-		index = call.Argument(1).number().int64
-	}
-	if 0 > index {
-		index += length
-	}
-	if index > length {
-		index = length - 1
-	} else if 0 > index {
-		return toValue_int(-1)
-	}
-	for ; index >= 0; index-- {
-		name := arrayIndexToString(int64(index))
-		if !thisObject.hasProperty(name) {
-			continue
-		}
-		value := thisObject.get(name)
-		if strictEqualityComparison(matchValue, value) {
-			return toValue_uint32(uint32(index))
-		}
-	}
-	return toValue_int(-1)
-}
-
-func builtinArray_every(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		length := int64(toUint32(thisObject.get("length")))
-		callThis := call.Argument(1)
-		for index := int64(0); index < length; index++ {
-			if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-				if value := thisObject.get(key); iterator.call(call.runtime, callThis, value, toValue_int64(index), this).bool() {
-					continue
-				}
-				return falseValue
-			}
-		}
-		return trueValue
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_some(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		length := int64(toUint32(thisObject.get("length")))
-		callThis := call.Argument(1)
-		for index := int64(0); index < length; index++ {
-			if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-				if value := thisObject.get(key); iterator.call(call.runtime, callThis, value, toValue_int64(index), this).bool() {
-					return trueValue
-				}
-			}
-		}
-		return falseValue
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_forEach(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		length := int64(toUint32(thisObject.get("length")))
-		callThis := call.Argument(1)
-		for index := int64(0); index < length; index++ {
-			if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-				iterator.call(call.runtime, callThis, thisObject.get(key), toValue_int64(index), this)
-			}
-		}
-		return Value{}
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_map(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		length := int64(toUint32(thisObject.get("length")))
-		callThis := call.Argument(1)
-		values := make([]Value, length)
-		for index := int64(0); index < length; index++ {
-			if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-				values[index] = iterator.call(call.runtime, callThis, thisObject.get(key), index, this)
-			} else {
-				values[index] = Value{}
-			}
-		}
-		return toValue_object(call.runtime.newArrayOf(values))
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_filter(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		length := int64(toUint32(thisObject.get("length")))
-		callThis := call.Argument(1)
-		values := make([]Value, 0)
-		for index := int64(0); index < length; index++ {
-			if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-				value := thisObject.get(key)
-				if iterator.call(call.runtime, callThis, value, index, this).bool() {
-					values = append(values, value)
-				}
-			}
-		}
-		return toValue_object(call.runtime.newArrayOf(values))
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_reduce(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		initial := len(call.ArgumentList) > 1
-		start := call.Argument(1)
-		length := int64(toUint32(thisObject.get("length")))
-		index := int64(0)
-		if length > 0 || initial {
-			var accumulator Value
-			if !initial {
-				for ; index < length; index++ {
-					if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-						accumulator = thisObject.get(key)
-						index++
-						break
-					}
-				}
-			} else {
-				accumulator = start
-			}
-			for ; index < length; index++ {
-				if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-					accumulator = iterator.call(call.runtime, Value{}, accumulator, thisObject.get(key), key, this)
-				}
-			}
-			return accumulator
-		}
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinArray_reduceRight(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	this := toValue_object(thisObject)
-	if iterator := call.Argument(0); iterator.isCallable() {
-		initial := len(call.ArgumentList) > 1
-		start := call.Argument(1)
-		length := int64(toUint32(thisObject.get("length")))
-		if length > 0 || initial {
-			index := length - 1
-			var accumulator Value
-			if !initial {
-				for ; index >= 0; index-- {
-					if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-						accumulator = thisObject.get(key)
-						index -= 1
-						break
-					}
-				}
-			} else {
-				accumulator = start
-			}
-			for ; index >= 0; index-- {
-				if key := arrayIndexToString(index); thisObject.hasProperty(key) {
-					accumulator = iterator.call(call.runtime, Value{}, accumulator, thisObject.get(key), key, this)
-				}
-			}
-			return accumulator
-		}
-	}
-	panic(call.runtime.panicTypeError())
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_boolean.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_boolean.go
deleted file mode 100644
index 59b8e789b..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_boolean.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package otto
-
-// Boolean
-
-func builtinBoolean(call FunctionCall) Value {
-	return toValue_bool(call.Argument(0).bool())
-}
-
-func builtinNewBoolean(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newBoolean(valueOfArrayIndex(argumentList, 0)))
-}
-
-func builtinBoolean_toString(call FunctionCall) Value {
-	value := call.This
-	if !value.IsBoolean() {
-		// Will throw a TypeError if ThisObject is not a Boolean
-		value = call.thisClassObject("Boolean").primitiveValue()
-	}
-	return toValue_string(value.string())
-}
-
-func builtinBoolean_valueOf(call FunctionCall) Value {
-	value := call.This
-	if !value.IsBoolean() {
-		value = call.thisClassObject("Boolean").primitiveValue()
-	}
-	return value
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_date.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_date.go
deleted file mode 100644
index f20bf8e3f..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_date.go
+++ /dev/null
@@ -1,615 +0,0 @@
-package otto
-
-import (
-	"math"
-	Time "time"
-)
-
-// Date
-
-const (
-	// TODO Be like V8?
-	// builtinDate_goDateTimeLayout = "Mon Jan 2 2006 15:04:05 GMT-0700 (MST)"
-	builtinDate_goDateTimeLayout = Time.RFC1123 // "Mon, 02 Jan 2006 15:04:05 MST"
-	builtinDate_goDateLayout     = "Mon, 02 Jan 2006"
-	builtinDate_goTimeLayout     = "15:04:05 MST"
-)
-
-func builtinDate(call FunctionCall) Value {
-	date := &_dateObject{}
-	date.Set(newDateTime([]Value{}, Time.Local))
-	return toValue_string(date.Time().Format(builtinDate_goDateTimeLayout))
-}
-
-func builtinNewDate(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newDate(newDateTime(argumentList, Time.Local)))
-}
-
-func builtinDate_toString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format(builtinDate_goDateTimeLayout))
-}
-
-func builtinDate_toDateString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format(builtinDate_goDateLayout))
-}
-
-func builtinDate_toTimeString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format(builtinDate_goTimeLayout))
-}
-
-func builtinDate_toUTCString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Format(builtinDate_goDateTimeLayout))
-}
-
-func builtinDate_toISOString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Format("2006-01-02T15:04:05.000Z"))
-}
-
-func builtinDate_toJSON(call FunctionCall) Value {
-	object := call.thisObject()
-	value := object.DefaultValue(defaultValueHintNumber) // FIXME object.primitiveNumberValue
-	{                                                    // FIXME value.isFinite
-		value := value.float64()
-		if math.IsNaN(value) || math.IsInf(value, 0) {
-			return nullValue
-		}
-	}
-	toISOString := object.get("toISOString")
-	if !toISOString.isCallable() {
-		// FIXME
-		panic(call.runtime.panicTypeError())
-	}
-	return toISOString.call(call.runtime, toValue_object(object), []Value{})
-}
-
-func builtinDate_toGMTString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Format("Mon, 02 Jan 2006 15:04:05 GMT"))
-}
-
-func builtinDate_getTime(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	// We do this (convert away from a float) so the user
-	// does not get something back in exponential notation
-	return toValue_int64(int64(date.Epoch()))
-}
-
-func builtinDate_setTime(call FunctionCall) Value {
-	object := call.thisObject()
-	date := dateObjectOf(call.runtime, call.thisObject())
-	date.Set(call.Argument(0).float64())
-	object.value = date
-	return date.Value()
-}
-
-func _builtinDate_beforeSet(call FunctionCall, argumentLimit int, timeLocal bool) (*_object, *_dateObject, *_ecmaTime, []int) {
-	object := call.thisObject()
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return nil, nil, nil, nil
-	}
-
-	if argumentLimit > len(call.ArgumentList) {
-		argumentLimit = len(call.ArgumentList)
-	}
-
-	if argumentLimit == 0 {
-		object.value = invalidDateObject
-		return nil, nil, nil, nil
-	}
-
-	valueList := make([]int, argumentLimit)
-	for index := 0; index < argumentLimit; index++ {
-		value := call.ArgumentList[index]
-		nm := value.number()
-		switch nm.kind {
-		case numberInteger, numberFloat:
-		default:
-			object.value = invalidDateObject
-			return nil, nil, nil, nil
-		}
-		valueList[index] = int(nm.int64)
-	}
-	baseTime := date.Time()
-	if timeLocal {
-		baseTime = baseTime.Local()
-	}
-	ecmaTime := ecmaTime(baseTime)
-	return object, &date, &ecmaTime, valueList
-}
-
-func builtinDate_parse(call FunctionCall) Value {
-	date := call.Argument(0).string()
-	return toValue_float64(dateParse(date))
-}
-
-func builtinDate_UTC(call FunctionCall) Value {
-	return toValue_float64(newDateTime(call.ArgumentList, Time.UTC))
-}
-
-func builtinDate_now(call FunctionCall) Value {
-	call.ArgumentList = []Value(nil)
-	return builtinDate_UTC(call)
-}
-
-// This is a placeholder
-func builtinDate_toLocaleString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format("2006-01-02 15:04:05"))
-}
-
-// This is a placeholder
-func builtinDate_toLocaleDateString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format("2006-01-02"))
-}
-
-// This is a placeholder
-func builtinDate_toLocaleTimeString(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return toValue_string("Invalid Date")
-	}
-	return toValue_string(date.Time().Local().Format("15:04:05"))
-}
-
-func builtinDate_valueOf(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return date.Value()
-}
-
-func builtinDate_getYear(call FunctionCall) Value {
-	// Will throw a TypeError is ThisObject is nil or
-	// does not have Class of "Date"
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Year() - 1900)
-}
-
-func builtinDate_getFullYear(call FunctionCall) Value {
-	// Will throw a TypeError is ThisObject is nil or
-	// does not have Class of "Date"
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Year())
-}
-
-func builtinDate_getUTCFullYear(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Year())
-}
-
-func builtinDate_getMonth(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(dateFromGoMonth(date.Time().Local().Month()))
-}
-
-func builtinDate_getUTCMonth(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(dateFromGoMonth(date.Time().Month()))
-}
-
-func builtinDate_getDate(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Day())
-}
-
-func builtinDate_getUTCDate(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Day())
-}
-
-func builtinDate_getDay(call FunctionCall) Value {
-	// Actually day of the week
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(dateFromGoDay(date.Time().Local().Weekday()))
-}
-
-func builtinDate_getUTCDay(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(dateFromGoDay(date.Time().Weekday()))
-}
-
-func builtinDate_getHours(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Hour())
-}
-
-func builtinDate_getUTCHours(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Hour())
-}
-
-func builtinDate_getMinutes(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Minute())
-}
-
-func builtinDate_getUTCMinutes(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Minute())
-}
-
-func builtinDate_getSeconds(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Second())
-}
-
-func builtinDate_getUTCSeconds(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Second())
-}
-
-func builtinDate_getMilliseconds(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Local().Nanosecond() / (100 * 100 * 100))
-}
-
-func builtinDate_getUTCMilliseconds(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	return toValue_int(date.Time().Nanosecond() / (100 * 100 * 100))
-}
-
-func builtinDate_getTimezoneOffset(call FunctionCall) Value {
-	date := dateObjectOf(call.runtime, call.thisObject())
-	if date.isNaN {
-		return NaNValue()
-	}
-	timeLocal := date.Time().Local()
-	// Is this kosher?
-	timeLocalAsUTC := Time.Date(
-		timeLocal.Year(),
-		timeLocal.Month(),
-		timeLocal.Day(),
-		timeLocal.Hour(),
-		timeLocal.Minute(),
-		timeLocal.Second(),
-		timeLocal.Nanosecond(),
-		Time.UTC,
-	)
-	return toValue_float64(date.Time().Sub(timeLocalAsUTC).Seconds() / 60)
-}
-
-func builtinDate_setMilliseconds(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 1, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	ecmaTime.millisecond = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCMilliseconds(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 1, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	ecmaTime.millisecond = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setSeconds(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 2, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 1 {
-		ecmaTime.millisecond = value[1]
-	}
-	ecmaTime.second = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCSeconds(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 2, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 1 {
-		ecmaTime.millisecond = value[1]
-	}
-	ecmaTime.second = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setMinutes(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 3, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 2 {
-		ecmaTime.millisecond = value[2]
-		ecmaTime.second = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.second = value[1]
-	}
-	ecmaTime.minute = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCMinutes(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 3, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 2 {
-		ecmaTime.millisecond = value[2]
-		ecmaTime.second = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.second = value[1]
-	}
-	ecmaTime.minute = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setHours(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 4, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 3 {
-		ecmaTime.millisecond = value[3]
-		ecmaTime.second = value[2]
-		ecmaTime.minute = value[1]
-	} else if len(value) > 2 {
-		ecmaTime.second = value[2]
-		ecmaTime.minute = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.minute = value[1]
-	}
-	ecmaTime.hour = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCHours(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 4, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 3 {
-		ecmaTime.millisecond = value[3]
-		ecmaTime.second = value[2]
-		ecmaTime.minute = value[1]
-	} else if len(value) > 2 {
-		ecmaTime.second = value[2]
-		ecmaTime.minute = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.minute = value[1]
-	}
-	ecmaTime.hour = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setDate(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 1, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	ecmaTime.day = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCDate(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 1, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	ecmaTime.day = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setMonth(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 2, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 1 {
-		ecmaTime.day = value[1]
-	}
-	ecmaTime.month = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCMonth(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 2, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 1 {
-		ecmaTime.day = value[1]
-	}
-	ecmaTime.month = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setYear(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 1, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	year := value[0]
-	if 0 <= year && year <= 99 {
-		year += 1900
-	}
-	ecmaTime.year = year
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setFullYear(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 3, true)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 2 {
-		ecmaTime.day = value[2]
-		ecmaTime.month = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.month = value[1]
-	}
-	ecmaTime.year = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-func builtinDate_setUTCFullYear(call FunctionCall) Value {
-	object, date, ecmaTime, value := _builtinDate_beforeSet(call, 3, false)
-	if ecmaTime == nil {
-		return NaNValue()
-	}
-
-	if len(value) > 2 {
-		ecmaTime.day = value[2]
-		ecmaTime.month = value[1]
-	} else if len(value) > 1 {
-		ecmaTime.month = value[1]
-	}
-	ecmaTime.year = value[0]
-
-	date.SetTime(ecmaTime.goTime())
-	object.value = *date
-	return date.Value()
-}
-
-// toUTCString
-// toISOString
-// toJSONString
-// toJSON
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_error.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_error.go
deleted file mode 100644
index 4c054fbea..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_error.go
+++ /dev/null
@@ -1,126 +0,0 @@
-package otto
-
-import (
-	"fmt"
-)
-
-func builtinError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newError("", call.Argument(0)))
-}
-
-func builtinNewError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newError("", valueOfArrayIndex(argumentList, 0)))
-}
-
-func builtinError_toString(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	if thisObject == nil {
-		panic(call.runtime.panicTypeError())
-	}
-
-	name := "Error"
-	nameValue := thisObject.get("name")
-	if nameValue.IsDefined() {
-		name = nameValue.string()
-	}
-
-	message := ""
-	messageValue := thisObject.get("message")
-	if messageValue.IsDefined() {
-		message = messageValue.string()
-	}
-
-	if len(name) == 0 {
-		return toValue_string(message)
-	}
-
-	if len(message) == 0 {
-		return toValue_string(name)
-	}
-
-	return toValue_string(fmt.Sprintf("%s: %s", name, message))
-}
-
-func (runtime *_runtime) newEvalError(message Value) *_object {
-	self := runtime.newErrorObject("EvalError", message)
-	self.prototype = runtime.global.EvalErrorPrototype
-	return self
-}
-
-func builtinEvalError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newEvalError(call.Argument(0)))
-}
-
-func builtinNewEvalError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newEvalError(valueOfArrayIndex(argumentList, 0)))
-}
-
-func (runtime *_runtime) newTypeError(message Value) *_object {
-	self := runtime.newErrorObject("TypeError", message)
-	self.prototype = runtime.global.TypeErrorPrototype
-	return self
-}
-
-func builtinTypeError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newTypeError(call.Argument(0)))
-}
-
-func builtinNewTypeError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newTypeError(valueOfArrayIndex(argumentList, 0)))
-}
-
-func (runtime *_runtime) newRangeError(message Value) *_object {
-	self := runtime.newErrorObject("RangeError", message)
-	self.prototype = runtime.global.RangeErrorPrototype
-	return self
-}
-
-func builtinRangeError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newRangeError(call.Argument(0)))
-}
-
-func builtinNewRangeError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newRangeError(valueOfArrayIndex(argumentList, 0)))
-}
-
-func (runtime *_runtime) newURIError(message Value) *_object {
-	self := runtime.newErrorObject("URIError", message)
-	self.prototype = runtime.global.URIErrorPrototype
-	return self
-}
-
-func (runtime *_runtime) newReferenceError(message Value) *_object {
-	self := runtime.newErrorObject("ReferenceError", message)
-	self.prototype = runtime.global.ReferenceErrorPrototype
-	return self
-}
-
-func builtinReferenceError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newReferenceError(call.Argument(0)))
-}
-
-func builtinNewReferenceError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newReferenceError(valueOfArrayIndex(argumentList, 0)))
-}
-
-func (runtime *_runtime) newSyntaxError(message Value) *_object {
-	self := runtime.newErrorObject("SyntaxError", message)
-	self.prototype = runtime.global.SyntaxErrorPrototype
-	return self
-}
-
-func builtinSyntaxError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newSyntaxError(call.Argument(0)))
-}
-
-func builtinNewSyntaxError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newSyntaxError(valueOfArrayIndex(argumentList, 0)))
-}
-
-func builtinURIError(call FunctionCall) Value {
-	return toValue_object(call.runtime.newURIError(call.Argument(0)))
-}
-
-func builtinNewURIError(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newURIError(valueOfArrayIndex(argumentList, 0)))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_function.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_function.go
deleted file mode 100644
index 3d07566c6..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_function.go
+++ /dev/null
@@ -1,129 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-	"unicode"
-
-	"github.com/robertkrimen/otto/parser"
-)
-
-// Function
-
-func builtinFunction(call FunctionCall) Value {
-	return toValue_object(builtinNewFunctionNative(call.runtime, call.ArgumentList))
-}
-
-func builtinNewFunction(self *_object, argumentList []Value) Value {
-	return toValue_object(builtinNewFunctionNative(self.runtime, argumentList))
-}
-
-func argumentList2parameterList(argumentList []Value) []string {
-	parameterList := make([]string, 0, len(argumentList))
-	for _, value := range argumentList {
-		tmp := strings.FieldsFunc(value.string(), func(chr rune) bool {
-			return chr == ',' || unicode.IsSpace(chr)
-		})
-		parameterList = append(parameterList, tmp...)
-	}
-	return parameterList
-}
-
-var matchIdentifier = regexp.MustCompile(`^[$_\p{L}][$_\p{L}\d}]*$`)
-
-func builtinNewFunctionNative(runtime *_runtime, argumentList []Value) *_object {
-	var parameterList, body string
-	count := len(argumentList)
-	if count > 0 {
-		tmp := make([]string, 0, count-1)
-		for _, value := range argumentList[0 : count-1] {
-			tmp = append(tmp, value.string())
-		}
-		parameterList = strings.Join(tmp, ",")
-		body = argumentList[count-1].string()
-	}
-
-	// FIXME
-	function, err := parser.ParseFunction(parameterList, body)
-	runtime.parseThrow(err) // Will panic/throw appropriately
-	cmpl := _compiler{}
-	cmpl_function := cmpl.parseExpression(function)
-
-	return runtime.newNodeFunction(cmpl_function.(*_nodeFunctionLiteral), runtime.globalStash)
-}
-
-func builtinFunction_toString(call FunctionCall) Value {
-	object := call.thisClassObject("Function") // Should throw a TypeError unless Function
-	switch fn := object.value.(type) {
-	case _nativeFunctionObject:
-		return toValue_string(fmt.Sprintf("function %s() { [native code] }", fn.name))
-	case _nodeFunctionObject:
-		return toValue_string(fn.node.source)
-	case _bindFunctionObject:
-		return toValue_string("function () { [native code] }")
-	}
-
-	panic(call.runtime.panicTypeError("Function.toString()"))
-}
-
-func builtinFunction_apply(call FunctionCall) Value {
-	if !call.This.isCallable() {
-		panic(call.runtime.panicTypeError())
-	}
-	this := call.Argument(0)
-	if this.IsUndefined() {
-		// FIXME Not ECMA5
-		this = toValue_object(call.runtime.globalObject)
-	}
-	argumentList := call.Argument(1)
-	switch argumentList.kind {
-	case valueUndefined, valueNull:
-		return call.thisObject().call(this, nil, false, nativeFrame)
-	case valueObject:
-	default:
-		panic(call.runtime.panicTypeError())
-	}
-
-	arrayObject := argumentList._object()
-	thisObject := call.thisObject()
-	length := int64(toUint32(arrayObject.get("length")))
-	valueArray := make([]Value, length)
-	for index := int64(0); index < length; index++ {
-		valueArray[index] = arrayObject.get(arrayIndexToString(index))
-	}
-	return thisObject.call(this, valueArray, false, nativeFrame)
-}
-
-func builtinFunction_call(call FunctionCall) Value {
-	if !call.This.isCallable() {
-		panic(call.runtime.panicTypeError())
-	}
-	thisObject := call.thisObject()
-	this := call.Argument(0)
-	if this.IsUndefined() {
-		// FIXME Not ECMA5
-		this = toValue_object(call.runtime.globalObject)
-	}
-	if len(call.ArgumentList) >= 1 {
-		return thisObject.call(this, call.ArgumentList[1:], false, nativeFrame)
-	}
-	return thisObject.call(this, nil, false, nativeFrame)
-}
-
-func builtinFunction_bind(call FunctionCall) Value {
-	target := call.This
-	if !target.isCallable() {
-		panic(call.runtime.panicTypeError())
-	}
-	targetObject := target._object()
-
-	this := call.Argument(0)
-	argumentList := call.slice(1)
-	if this.IsUndefined() {
-		// FIXME Do this elsewhere?
-		this = toValue_object(call.runtime.globalObject)
-	}
-
-	return toValue_object(call.runtime.newBoundFunction(targetObject, this, argumentList))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_json.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_json.go
deleted file mode 100644
index aed54bf12..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_json.go
+++ /dev/null
@@ -1,299 +0,0 @@
-package otto
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-type _builtinJSON_parseContext struct {
-	call    FunctionCall
-	reviver Value
-}
-
-func builtinJSON_parse(call FunctionCall) Value {
-	ctx := _builtinJSON_parseContext{
-		call: call,
-	}
-	revive := false
-	if reviver := call.Argument(1); reviver.isCallable() {
-		revive = true
-		ctx.reviver = reviver
-	}
-
-	var root interface{}
-	err := json.Unmarshal([]byte(call.Argument(0).string()), &root)
-	if err != nil {
-		panic(call.runtime.panicSyntaxError(err.Error()))
-	}
-	value, exists := builtinJSON_parseWalk(ctx, root)
-	if !exists {
-		value = Value{}
-	}
-	if revive {
-		root := ctx.call.runtime.newObject()
-		root.put("", value, false)
-		return builtinJSON_reviveWalk(ctx, root, "")
-	}
-	return value
-}
-
-func builtinJSON_reviveWalk(ctx _builtinJSON_parseContext, holder *_object, name string) Value {
-	value := holder.get(name)
-	if object := value._object(); object != nil {
-		if isArray(object) {
-			length := int64(objectLength(object))
-			for index := int64(0); index < length; index += 1 {
-				name := arrayIndexToString(index)
-				value := builtinJSON_reviveWalk(ctx, object, name)
-				if value.IsUndefined() {
-					object.delete(name, false)
-				} else {
-					object.defineProperty(name, value, 0111, false)
-				}
-			}
-		} else {
-			object.enumerate(false, func(name string) bool {
-				value := builtinJSON_reviveWalk(ctx, object, name)
-				if value.IsUndefined() {
-					object.delete(name, false)
-				} else {
-					object.defineProperty(name, value, 0111, false)
-				}
-				return true
-			})
-		}
-	}
-	return ctx.reviver.call(ctx.call.runtime, toValue_object(holder), name, value)
-}
-
-func builtinJSON_parseWalk(ctx _builtinJSON_parseContext, rawValue interface{}) (Value, bool) {
-	switch value := rawValue.(type) {
-	case nil:
-		return nullValue, true
-	case bool:
-		return toValue_bool(value), true
-	case string:
-		return toValue_string(value), true
-	case float64:
-		return toValue_float64(value), true
-	case []interface{}:
-		arrayValue := make([]Value, len(value))
-		for index, rawValue := range value {
-			if value, exists := builtinJSON_parseWalk(ctx, rawValue); exists {
-				arrayValue[index] = value
-			}
-		}
-		return toValue_object(ctx.call.runtime.newArrayOf(arrayValue)), true
-	case map[string]interface{}:
-		object := ctx.call.runtime.newObject()
-		for name, rawValue := range value {
-			if value, exists := builtinJSON_parseWalk(ctx, rawValue); exists {
-				object.put(name, value, false)
-			}
-		}
-		return toValue_object(object), true
-	}
-	return Value{}, false
-}
-
-type _builtinJSON_stringifyContext struct {
-	call             FunctionCall
-	stack            []*_object
-	propertyList     []string
-	replacerFunction *Value
-	gap              string
-}
-
-func builtinJSON_stringify(call FunctionCall) Value {
-	ctx := _builtinJSON_stringifyContext{
-		call:  call,
-		stack: []*_object{nil},
-	}
-	replacer := call.Argument(1)._object()
-	if replacer != nil {
-		if isArray(replacer) {
-			length := objectLength(replacer)
-			seen := map[string]bool{}
-			propertyList := make([]string, length)
-			length = 0
-			for index, _ := range propertyList {
-				value := replacer.get(arrayIndexToString(int64(index)))
-				switch value.kind {
-				case valueObject:
-					switch value.value.(*_object).class {
-					case "String":
-					case "Number":
-					default:
-						continue
-					}
-				case valueString:
-				case valueNumber:
-				default:
-					continue
-				}
-				name := value.string()
-				if seen[name] {
-					continue
-				}
-				seen[name] = true
-				length += 1
-				propertyList[index] = name
-			}
-			ctx.propertyList = propertyList[0:length]
-		} else if replacer.class == "Function" {
-			value := toValue_object(replacer)
-			ctx.replacerFunction = &value
-		}
-	}
-	if spaceValue, exists := call.getArgument(2); exists {
-		if spaceValue.kind == valueObject {
-			switch spaceValue.value.(*_object).class {
-			case "String":
-				spaceValue = toValue_string(spaceValue.string())
-			case "Number":
-				spaceValue = spaceValue.numberValue()
-			}
-		}
-		switch spaceValue.kind {
-		case valueString:
-			value := spaceValue.string()
-			if len(value) > 10 {
-				ctx.gap = value[0:10]
-			} else {
-				ctx.gap = value
-			}
-		case valueNumber:
-			value := spaceValue.number().int64
-			if value > 10 {
-				value = 10
-			} else if value < 0 {
-				value = 0
-			}
-			ctx.gap = strings.Repeat(" ", int(value))
-		}
-	}
-	holder := call.runtime.newObject()
-	holder.put("", call.Argument(0), false)
-	value, exists := builtinJSON_stringifyWalk(ctx, "", holder)
-	if !exists {
-		return Value{}
-	}
-	valueJSON, err := json.Marshal(value)
-	if err != nil {
-		panic(call.runtime.panicTypeError(err.Error()))
-	}
-	if ctx.gap != "" {
-		valueJSON1 := bytes.Buffer{}
-		json.Indent(&valueJSON1, valueJSON, "", ctx.gap)
-		valueJSON = valueJSON1.Bytes()
-	}
-	return toValue_string(string(valueJSON))
-}
-
-func builtinJSON_stringifyWalk(ctx _builtinJSON_stringifyContext, key string, holder *_object) (interface{}, bool) {
-	value := holder.get(key)
-
-	if value.IsObject() {
-		object := value._object()
-		if toJSON := object.get("toJSON"); toJSON.IsFunction() {
-			value = toJSON.call(ctx.call.runtime, value, key)
-		} else {
-			// If the object is a GoStruct or something that implements json.Marshaler
-			if object.objectClass.marshalJSON != nil {
-				marshaler := object.objectClass.marshalJSON(object)
-				if marshaler != nil {
-					return marshaler, true
-				}
-			}
-		}
-	}
-
-	if ctx.replacerFunction != nil {
-		value = (*ctx.replacerFunction).call(ctx.call.runtime, toValue_object(holder), key, value)
-	}
-
-	if value.kind == valueObject {
-		switch value.value.(*_object).class {
-		case "Boolean":
-			value = value._object().value.(Value)
-		case "String":
-			value = toValue_string(value.string())
-		case "Number":
-			value = value.numberValue()
-		}
-	}
-
-	switch value.kind {
-	case valueBoolean:
-		return value.bool(), true
-	case valueString:
-		return value.string(), true
-	case valueNumber:
-		integer := value.number()
-		switch integer.kind {
-		case numberInteger:
-			return integer.int64, true
-		case numberFloat:
-			return integer.float64, true
-		default:
-			return nil, true
-		}
-	case valueNull:
-		return nil, true
-	case valueObject:
-		holder := value._object()
-		if value := value._object(); nil != value {
-			for _, object := range ctx.stack {
-				if holder == object {
-					panic(ctx.call.runtime.panicTypeError("Converting circular structure to JSON"))
-				}
-			}
-			ctx.stack = append(ctx.stack, value)
-			defer func() { ctx.stack = ctx.stack[:len(ctx.stack)-1] }()
-		}
-		if isArray(holder) {
-			var length uint32
-			switch value := holder.get("length").value.(type) {
-			case uint32:
-				length = value
-			case int:
-				if value >= 0 {
-					length = uint32(value)
-				}
-			default:
-				panic(ctx.call.runtime.panicTypeError(fmt.Sprintf("JSON.stringify: invalid length: %v (%[1]T)", value)))
-			}
-			array := make([]interface{}, length)
-			for index, _ := range array {
-				name := arrayIndexToString(int64(index))
-				value, _ := builtinJSON_stringifyWalk(ctx, name, holder)
-				array[index] = value
-			}
-			return array, true
-		} else if holder.class != "Function" {
-			object := map[string]interface{}{}
-			if ctx.propertyList != nil {
-				for _, name := range ctx.propertyList {
-					value, exists := builtinJSON_stringifyWalk(ctx, name, holder)
-					if exists {
-						object[name] = value
-					}
-				}
-			} else {
-				// Go maps are without order, so this doesn't conform to the ECMA ordering
-				// standard, but oh well...
-				holder.enumerate(false, func(name string) bool {
-					value, exists := builtinJSON_stringifyWalk(ctx, name, holder)
-					if exists {
-						object[name] = value
-					}
-					return true
-				})
-			}
-			return object, true
-		}
-	}
-	return nil, false
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_math.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_math.go
deleted file mode 100644
index 7ce90c339..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_math.go
+++ /dev/null
@@ -1,151 +0,0 @@
-package otto
-
-import (
-	"math"
-	"math/rand"
-)
-
-// Math
-
-func builtinMath_abs(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Abs(number))
-}
-
-func builtinMath_acos(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Acos(number))
-}
-
-func builtinMath_asin(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Asin(number))
-}
-
-func builtinMath_atan(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Atan(number))
-}
-
-func builtinMath_atan2(call FunctionCall) Value {
-	y := call.Argument(0).float64()
-	if math.IsNaN(y) {
-		return NaNValue()
-	}
-	x := call.Argument(1).float64()
-	if math.IsNaN(x) {
-		return NaNValue()
-	}
-	return toValue_float64(math.Atan2(y, x))
-}
-
-func builtinMath_cos(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Cos(number))
-}
-
-func builtinMath_ceil(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Ceil(number))
-}
-
-func builtinMath_exp(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Exp(number))
-}
-
-func builtinMath_floor(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Floor(number))
-}
-
-func builtinMath_log(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Log(number))
-}
-
-func builtinMath_max(call FunctionCall) Value {
-	switch len(call.ArgumentList) {
-	case 0:
-		return negativeInfinityValue()
-	case 1:
-		return toValue_float64(call.ArgumentList[0].float64())
-	}
-	result := call.ArgumentList[0].float64()
-	if math.IsNaN(result) {
-		return NaNValue()
-	}
-	for _, value := range call.ArgumentList[1:] {
-		value := value.float64()
-		if math.IsNaN(value) {
-			return NaNValue()
-		}
-		result = math.Max(result, value)
-	}
-	return toValue_float64(result)
-}
-
-func builtinMath_min(call FunctionCall) Value {
-	switch len(call.ArgumentList) {
-	case 0:
-		return positiveInfinityValue()
-	case 1:
-		return toValue_float64(call.ArgumentList[0].float64())
-	}
-	result := call.ArgumentList[0].float64()
-	if math.IsNaN(result) {
-		return NaNValue()
-	}
-	for _, value := range call.ArgumentList[1:] {
-		value := value.float64()
-		if math.IsNaN(value) {
-			return NaNValue()
-		}
-		result = math.Min(result, value)
-	}
-	return toValue_float64(result)
-}
-
-func builtinMath_pow(call FunctionCall) Value {
-	// TODO Make sure this works according to the specification (15.8.2.13)
-	x := call.Argument(0).float64()
-	y := call.Argument(1).float64()
-	if math.Abs(x) == 1 && math.IsInf(y, 0) {
-		return NaNValue()
-	}
-	return toValue_float64(math.Pow(x, y))
-}
-
-func builtinMath_random(call FunctionCall) Value {
-	var v float64
-	if call.runtime.random != nil {
-		v = call.runtime.random()
-	} else {
-		v = rand.Float64()
-	}
-	return toValue_float64(v)
-}
-
-func builtinMath_round(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	value := math.Floor(number + 0.5)
-	if value == 0 {
-		value = math.Copysign(0, number)
-	}
-	return toValue_float64(value)
-}
-
-func builtinMath_sin(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Sin(number))
-}
-
-func builtinMath_sqrt(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Sqrt(number))
-}
-
-func builtinMath_tan(call FunctionCall) Value {
-	number := call.Argument(0).float64()
-	return toValue_float64(math.Tan(number))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_number.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_number.go
deleted file mode 100644
index 26a03e7b6..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_number.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package otto
-
-import (
-	"math"
-	"strconv"
-)
-
-// Number
-
-func numberValueFromNumberArgumentList(argumentList []Value) Value {
-	if len(argumentList) > 0 {
-		return argumentList[0].numberValue()
-	}
-	return toValue_int(0)
-}
-
-func builtinNumber(call FunctionCall) Value {
-	return numberValueFromNumberArgumentList(call.ArgumentList)
-}
-
-func builtinNewNumber(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newNumber(numberValueFromNumberArgumentList(argumentList)))
-}
-
-func builtinNumber_toString(call FunctionCall) Value {
-	// Will throw a TypeError if ThisObject is not a Number
-	value := call.thisClassObject("Number").primitiveValue()
-	radix := 10
-	radixArgument := call.Argument(0)
-	if radixArgument.IsDefined() {
-		integer := toIntegerFloat(radixArgument)
-		if integer < 2 || integer > 36 {
-			panic(call.runtime.panicRangeError("RangeError: toString() radix must be between 2 and 36"))
-		}
-		radix = int(integer)
-	}
-	if radix == 10 {
-		return toValue_string(value.string())
-	}
-	return toValue_string(numberToStringRadix(value, radix))
-}
-
-func builtinNumber_valueOf(call FunctionCall) Value {
-	return call.thisClassObject("Number").primitiveValue()
-}
-
-func builtinNumber_toFixed(call FunctionCall) Value {
-	precision := toIntegerFloat(call.Argument(0))
-	if 20 < precision || 0 > precision {
-		panic(call.runtime.panicRangeError("toFixed() precision must be between 0 and 20"))
-	}
-	if call.This.IsNaN() {
-		return toValue_string("NaN")
-	}
-	value := call.This.float64()
-	if math.Abs(value) >= 1e21 {
-		return toValue_string(floatToString(value, 64))
-	}
-	return toValue_string(strconv.FormatFloat(call.This.float64(), 'f', int(precision), 64))
-}
-
-func builtinNumber_toExponential(call FunctionCall) Value {
-	if call.This.IsNaN() {
-		return toValue_string("NaN")
-	}
-	precision := float64(-1)
-	if value := call.Argument(0); value.IsDefined() {
-		precision = toIntegerFloat(value)
-		if 0 > precision {
-			panic(call.runtime.panicRangeError("RangeError: toString() radix must be between 2 and 36"))
-		}
-	}
-	return toValue_string(strconv.FormatFloat(call.This.float64(), 'e', int(precision), 64))
-}
-
-func builtinNumber_toPrecision(call FunctionCall) Value {
-	if call.This.IsNaN() {
-		return toValue_string("NaN")
-	}
-	value := call.Argument(0)
-	if value.IsUndefined() {
-		return toValue_string(call.This.string())
-	}
-	precision := toIntegerFloat(value)
-	if 1 > precision {
-		panic(call.runtime.panicRangeError("RangeError: toPrecision() precision must be greater than 1"))
-	}
-	return toValue_string(strconv.FormatFloat(call.This.float64(), 'g', int(precision), 64))
-}
-
-func builtinNumber_toLocaleString(call FunctionCall) Value {
-	return builtinNumber_toString(call)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_object.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_object.go
deleted file mode 100644
index c2433f7be..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_object.go
+++ /dev/null
@@ -1,289 +0,0 @@
-package otto
-
-import (
-	"fmt"
-)
-
-// Object
-
-func builtinObject(call FunctionCall) Value {
-	value := call.Argument(0)
-	switch value.kind {
-	case valueUndefined, valueNull:
-		return toValue_object(call.runtime.newObject())
-	}
-
-	return toValue_object(call.runtime.toObject(value))
-}
-
-func builtinNewObject(self *_object, argumentList []Value) Value {
-	value := valueOfArrayIndex(argumentList, 0)
-	switch value.kind {
-	case valueNull, valueUndefined:
-	case valueNumber, valueString, valueBoolean:
-		return toValue_object(self.runtime.toObject(value))
-	case valueObject:
-		return value
-	default:
-	}
-	return toValue_object(self.runtime.newObject())
-}
-
-func builtinObject_valueOf(call FunctionCall) Value {
-	return toValue_object(call.thisObject())
-}
-
-func builtinObject_hasOwnProperty(call FunctionCall) Value {
-	propertyName := call.Argument(0).string()
-	thisObject := call.thisObject()
-	return toValue_bool(thisObject.hasOwnProperty(propertyName))
-}
-
-func builtinObject_isPrototypeOf(call FunctionCall) Value {
-	value := call.Argument(0)
-	if !value.IsObject() {
-		return falseValue
-	}
-	prototype := call.toObject(value).prototype
-	thisObject := call.thisObject()
-	for prototype != nil {
-		if thisObject == prototype {
-			return trueValue
-		}
-		prototype = prototype.prototype
-	}
-	return falseValue
-}
-
-func builtinObject_propertyIsEnumerable(call FunctionCall) Value {
-	propertyName := call.Argument(0).string()
-	thisObject := call.thisObject()
-	property := thisObject.getOwnProperty(propertyName)
-	if property != nil && property.enumerable() {
-		return trueValue
-	}
-	return falseValue
-}
-
-func builtinObject_toString(call FunctionCall) Value {
-	result := ""
-	if call.This.IsUndefined() {
-		result = "[object Undefined]"
-	} else if call.This.IsNull() {
-		result = "[object Null]"
-	} else {
-		result = fmt.Sprintf("[object %s]", call.thisObject().class)
-	}
-	return toValue_string(result)
-}
-
-func builtinObject_toLocaleString(call FunctionCall) Value {
-	toString := call.thisObject().get("toString")
-	if !toString.isCallable() {
-		panic(call.runtime.panicTypeError())
-	}
-	return toString.call(call.runtime, call.This)
-}
-
-func builtinObject_getPrototypeOf(call FunctionCall) Value {
-	objectValue := call.Argument(0)
-	object := objectValue._object()
-	if object == nil {
-		panic(call.runtime.panicTypeError())
-	}
-
-	if object.prototype == nil {
-		return nullValue
-	}
-
-	return toValue_object(object.prototype)
-}
-
-func builtinObject_getOwnPropertyDescriptor(call FunctionCall) Value {
-	objectValue := call.Argument(0)
-	object := objectValue._object()
-	if object == nil {
-		panic(call.runtime.panicTypeError())
-	}
-
-	name := call.Argument(1).string()
-	descriptor := object.getOwnProperty(name)
-	if descriptor == nil {
-		return Value{}
-	}
-	return toValue_object(call.runtime.fromPropertyDescriptor(*descriptor))
-}
-
-func builtinObject_defineProperty(call FunctionCall) Value {
-	objectValue := call.Argument(0)
-	object := objectValue._object()
-	if object == nil {
-		panic(call.runtime.panicTypeError())
-	}
-	name := call.Argument(1).string()
-	descriptor := toPropertyDescriptor(call.runtime, call.Argument(2))
-	object.defineOwnProperty(name, descriptor, true)
-	return objectValue
-}
-
-func builtinObject_defineProperties(call FunctionCall) Value {
-	objectValue := call.Argument(0)
-	object := objectValue._object()
-	if object == nil {
-		panic(call.runtime.panicTypeError())
-	}
-
-	properties := call.runtime.toObject(call.Argument(1))
-	properties.enumerate(false, func(name string) bool {
-		descriptor := toPropertyDescriptor(call.runtime, properties.get(name))
-		object.defineOwnProperty(name, descriptor, true)
-		return true
-	})
-
-	return objectValue
-}
-
-func builtinObject_create(call FunctionCall) Value {
-	prototypeValue := call.Argument(0)
-	if !prototypeValue.IsNull() && !prototypeValue.IsObject() {
-		panic(call.runtime.panicTypeError())
-	}
-
-	object := call.runtime.newObject()
-	object.prototype = prototypeValue._object()
-
-	propertiesValue := call.Argument(1)
-	if propertiesValue.IsDefined() {
-		properties := call.runtime.toObject(propertiesValue)
-		properties.enumerate(false, func(name string) bool {
-			descriptor := toPropertyDescriptor(call.runtime, properties.get(name))
-			object.defineOwnProperty(name, descriptor, true)
-			return true
-		})
-	}
-
-	return toValue_object(object)
-}
-
-func builtinObject_isExtensible(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		return toValue_bool(object.extensible)
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinObject_preventExtensions(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		object.extensible = false
-	} else {
-		panic(call.runtime.panicTypeError())
-	}
-	return object
-}
-
-func builtinObject_isSealed(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		if object.extensible {
-			return toValue_bool(false)
-		}
-		result := true
-		object.enumerate(true, func(name string) bool {
-			property := object.getProperty(name)
-			if property.configurable() {
-				result = false
-			}
-			return true
-		})
-		return toValue_bool(result)
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinObject_seal(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		object.enumerate(true, func(name string) bool {
-			if property := object.getOwnProperty(name); nil != property && property.configurable() {
-				property.configureOff()
-				object.defineOwnProperty(name, *property, true)
-			}
-			return true
-		})
-		object.extensible = false
-	} else {
-		panic(call.runtime.panicTypeError())
-	}
-	return object
-}
-
-func builtinObject_isFrozen(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		if object.extensible {
-			return toValue_bool(false)
-		}
-		result := true
-		object.enumerate(true, func(name string) bool {
-			property := object.getProperty(name)
-			if property.configurable() || property.writable() {
-				result = false
-			}
-			return true
-		})
-		return toValue_bool(result)
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinObject_freeze(call FunctionCall) Value {
-	object := call.Argument(0)
-	if object := object._object(); object != nil {
-		object.enumerate(true, func(name string) bool {
-			if property, update := object.getOwnProperty(name), false; nil != property {
-				if property.isDataDescriptor() && property.writable() {
-					property.writeOff()
-					update = true
-				}
-				if property.configurable() {
-					property.configureOff()
-					update = true
-				}
-				if update {
-					object.defineOwnProperty(name, *property, true)
-				}
-			}
-			return true
-		})
-		object.extensible = false
-	} else {
-		panic(call.runtime.panicTypeError())
-	}
-	return object
-}
-
-func builtinObject_keys(call FunctionCall) Value {
-	if object, keys := call.Argument(0)._object(), []Value(nil); nil != object {
-		object.enumerate(false, func(name string) bool {
-			keys = append(keys, toValue_string(name))
-			return true
-		})
-		return toValue_object(call.runtime.newArrayOf(keys))
-	}
-	panic(call.runtime.panicTypeError())
-}
-
-func builtinObject_getOwnPropertyNames(call FunctionCall) Value {
-	if object, propertyNames := call.Argument(0)._object(), []Value(nil); nil != object {
-		object.enumerate(true, func(name string) bool {
-			if object.hasOwnProperty(name) {
-				propertyNames = append(propertyNames, toValue_string(name))
-			}
-			return true
-		})
-		return toValue_object(call.runtime.newArrayOf(propertyNames))
-	}
-	panic(call.runtime.panicTypeError())
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_regexp.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_regexp.go
deleted file mode 100644
index 99422510d..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_regexp.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package otto
-
-import (
-	"fmt"
-)
-
-// RegExp
-
-func builtinRegExp(call FunctionCall) Value {
-	pattern := call.Argument(0)
-	flags := call.Argument(1)
-	if object := pattern._object(); object != nil {
-		if object.class == "RegExp" && flags.IsUndefined() {
-			return pattern
-		}
-	}
-	return toValue_object(call.runtime.newRegExp(pattern, flags))
-}
-
-func builtinNewRegExp(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newRegExp(
-		valueOfArrayIndex(argumentList, 0),
-		valueOfArrayIndex(argumentList, 1),
-	))
-}
-
-func builtinRegExp_toString(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	source := thisObject.get("source").string()
-	flags := []byte{}
-	if thisObject.get("global").bool() {
-		flags = append(flags, 'g')
-	}
-	if thisObject.get("ignoreCase").bool() {
-		flags = append(flags, 'i')
-	}
-	if thisObject.get("multiline").bool() {
-		flags = append(flags, 'm')
-	}
-	return toValue_string(fmt.Sprintf("/%s/%s", source, flags))
-}
-
-func builtinRegExp_exec(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	target := call.Argument(0).string()
-	match, result := execRegExp(thisObject, target)
-	if !match {
-		return nullValue
-	}
-	return toValue_object(execResultToArray(call.runtime, target, result))
-}
-
-func builtinRegExp_test(call FunctionCall) Value {
-	thisObject := call.thisObject()
-	target := call.Argument(0).string()
-	match, _ := execRegExp(thisObject, target)
-	return toValue_bool(match)
-}
-
-func builtinRegExp_compile(call FunctionCall) Value {
-	// This (useless) function is deprecated, but is here to provide some
-	// semblance of compatibility.
-	// Caveat emptor: it may not be around for long.
-	return Value{}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_string.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_string.go
deleted file mode 100644
index 6a1718458..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/builtin_string.go
+++ /dev/null
@@ -1,500 +0,0 @@
-package otto
-
-import (
-	"bytes"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-)
-
-// String
-
-func stringValueFromStringArgumentList(argumentList []Value) Value {
-	if len(argumentList) > 0 {
-		return toValue_string(argumentList[0].string())
-	}
-	return toValue_string("")
-}
-
-func builtinString(call FunctionCall) Value {
-	return stringValueFromStringArgumentList(call.ArgumentList)
-}
-
-func builtinNewString(self *_object, argumentList []Value) Value {
-	return toValue_object(self.runtime.newString(stringValueFromStringArgumentList(argumentList)))
-}
-
-func builtinString_toString(call FunctionCall) Value {
-	return call.thisClassObject("String").primitiveValue()
-}
-func builtinString_valueOf(call FunctionCall) Value {
-	return call.thisClassObject("String").primitiveValue()
-}
-
-func builtinString_fromCharCode(call FunctionCall) Value {
-	chrList := make([]uint16, len(call.ArgumentList))
-	for index, value := range call.ArgumentList {
-		chrList[index] = toUint16(value)
-	}
-	return toValue_string16(chrList)
-}
-
-func builtinString_charAt(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	idx := int(call.Argument(0).number().int64)
-	chr := stringAt(call.This._object().stringValue(), idx)
-	if chr == utf8.RuneError {
-		return toValue_string("")
-	}
-	return toValue_string(string(chr))
-}
-
-func builtinString_charCodeAt(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	idx := int(call.Argument(0).number().int64)
-	chr := stringAt(call.This._object().stringValue(), idx)
-	if chr == utf8.RuneError {
-		return NaNValue()
-	}
-	return toValue_uint16(uint16(chr))
-}
-
-func builtinString_concat(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	var value bytes.Buffer
-	value.WriteString(call.This.string())
-	for _, item := range call.ArgumentList {
-		value.WriteString(item.string())
-	}
-	return toValue_string(value.String())
-}
-
-func builtinString_indexOf(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	value := call.This.string()
-	target := call.Argument(0).string()
-	if 2 > len(call.ArgumentList) {
-		return toValue_int(strings.Index(value, target))
-	}
-	start := toIntegerFloat(call.Argument(1))
-	if 0 > start {
-		start = 0
-	} else if start >= float64(len(value)) {
-		if target == "" {
-			return toValue_int(len(value))
-		}
-		return toValue_int(-1)
-	}
-	index := strings.Index(value[int(start):], target)
-	if index >= 0 {
-		index += int(start)
-	}
-	return toValue_int(index)
-}
-
-func builtinString_lastIndexOf(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	value := call.This.string()
-	target := call.Argument(0).string()
-	if 2 > len(call.ArgumentList) || call.ArgumentList[1].IsUndefined() {
-		return toValue_int(strings.LastIndex(value, target))
-	}
-	length := len(value)
-	if length == 0 {
-		return toValue_int(strings.LastIndex(value, target))
-	}
-	start := call.ArgumentList[1].number()
-	if start.kind == numberInfinity { // FIXME
-		// startNumber is infinity, so start is the end of string (start = length)
-		return toValue_int(strings.LastIndex(value, target))
-	}
-	if 0 > start.int64 {
-		start.int64 = 0
-	}
-	end := int(start.int64) + len(target)
-	if end > length {
-		end = length
-	}
-	return toValue_int(strings.LastIndex(value[:end], target))
-}
-
-func builtinString_match(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := call.This.string()
-	matcherValue := call.Argument(0)
-	matcher := matcherValue._object()
-	if !matcherValue.IsObject() || matcher.class != "RegExp" {
-		matcher = call.runtime.newRegExp(matcherValue, Value{})
-	}
-	global := matcher.get("global").bool()
-	if !global {
-		match, result := execRegExp(matcher, target)
-		if !match {
-			return nullValue
-		}
-		return toValue_object(execResultToArray(call.runtime, target, result))
-	}
-
-	{
-		result := matcher.regExpValue().regularExpression.FindAllStringIndex(target, -1)
-		matchCount := len(result)
-		if result == nil {
-			matcher.put("lastIndex", toValue_int(0), true)
-			return Value{} // !match
-		}
-		matchCount = len(result)
-		valueArray := make([]Value, matchCount)
-		for index := 0; index < matchCount; index++ {
-			valueArray[index] = toValue_string(target[result[index][0]:result[index][1]])
-		}
-		matcher.put("lastIndex", toValue_int(result[matchCount-1][1]), true)
-		return toValue_object(call.runtime.newArrayOf(valueArray))
-	}
-}
-
-var builtinString_replace_Regexp = regexp.MustCompile("\\$(?:[\\$\\&\\'\\`1-9]|0[1-9]|[1-9][0-9])")
-
-func builtinString_findAndReplaceString(input []byte, lastIndex int, match []int, target []byte, replaceValue []byte) (output []byte) {
-	matchCount := len(match) / 2
-	output = input
-	if match[0] != lastIndex {
-		output = append(output, target[lastIndex:match[0]]...)
-	}
-	replacement := builtinString_replace_Regexp.ReplaceAllFunc(replaceValue, func(part []byte) []byte {
-		// TODO Check if match[0] or match[1] can be -1 in this scenario
-		switch part[1] {
-		case '$':
-			return []byte{'$'}
-		case '&':
-			return target[match[0]:match[1]]
-		case '`':
-			return target[:match[0]]
-		case '\'':
-			return target[match[1]:len(target)]
-		}
-		matchNumberParse, error := strconv.ParseInt(string(part[1:]), 10, 64)
-		matchNumber := int(matchNumberParse)
-		if error != nil || matchNumber >= matchCount {
-			return []byte{}
-		}
-		offset := 2 * matchNumber
-		if match[offset] != -1 {
-			return target[match[offset]:match[offset+1]]
-		}
-		return []byte{} // The empty string
-	})
-	output = append(output, replacement...)
-	return output
-}
-
-func builtinString_replace(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := []byte(call.This.string())
-	searchValue := call.Argument(0)
-	searchObject := searchValue._object()
-
-	// TODO If a capture is -1?
-	var search *regexp.Regexp
-	global := false
-	find := 1
-	if searchValue.IsObject() && searchObject.class == "RegExp" {
-		regExp := searchObject.regExpValue()
-		search = regExp.regularExpression
-		if regExp.global {
-			find = -1
-		}
-	} else {
-		search = regexp.MustCompile(regexp.QuoteMeta(searchValue.string()))
-	}
-
-	found := search.FindAllSubmatchIndex(target, find)
-	if found == nil {
-		return toValue_string(string(target)) // !match
-	}
-
-	{
-		lastIndex := 0
-		result := []byte{}
-
-		replaceValue := call.Argument(1)
-		if replaceValue.isCallable() {
-			target := string(target)
-			replace := replaceValue._object()
-			for _, match := range found {
-				if match[0] != lastIndex {
-					result = append(result, target[lastIndex:match[0]]...)
-				}
-				matchCount := len(match) / 2
-				argumentList := make([]Value, matchCount+2)
-				for index := 0; index < matchCount; index++ {
-					offset := 2 * index
-					if match[offset] != -1 {
-						argumentList[index] = toValue_string(target[match[offset]:match[offset+1]])
-					} else {
-						argumentList[index] = Value{}
-					}
-				}
-				argumentList[matchCount+0] = toValue_int(match[0])
-				argumentList[matchCount+1] = toValue_string(target)
-				replacement := replace.call(Value{}, argumentList, false, nativeFrame).string()
-				result = append(result, []byte(replacement)...)
-				lastIndex = match[1]
-			}
-
-		} else {
-			replace := []byte(replaceValue.string())
-			for _, match := range found {
-				result = builtinString_findAndReplaceString(result, lastIndex, match, target, replace)
-				lastIndex = match[1]
-			}
-		}
-
-		if lastIndex != len(target) {
-			result = append(result, target[lastIndex:]...)
-		}
-
-		if global && searchObject != nil {
-			searchObject.put("lastIndex", toValue_int(lastIndex), true)
-		}
-
-		return toValue_string(string(result))
-	}
-}
-
-func builtinString_search(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := call.This.string()
-	searchValue := call.Argument(0)
-	search := searchValue._object()
-	if !searchValue.IsObject() || search.class != "RegExp" {
-		search = call.runtime.newRegExp(searchValue, Value{})
-	}
-	result := search.regExpValue().regularExpression.FindStringIndex(target)
-	if result == nil {
-		return toValue_int(-1)
-	}
-	return toValue_int(result[0])
-}
-
-func stringSplitMatch(target string, targetLength int64, index uint, search string, searchLength int64) (bool, uint) {
-	if int64(index)+searchLength > searchLength {
-		return false, 0
-	}
-	found := strings.Index(target[index:], search)
-	if 0 > found {
-		return false, 0
-	}
-	return true, uint(found)
-}
-
-func builtinString_split(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := call.This.string()
-
-	separatorValue := call.Argument(0)
-	limitValue := call.Argument(1)
-	limit := -1
-	if limitValue.IsDefined() {
-		limit = int(toUint32(limitValue))
-	}
-
-	if limit == 0 {
-		return toValue_object(call.runtime.newArray(0))
-	}
-
-	if separatorValue.IsUndefined() {
-		return toValue_object(call.runtime.newArrayOf([]Value{toValue_string(target)}))
-	}
-
-	if separatorValue.isRegExp() {
-		targetLength := len(target)
-		search := separatorValue._object().regExpValue().regularExpression
-		valueArray := []Value{}
-		result := search.FindAllStringSubmatchIndex(target, -1)
-		lastIndex := 0
-		found := 0
-
-		for _, match := range result {
-			if match[0] == match[1] {
-				// FIXME Ugh, this is a hack
-				if match[0] == 0 || match[0] == targetLength {
-					continue
-				}
-			}
-
-			if lastIndex != match[0] {
-				valueArray = append(valueArray, toValue_string(target[lastIndex:match[0]]))
-				found++
-			} else if lastIndex == match[0] {
-				if lastIndex != -1 {
-					valueArray = append(valueArray, toValue_string(""))
-					found++
-				}
-			}
-
-			lastIndex = match[1]
-			if found == limit {
-				goto RETURN
-			}
-
-			captureCount := len(match) / 2
-			for index := 1; index < captureCount; index++ {
-				offset := index * 2
-				value := Value{}
-				if match[offset] != -1 {
-					value = toValue_string(target[match[offset]:match[offset+1]])
-				}
-				valueArray = append(valueArray, value)
-				found++
-				if found == limit {
-					goto RETURN
-				}
-			}
-		}
-
-		if found != limit {
-			if lastIndex != targetLength {
-				valueArray = append(valueArray, toValue_string(target[lastIndex:targetLength]))
-			} else {
-				valueArray = append(valueArray, toValue_string(""))
-			}
-		}
-
-	RETURN:
-		return toValue_object(call.runtime.newArrayOf(valueArray))
-
-	} else {
-		separator := separatorValue.string()
-
-		splitLimit := limit
-		excess := false
-		if limit > 0 {
-			splitLimit = limit + 1
-			excess = true
-		}
-
-		split := strings.SplitN(target, separator, splitLimit)
-
-		if excess && len(split) > limit {
-			split = split[:limit]
-		}
-
-		valueArray := make([]Value, len(split))
-		for index, value := range split {
-			valueArray[index] = toValue_string(value)
-		}
-
-		return toValue_object(call.runtime.newArrayOf(valueArray))
-	}
-}
-
-func builtinString_slice(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := call.This.string()
-
-	length := int64(len(target))
-	start, end := rangeStartEnd(call.ArgumentList, length, false)
-	if end-start <= 0 {
-		return toValue_string("")
-	}
-	return toValue_string(target[start:end])
-}
-
-func builtinString_substring(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	target := call.This.string()
-
-	length := int64(len(target))
-	start, end := rangeStartEnd(call.ArgumentList, length, true)
-	if start > end {
-		start, end = end, start
-	}
-	return toValue_string(target[start:end])
-}
-
-func builtinString_substr(call FunctionCall) Value {
-	target := call.This.string()
-
-	size := int64(len(target))
-	start, length := rangeStartLength(call.ArgumentList, size)
-
-	if start >= size {
-		return toValue_string("")
-	}
-
-	if length <= 0 {
-		return toValue_string("")
-	}
-
-	if start+length >= size {
-		// Cap length to be to the end of the string
-		// start = 3, length = 5, size = 4 [0, 1, 2, 3]
-		// 4 - 3 = 1
-		// target[3:4]
-		length = size - start
-	}
-
-	return toValue_string(target[start : start+length])
-}
-
-func builtinString_toLowerCase(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	return toValue_string(strings.ToLower(call.This.string()))
-}
-
-func builtinString_toUpperCase(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	return toValue_string(strings.ToUpper(call.This.string()))
-}
-
-// 7.2 Table 2 — Whitespace Characters & 7.3 Table 3 - Line Terminator Characters
-const builtinString_trim_whitespace = "\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF"
-
-func builtinString_trim(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	return toValue(strings.Trim(call.This.string(),
-		builtinString_trim_whitespace))
-}
-
-// Mozilla extension, not ECMAScript 5
-func builtinString_trimLeft(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	return toValue(strings.TrimLeft(call.This.string(),
-		builtinString_trim_whitespace))
-}
-
-// Mozilla extension, not ECMAScript 5
-func builtinString_trimRight(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	return toValue(strings.TrimRight(call.This.string(),
-		builtinString_trim_whitespace))
-}
-
-func builtinString_localeCompare(call FunctionCall) Value {
-	checkObjectCoercible(call.runtime, call.This)
-	this := call.This.string()
-	that := call.Argument(0).string()
-	if this < that {
-		return toValue_int(-1)
-	} else if this == that {
-		return toValue_int(0)
-	}
-	return toValue_int(1)
-}
-
-/*
-An alternate version of String.trim
-func builtinString_trim(call FunctionCall) Value {
-	checkObjectCoercible(call.This)
-	return toValue_string(strings.TrimFunc(call.string(.This), isWhiteSpaceOrLineTerminator))
-}
-*/
-
-func builtinString_toLocaleLowerCase(call FunctionCall) Value {
-	return builtinString_toLowerCase(call)
-}
-
-func builtinString_toLocaleUpperCase(call FunctionCall) Value {
-	return builtinString_toUpperCase(call)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/clone.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/clone.go
deleted file mode 100644
index 82cb0f0af..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/clone.go
+++ /dev/null
@@ -1,167 +0,0 @@
-package otto
-
-import (
-	"fmt"
-)
-
-type _clone struct {
-	runtime      *_runtime
-	_object      map[*_object]*_object
-	_objectStash map[*_objectStash]*_objectStash
-	_dclStash    map[*_dclStash]*_dclStash
-	_fnStash     map[*_fnStash]*_fnStash
-}
-
-func (in *_runtime) clone() *_runtime {
-
-	in.lck.Lock()
-	defer in.lck.Unlock()
-
-	out := &_runtime{}
-	clone := _clone{
-		runtime:      out,
-		_object:      make(map[*_object]*_object),
-		_objectStash: make(map[*_objectStash]*_objectStash),
-		_dclStash:    make(map[*_dclStash]*_dclStash),
-		_fnStash:     make(map[*_fnStash]*_fnStash),
-	}
-
-	globalObject := clone.object(in.globalObject)
-	out.globalStash = out.newObjectStash(globalObject, nil)
-	out.globalObject = globalObject
-	out.global = _global{
-		clone.object(in.global.Object),
-		clone.object(in.global.Function),
-		clone.object(in.global.Array),
-		clone.object(in.global.String),
-		clone.object(in.global.Boolean),
-		clone.object(in.global.Number),
-		clone.object(in.global.Math),
-		clone.object(in.global.Date),
-		clone.object(in.global.RegExp),
-		clone.object(in.global.Error),
-		clone.object(in.global.EvalError),
-		clone.object(in.global.TypeError),
-		clone.object(in.global.RangeError),
-		clone.object(in.global.ReferenceError),
-		clone.object(in.global.SyntaxError),
-		clone.object(in.global.URIError),
-		clone.object(in.global.JSON),
-
-		clone.object(in.global.ObjectPrototype),
-		clone.object(in.global.FunctionPrototype),
-		clone.object(in.global.ArrayPrototype),
-		clone.object(in.global.StringPrototype),
-		clone.object(in.global.BooleanPrototype),
-		clone.object(in.global.NumberPrototype),
-		clone.object(in.global.DatePrototype),
-		clone.object(in.global.RegExpPrototype),
-		clone.object(in.global.ErrorPrototype),
-		clone.object(in.global.EvalErrorPrototype),
-		clone.object(in.global.TypeErrorPrototype),
-		clone.object(in.global.RangeErrorPrototype),
-		clone.object(in.global.ReferenceErrorPrototype),
-		clone.object(in.global.SyntaxErrorPrototype),
-		clone.object(in.global.URIErrorPrototype),
-	}
-
-	out.eval = out.globalObject.property["eval"].value.(Value).value.(*_object)
-	out.globalObject.prototype = out.global.ObjectPrototype
-
-	// Not sure if this is necessary, but give some help to the GC
-	clone.runtime = nil
-	clone._object = nil
-	clone._objectStash = nil
-	clone._dclStash = nil
-	clone._fnStash = nil
-
-	return out
-}
-
-func (clone *_clone) object(in *_object) *_object {
-	if out, exists := clone._object[in]; exists {
-		return out
-	}
-	out := &_object{}
-	clone._object[in] = out
-	return in.objectClass.clone(in, out, clone)
-}
-
-func (clone *_clone) dclStash(in *_dclStash) (*_dclStash, bool) {
-	if out, exists := clone._dclStash[in]; exists {
-		return out, true
-	}
-	out := &_dclStash{}
-	clone._dclStash[in] = out
-	return out, false
-}
-
-func (clone *_clone) objectStash(in *_objectStash) (*_objectStash, bool) {
-	if out, exists := clone._objectStash[in]; exists {
-		return out, true
-	}
-	out := &_objectStash{}
-	clone._objectStash[in] = out
-	return out, false
-}
-
-func (clone *_clone) fnStash(in *_fnStash) (*_fnStash, bool) {
-	if out, exists := clone._fnStash[in]; exists {
-		return out, true
-	}
-	out := &_fnStash{}
-	clone._fnStash[in] = out
-	return out, false
-}
-
-func (clone *_clone) value(in Value) Value {
-	out := in
-	switch value := in.value.(type) {
-	case *_object:
-		out.value = clone.object(value)
-	}
-	return out
-}
-
-func (clone *_clone) valueArray(in []Value) []Value {
-	out := make([]Value, len(in))
-	for index, value := range in {
-		out[index] = clone.value(value)
-	}
-	return out
-}
-
-func (clone *_clone) stash(in _stash) _stash {
-	if in == nil {
-		return nil
-	}
-	return in.clone(clone)
-}
-
-func (clone *_clone) property(in _property) _property {
-	out := in
-
-	switch value := in.value.(type) {
-	case Value:
-		out.value = clone.value(value)
-	case _propertyGetSet:
-		p := _propertyGetSet{}
-		if value[0] != nil {
-			p[0] = clone.object(value[0])
-		}
-		if value[1] != nil {
-			p[1] = clone.object(value[1])
-		}
-		out.value = p
-	default:
-		panic(fmt.Errorf("in.value.(Value) != true; in.value is %T", in.value))
-	}
-
-	return out
-}
-
-func (clone *_clone) dclProperty(in _dclProperty) _dclProperty {
-	out := in
-	out.value = clone.value(in.value)
-	return out
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl.go
deleted file mode 100644
index c191b4527..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package otto
-
-import (
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/file"
-)
-
-type _file struct {
-	name string
-	src  string
-	base int // This will always be 1 or greater
-}
-
-type _compiler struct {
-	file    *file.File
-	program *ast.Program
-}
-
-func (cmpl *_compiler) parse() *_nodeProgram {
-	if cmpl.program != nil {
-		cmpl.file = cmpl.program.File
-	}
-	return cmpl._parse(cmpl.program)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate.go
deleted file mode 100644
index 6741bf394..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate.go
+++ /dev/null
@@ -1,96 +0,0 @@
-package otto
-
-import (
-	"strconv"
-)
-
-func (self *_runtime) cmpl_evaluate_nodeProgram(node *_nodeProgram, eval bool) Value {
-	if !eval {
-		self.enterGlobalScope()
-		defer func() {
-			self.leaveScope()
-		}()
-	}
-	self.cmpl_functionDeclaration(node.functionList)
-	self.cmpl_variableDeclaration(node.varList)
-	self.scope.frame.file = node.file
-	return self.cmpl_evaluate_nodeStatementList(node.body)
-}
-
-func (self *_runtime) cmpl_call_nodeFunction(function *_object, stash *_fnStash, node *_nodeFunctionLiteral, this Value, argumentList []Value) Value {
-
-	indexOfParameterName := make([]string, len(argumentList))
-	// function(abc, def, ghi)
-	// indexOfParameterName[0] = "abc"
-	// indexOfParameterName[1] = "def"
-	// indexOfParameterName[2] = "ghi"
-	// ...
-
-	argumentsFound := false
-	for index, name := range node.parameterList {
-		if name == "arguments" {
-			argumentsFound = true
-		}
-		value := Value{}
-		if index < len(argumentList) {
-			value = argumentList[index]
-			indexOfParameterName[index] = name
-		}
-		// strict = false
-		self.scope.lexical.setValue(name, value, false)
-	}
-
-	if !argumentsFound {
-		arguments := self.newArgumentsObject(indexOfParameterName, stash, len(argumentList))
-		arguments.defineProperty("callee", toValue_object(function), 0101, false)
-		stash.arguments = arguments
-		// strict = false
-		self.scope.lexical.setValue("arguments", toValue_object(arguments), false)
-		for index, _ := range argumentList {
-			if index < len(node.parameterList) {
-				continue
-			}
-			indexAsString := strconv.FormatInt(int64(index), 10)
-			arguments.defineProperty(indexAsString, argumentList[index], 0111, false)
-		}
-	}
-
-	self.cmpl_functionDeclaration(node.functionList)
-	self.cmpl_variableDeclaration(node.varList)
-
-	result := self.cmpl_evaluate_nodeStatement(node.body)
-	if result.kind == valueResult {
-		return result
-	}
-
-	return Value{}
-}
-
-func (self *_runtime) cmpl_functionDeclaration(list []*_nodeFunctionLiteral) {
-	executionContext := self.scope
-	eval := executionContext.eval
-	stash := executionContext.variable
-
-	for _, function := range list {
-		name := function.name
-		value := self.cmpl_evaluate_nodeExpression(function)
-		if !stash.hasBinding(name) {
-			stash.createBinding(name, eval == true, value)
-		} else {
-			// TODO 10.5.5.e
-			stash.setBinding(name, value, false) // TODO strict
-		}
-	}
-}
-
-func (self *_runtime) cmpl_variableDeclaration(list []string) {
-	executionContext := self.scope
-	eval := executionContext.eval
-	stash := executionContext.variable
-
-	for _, name := range list {
-		if !stash.hasBinding(name) {
-			stash.createBinding(name, eval == true, Value{}) // TODO strict?
-		}
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_expression.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_expression.go
deleted file mode 100644
index 8586a484f..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_expression.go
+++ /dev/null
@@ -1,460 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"runtime"
-
-	"github.com/robertkrimen/otto/token"
-)
-
-func (self *_runtime) cmpl_evaluate_nodeExpression(node _nodeExpression) Value {
-	// Allow interpreter interruption
-	// If the Interrupt channel is nil, then
-	// we avoid runtime.Gosched() overhead (if any)
-	// FIXME: Test this
-	if self.otto.Interrupt != nil {
-		runtime.Gosched()
-		select {
-		case value := <-self.otto.Interrupt:
-			value()
-		default:
-		}
-	}
-
-	switch node := node.(type) {
-
-	case *_nodeArrayLiteral:
-		return self.cmpl_evaluate_nodeArrayLiteral(node)
-
-	case *_nodeAssignExpression:
-		return self.cmpl_evaluate_nodeAssignExpression(node)
-
-	case *_nodeBinaryExpression:
-		if node.comparison {
-			return self.cmpl_evaluate_nodeBinaryExpression_comparison(node)
-		} else {
-			return self.cmpl_evaluate_nodeBinaryExpression(node)
-		}
-
-	case *_nodeBracketExpression:
-		return self.cmpl_evaluate_nodeBracketExpression(node)
-
-	case *_nodeCallExpression:
-		return self.cmpl_evaluate_nodeCallExpression(node, nil)
-
-	case *_nodeConditionalExpression:
-		return self.cmpl_evaluate_nodeConditionalExpression(node)
-
-	case *_nodeDotExpression:
-		return self.cmpl_evaluate_nodeDotExpression(node)
-
-	case *_nodeFunctionLiteral:
-		var local = self.scope.lexical
-		if node.name != "" {
-			local = self.newDeclarationStash(local)
-		}
-
-		value := toValue_object(self.newNodeFunction(node, local))
-		if node.name != "" {
-			local.createBinding(node.name, false, value)
-		}
-		return value
-
-	case *_nodeIdentifier:
-		name := node.name
-		// TODO Should be true or false (strictness) depending on context
-		// getIdentifierReference should not return nil, but we check anyway and panic
-		// so as not to propagate the nil into something else
-		reference := getIdentifierReference(self, self.scope.lexical, name, false, _at(node.idx))
-		if reference == nil {
-			// Should never get here!
-			panic(hereBeDragons("referenceError == nil: " + name))
-		}
-		return toValue(reference)
-
-	case *_nodeLiteral:
-		return node.value
-
-	case *_nodeNewExpression:
-		return self.cmpl_evaluate_nodeNewExpression(node)
-
-	case *_nodeObjectLiteral:
-		return self.cmpl_evaluate_nodeObjectLiteral(node)
-
-	case *_nodeRegExpLiteral:
-		return toValue_object(self._newRegExp(node.pattern, node.flags))
-
-	case *_nodeSequenceExpression:
-		return self.cmpl_evaluate_nodeSequenceExpression(node)
-
-	case *_nodeThisExpression:
-		return toValue_object(self.scope.this)
-
-	case *_nodeUnaryExpression:
-		return self.cmpl_evaluate_nodeUnaryExpression(node)
-
-	case *_nodeVariableExpression:
-		return self.cmpl_evaluate_nodeVariableExpression(node)
-	}
-
-	panic(fmt.Errorf("Here be dragons: evaluate_nodeExpression(%T)", node))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeArrayLiteral(node *_nodeArrayLiteral) Value {
-
-	valueArray := []Value{}
-
-	for _, node := range node.value {
-		if node == nil {
-			valueArray = append(valueArray, emptyValue)
-		} else {
-			valueArray = append(valueArray, self.cmpl_evaluate_nodeExpression(node).resolve())
-		}
-	}
-
-	result := self.newArrayOf(valueArray)
-
-	return toValue_object(result)
-}
-
-func (self *_runtime) cmpl_evaluate_nodeAssignExpression(node *_nodeAssignExpression) Value {
-
-	left := self.cmpl_evaluate_nodeExpression(node.left)
-	right := self.cmpl_evaluate_nodeExpression(node.right)
-	rightValue := right.resolve()
-
-	result := rightValue
-	if node.operator != token.ASSIGN {
-		result = self.calculateBinaryExpression(node.operator, left, rightValue)
-	}
-
-	self.putValue(left.reference(), result)
-
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeBinaryExpression(node *_nodeBinaryExpression) Value {
-
-	left := self.cmpl_evaluate_nodeExpression(node.left)
-	leftValue := left.resolve()
-
-	switch node.operator {
-	// Logical
-	case token.LOGICAL_AND:
-		if !leftValue.bool() {
-			return leftValue
-		}
-		right := self.cmpl_evaluate_nodeExpression(node.right)
-		return right.resolve()
-	case token.LOGICAL_OR:
-		if leftValue.bool() {
-			return leftValue
-		}
-		right := self.cmpl_evaluate_nodeExpression(node.right)
-		return right.resolve()
-	}
-
-	return self.calculateBinaryExpression(node.operator, leftValue, self.cmpl_evaluate_nodeExpression(node.right))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeBinaryExpression_comparison(node *_nodeBinaryExpression) Value {
-
-	left := self.cmpl_evaluate_nodeExpression(node.left).resolve()
-	right := self.cmpl_evaluate_nodeExpression(node.right).resolve()
-
-	return toValue_bool(self.calculateComparison(node.operator, left, right))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeBracketExpression(node *_nodeBracketExpression) Value {
-	target := self.cmpl_evaluate_nodeExpression(node.left)
-	targetValue := target.resolve()
-	member := self.cmpl_evaluate_nodeExpression(node.member)
-	memberValue := member.resolve()
-
-	// TODO Pass in base value as-is, and defer toObject till later?
-	object, err := self.objectCoerce(targetValue)
-	if err != nil {
-		panic(self.panicTypeError("Cannot access member '%s' of %s", memberValue.string(), err.Error(), _at(node.idx)))
-	}
-	return toValue(newPropertyReference(self, object, memberValue.string(), false, _at(node.idx)))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeCallExpression(node *_nodeCallExpression, withArgumentList []interface{}) Value {
-	rt := self
-	this := Value{}
-	callee := self.cmpl_evaluate_nodeExpression(node.callee)
-
-	argumentList := []Value{}
-	if withArgumentList != nil {
-		argumentList = self.toValueArray(withArgumentList...)
-	} else {
-		for _, argumentNode := range node.argumentList {
-			argumentList = append(argumentList, self.cmpl_evaluate_nodeExpression(argumentNode).resolve())
-		}
-	}
-
-	rf := callee.reference()
-	vl := callee.resolve()
-
-	eval := false // Whether this call is a (candidate for) direct call to eval
-	name := ""
-	if rf != nil {
-		switch rf := rf.(type) {
-		case *_propertyReference:
-			name = rf.name
-			object := rf.base
-			this = toValue_object(object)
-			eval = rf.name == "eval" // Possible direct eval
-		case *_stashReference:
-			// TODO ImplicitThisValue
-			name = rf.name
-			eval = rf.name == "eval" // Possible direct eval
-		default:
-			// FIXME?
-			panic(rt.panicTypeError("Here be dragons"))
-		}
-	}
-
-	at := _at(-1)
-	switch callee := node.callee.(type) {
-	case *_nodeIdentifier:
-		at = _at(callee.idx)
-	case *_nodeDotExpression:
-		at = _at(callee.idx)
-	case *_nodeBracketExpression:
-		at = _at(callee.idx)
-	}
-
-	frame := _frame{
-		callee: name,
-		file:   self.scope.frame.file,
-	}
-
-	if !vl.IsFunction() {
-		if name == "" {
-			// FIXME Maybe typeof?
-			panic(rt.panicTypeError("%v is not a function", vl, at))
-		}
-		panic(rt.panicTypeError("'%s' is not a function", name, at))
-	}
-
-	self.scope.frame.offset = int(at)
-
-	return vl._object().call(this, argumentList, eval, frame)
-}
-
-func (self *_runtime) cmpl_evaluate_nodeConditionalExpression(node *_nodeConditionalExpression) Value {
-	test := self.cmpl_evaluate_nodeExpression(node.test)
-	testValue := test.resolve()
-	if testValue.bool() {
-		return self.cmpl_evaluate_nodeExpression(node.consequent)
-	}
-	return self.cmpl_evaluate_nodeExpression(node.alternate)
-}
-
-func (self *_runtime) cmpl_evaluate_nodeDotExpression(node *_nodeDotExpression) Value {
-	target := self.cmpl_evaluate_nodeExpression(node.left)
-	targetValue := target.resolve()
-	// TODO Pass in base value as-is, and defer toObject till later?
-	object, err := self.objectCoerce(targetValue)
-	if err != nil {
-		panic(self.panicTypeError("Cannot access member '%s' of %s", node.identifier, err.Error(), _at(node.idx)))
-	}
-	return toValue(newPropertyReference(self, object, node.identifier, false, _at(node.idx)))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeNewExpression(node *_nodeNewExpression) Value {
-	rt := self
-	callee := self.cmpl_evaluate_nodeExpression(node.callee)
-
-	argumentList := []Value{}
-	for _, argumentNode := range node.argumentList {
-		argumentList = append(argumentList, self.cmpl_evaluate_nodeExpression(argumentNode).resolve())
-	}
-
-	rf := callee.reference()
-	vl := callee.resolve()
-
-	name := ""
-	if rf != nil {
-		switch rf := rf.(type) {
-		case *_propertyReference:
-			name = rf.name
-		case *_stashReference:
-			name = rf.name
-		default:
-			panic(rt.panicTypeError("Here be dragons"))
-		}
-	}
-
-	at := _at(-1)
-	switch callee := node.callee.(type) {
-	case *_nodeIdentifier:
-		at = _at(callee.idx)
-	case *_nodeDotExpression:
-		at = _at(callee.idx)
-	case *_nodeBracketExpression:
-		at = _at(callee.idx)
-	}
-
-	if !vl.IsFunction() {
-		if name == "" {
-			// FIXME Maybe typeof?
-			panic(rt.panicTypeError("%v is not a function", vl, at))
-		}
-		panic(rt.panicTypeError("'%s' is not a function", name, at))
-	}
-
-	self.scope.frame.offset = int(at)
-
-	return vl._object().construct(argumentList)
-}
-
-func (self *_runtime) cmpl_evaluate_nodeObjectLiteral(node *_nodeObjectLiteral) Value {
-
-	result := self.newObject()
-
-	for _, property := range node.value {
-		switch property.kind {
-		case "value":
-			result.defineProperty(property.key, self.cmpl_evaluate_nodeExpression(property.value).resolve(), 0111, false)
-		case "get":
-			getter := self.newNodeFunction(property.value.(*_nodeFunctionLiteral), self.scope.lexical)
-			descriptor := _property{}
-			descriptor.mode = 0211
-			descriptor.value = _propertyGetSet{getter, nil}
-			result.defineOwnProperty(property.key, descriptor, false)
-		case "set":
-			setter := self.newNodeFunction(property.value.(*_nodeFunctionLiteral), self.scope.lexical)
-			descriptor := _property{}
-			descriptor.mode = 0211
-			descriptor.value = _propertyGetSet{nil, setter}
-			result.defineOwnProperty(property.key, descriptor, false)
-		default:
-			panic(fmt.Errorf("Here be dragons: evaluate_nodeObjectLiteral: invalid property.Kind: %v", property.kind))
-		}
-	}
-
-	return toValue_object(result)
-}
-
-func (self *_runtime) cmpl_evaluate_nodeSequenceExpression(node *_nodeSequenceExpression) Value {
-	var result Value
-	for _, node := range node.sequence {
-		result = self.cmpl_evaluate_nodeExpression(node)
-		result = result.resolve()
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeUnaryExpression(node *_nodeUnaryExpression) Value {
-
-	target := self.cmpl_evaluate_nodeExpression(node.operand)
-	switch node.operator {
-	case token.TYPEOF, token.DELETE:
-		if target.kind == valueReference && target.reference().invalid() {
-			if node.operator == token.TYPEOF {
-				return toValue_string("undefined")
-			}
-			return trueValue
-		}
-	}
-
-	switch node.operator {
-	case token.NOT:
-		targetValue := target.resolve()
-		if targetValue.bool() {
-			return falseValue
-		}
-		return trueValue
-	case token.BITWISE_NOT:
-		targetValue := target.resolve()
-		integerValue := toInt32(targetValue)
-		return toValue_int32(^integerValue)
-	case token.PLUS:
-		targetValue := target.resolve()
-		return toValue_float64(targetValue.float64())
-	case token.MINUS:
-		targetValue := target.resolve()
-		value := targetValue.float64()
-		// TODO Test this
-		sign := float64(-1)
-		if math.Signbit(value) {
-			sign = 1
-		}
-		return toValue_float64(math.Copysign(value, sign))
-	case token.INCREMENT:
-		targetValue := target.resolve()
-		if node.postfix {
-			// Postfix++
-			oldValue := targetValue.float64()
-			newValue := toValue_float64(+1 + oldValue)
-			self.putValue(target.reference(), newValue)
-			return toValue_float64(oldValue)
-		} else {
-			// ++Prefix
-			newValue := toValue_float64(+1 + targetValue.float64())
-			self.putValue(target.reference(), newValue)
-			return newValue
-		}
-	case token.DECREMENT:
-		targetValue := target.resolve()
-		if node.postfix {
-			// Postfix--
-			oldValue := targetValue.float64()
-			newValue := toValue_float64(-1 + oldValue)
-			self.putValue(target.reference(), newValue)
-			return toValue_float64(oldValue)
-		} else {
-			// --Prefix
-			newValue := toValue_float64(-1 + targetValue.float64())
-			self.putValue(target.reference(), newValue)
-			return newValue
-		}
-	case token.VOID:
-		target.resolve() // FIXME Side effect?
-		return Value{}
-	case token.DELETE:
-		reference := target.reference()
-		if reference == nil {
-			return trueValue
-		}
-		return toValue_bool(target.reference().delete())
-	case token.TYPEOF:
-		targetValue := target.resolve()
-		switch targetValue.kind {
-		case valueUndefined:
-			return toValue_string("undefined")
-		case valueNull:
-			return toValue_string("object")
-		case valueBoolean:
-			return toValue_string("boolean")
-		case valueNumber:
-			return toValue_string("number")
-		case valueString:
-			return toValue_string("string")
-		case valueObject:
-			if targetValue._object().isCall() {
-				return toValue_string("function")
-			}
-			return toValue_string("object")
-		default:
-			// FIXME ?
-		}
-	}
-
-	panic(hereBeDragons())
-}
-
-func (self *_runtime) cmpl_evaluate_nodeVariableExpression(node *_nodeVariableExpression) Value {
-	if node.initializer != nil {
-		// FIXME If reference is nil
-		left := getIdentifierReference(self, self.scope.lexical, node.name, false, _at(node.idx))
-		right := self.cmpl_evaluate_nodeExpression(node.initializer)
-		rightValue := right.resolve()
-
-		self.putValue(left, rightValue)
-	}
-	return toValue_string(node.name)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_statement.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_statement.go
deleted file mode 100644
index e16c6ac6c..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_evaluate_statement.go
+++ /dev/null
@@ -1,424 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"runtime"
-
-	"github.com/robertkrimen/otto/token"
-)
-
-func (self *_runtime) cmpl_evaluate_nodeStatement(node _nodeStatement) Value {
-	// Allow interpreter interruption
-	// If the Interrupt channel is nil, then
-	// we avoid runtime.Gosched() overhead (if any)
-	// FIXME: Test this
-	if self.otto.Interrupt != nil {
-		runtime.Gosched()
-		select {
-		case value := <-self.otto.Interrupt:
-			value()
-		default:
-		}
-	}
-
-	switch node := node.(type) {
-
-	case *_nodeBlockStatement:
-		labels := self.labels
-		self.labels = nil
-
-		value := self.cmpl_evaluate_nodeStatementList(node.list)
-		switch value.kind {
-		case valueResult:
-			switch value.evaluateBreak(labels) {
-			case resultBreak:
-				return emptyValue
-			}
-		}
-		return value
-
-	case *_nodeBranchStatement:
-		target := node.label
-		switch node.branch { // FIXME Maybe node.kind? node.operator?
-		case token.BREAK:
-			return toValue(newBreakResult(target))
-		case token.CONTINUE:
-			return toValue(newContinueResult(target))
-		}
-
-	case *_nodeDebuggerStatement:
-		if self.debugger != nil {
-			self.debugger(self.otto)
-		}
-		return emptyValue // Nothing happens.
-
-	case *_nodeDoWhileStatement:
-		return self.cmpl_evaluate_nodeDoWhileStatement(node)
-
-	case *_nodeEmptyStatement:
-		return emptyValue
-
-	case *_nodeExpressionStatement:
-		return self.cmpl_evaluate_nodeExpression(node.expression)
-
-	case *_nodeForInStatement:
-		return self.cmpl_evaluate_nodeForInStatement(node)
-
-	case *_nodeForStatement:
-		return self.cmpl_evaluate_nodeForStatement(node)
-
-	case *_nodeIfStatement:
-		return self.cmpl_evaluate_nodeIfStatement(node)
-
-	case *_nodeLabelledStatement:
-		self.labels = append(self.labels, node.label)
-		defer func() {
-			if len(self.labels) > 0 {
-				self.labels = self.labels[:len(self.labels)-1] // Pop the label
-			} else {
-				self.labels = nil
-			}
-		}()
-		return self.cmpl_evaluate_nodeStatement(node.statement)
-
-	case *_nodeReturnStatement:
-		if node.argument != nil {
-			return toValue(newReturnResult(self.cmpl_evaluate_nodeExpression(node.argument).resolve()))
-		}
-		return toValue(newReturnResult(Value{}))
-
-	case *_nodeSwitchStatement:
-		return self.cmpl_evaluate_nodeSwitchStatement(node)
-
-	case *_nodeThrowStatement:
-		value := self.cmpl_evaluate_nodeExpression(node.argument).resolve()
-		panic(newException(value))
-
-	case *_nodeTryStatement:
-		return self.cmpl_evaluate_nodeTryStatement(node)
-
-	case *_nodeVariableStatement:
-		// Variables are already defined, this is initialization only
-		for _, variable := range node.list {
-			self.cmpl_evaluate_nodeVariableExpression(variable.(*_nodeVariableExpression))
-		}
-		return emptyValue
-
-	case *_nodeWhileStatement:
-		return self.cmpl_evaluate_nodeWhileStatement(node)
-
-	case *_nodeWithStatement:
-		return self.cmpl_evaluate_nodeWithStatement(node)
-
-	}
-
-	panic(fmt.Errorf("Here be dragons: evaluate_nodeStatement(%T)", node))
-}
-
-func (self *_runtime) cmpl_evaluate_nodeStatementList(list []_nodeStatement) Value {
-	var result Value
-	for _, node := range list {
-		value := self.cmpl_evaluate_nodeStatement(node)
-		switch value.kind {
-		case valueResult:
-			return value
-		case valueEmpty:
-		default:
-			// We have getValue here to (for example) trigger a
-			// ReferenceError (of the not defined variety)
-			// Not sure if this is the best way to error out early
-			// for such errors or if there is a better way
-			// TODO Do we still need this?
-			result = value.resolve()
-		}
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeDoWhileStatement(node *_nodeDoWhileStatement) Value {
-
-	labels := append(self.labels, "")
-	self.labels = nil
-
-	test := node.test
-
-	result := emptyValue
-resultBreak:
-	for {
-		for _, node := range node.body {
-			value := self.cmpl_evaluate_nodeStatement(node)
-			switch value.kind {
-			case valueResult:
-				switch value.evaluateBreakContinue(labels) {
-				case resultReturn:
-					return value
-				case resultBreak:
-					break resultBreak
-				case resultContinue:
-					goto resultContinue
-				}
-			case valueEmpty:
-			default:
-				result = value
-			}
-		}
-	resultContinue:
-		if !self.cmpl_evaluate_nodeExpression(test).resolve().bool() {
-			// Stahp: do ... while (false)
-			break
-		}
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeForInStatement(node *_nodeForInStatement) Value {
-
-	labels := append(self.labels, "")
-	self.labels = nil
-
-	source := self.cmpl_evaluate_nodeExpression(node.source)
-	sourceValue := source.resolve()
-
-	switch sourceValue.kind {
-	case valueUndefined, valueNull:
-		return emptyValue
-	}
-
-	sourceObject := self.toObject(sourceValue)
-
-	into := node.into
-	body := node.body
-
-	result := emptyValue
-	object := sourceObject
-	for object != nil {
-		enumerateValue := emptyValue
-		object.enumerate(false, func(name string) bool {
-			into := self.cmpl_evaluate_nodeExpression(into)
-			// In the case of: for (var abc in def) ...
-			if into.reference() == nil {
-				identifier := into.string()
-				// TODO Should be true or false (strictness) depending on context
-				into = toValue(getIdentifierReference(self, self.scope.lexical, identifier, false, -1))
-			}
-			self.putValue(into.reference(), toValue_string(name))
-			for _, node := range body {
-				value := self.cmpl_evaluate_nodeStatement(node)
-				switch value.kind {
-				case valueResult:
-					switch value.evaluateBreakContinue(labels) {
-					case resultReturn:
-						enumerateValue = value
-						return false
-					case resultBreak:
-						object = nil
-						return false
-					case resultContinue:
-						return true
-					}
-				case valueEmpty:
-				default:
-					enumerateValue = value
-				}
-			}
-			return true
-		})
-		if object == nil {
-			break
-		}
-		object = object.prototype
-		if !enumerateValue.isEmpty() {
-			result = enumerateValue
-		}
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeForStatement(node *_nodeForStatement) Value {
-
-	labels := append(self.labels, "")
-	self.labels = nil
-
-	initializer := node.initializer
-	test := node.test
-	update := node.update
-	body := node.body
-
-	if initializer != nil {
-		initialResult := self.cmpl_evaluate_nodeExpression(initializer)
-		initialResult.resolve() // Side-effect trigger
-	}
-
-	result := emptyValue
-resultBreak:
-	for {
-		if test != nil {
-			testResult := self.cmpl_evaluate_nodeExpression(test)
-			testResultValue := testResult.resolve()
-			if testResultValue.bool() == false {
-				break
-			}
-		}
-		for _, node := range body {
-			value := self.cmpl_evaluate_nodeStatement(node)
-			switch value.kind {
-			case valueResult:
-				switch value.evaluateBreakContinue(labels) {
-				case resultReturn:
-					return value
-				case resultBreak:
-					break resultBreak
-				case resultContinue:
-					goto resultContinue
-				}
-			case valueEmpty:
-			default:
-				result = value
-			}
-		}
-	resultContinue:
-		if update != nil {
-			updateResult := self.cmpl_evaluate_nodeExpression(update)
-			updateResult.resolve() // Side-effect trigger
-		}
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeIfStatement(node *_nodeIfStatement) Value {
-	test := self.cmpl_evaluate_nodeExpression(node.test)
-	testValue := test.resolve()
-	if testValue.bool() {
-		return self.cmpl_evaluate_nodeStatement(node.consequent)
-	} else if node.alternate != nil {
-		return self.cmpl_evaluate_nodeStatement(node.alternate)
-	}
-
-	return emptyValue
-}
-
-func (self *_runtime) cmpl_evaluate_nodeSwitchStatement(node *_nodeSwitchStatement) Value {
-
-	labels := append(self.labels, "")
-	self.labels = nil
-
-	discriminantResult := self.cmpl_evaluate_nodeExpression(node.discriminant)
-	target := node.default_
-
-	for index, clause := range node.body {
-		test := clause.test
-		if test != nil {
-			if self.calculateComparison(token.STRICT_EQUAL, discriminantResult, self.cmpl_evaluate_nodeExpression(test)) {
-				target = index
-				break
-			}
-		}
-	}
-
-	result := emptyValue
-	if target != -1 {
-		for _, clause := range node.body[target:] {
-			for _, statement := range clause.consequent {
-				value := self.cmpl_evaluate_nodeStatement(statement)
-				switch value.kind {
-				case valueResult:
-					switch value.evaluateBreak(labels) {
-					case resultReturn:
-						return value
-					case resultBreak:
-						return emptyValue
-					}
-				case valueEmpty:
-				default:
-					result = value
-				}
-			}
-		}
-	}
-
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeTryStatement(node *_nodeTryStatement) Value {
-	tryCatchValue, exception := self.tryCatchEvaluate(func() Value {
-		return self.cmpl_evaluate_nodeStatement(node.body)
-	})
-
-	if exception && node.catch != nil {
-		outer := self.scope.lexical
-		self.scope.lexical = self.newDeclarationStash(outer)
-		defer func() {
-			self.scope.lexical = outer
-		}()
-		// TODO If necessary, convert TypeError<runtime> => TypeError
-		// That, is, such errors can be thrown despite not being JavaScript "native"
-		// strict = false
-		self.scope.lexical.setValue(node.catch.parameter, tryCatchValue, false)
-
-		// FIXME node.CatchParameter
-		// FIXME node.Catch
-		tryCatchValue, exception = self.tryCatchEvaluate(func() Value {
-			return self.cmpl_evaluate_nodeStatement(node.catch.body)
-		})
-	}
-
-	if node.finally != nil {
-		finallyValue := self.cmpl_evaluate_nodeStatement(node.finally)
-		if finallyValue.kind == valueResult {
-			return finallyValue
-		}
-	}
-
-	if exception {
-		panic(newException(tryCatchValue))
-	}
-
-	return tryCatchValue
-}
-
-func (self *_runtime) cmpl_evaluate_nodeWhileStatement(node *_nodeWhileStatement) Value {
-
-	test := node.test
-	body := node.body
-	labels := append(self.labels, "")
-	self.labels = nil
-
-	result := emptyValue
-resultBreakContinue:
-	for {
-		if !self.cmpl_evaluate_nodeExpression(test).resolve().bool() {
-			// Stahp: while (false) ...
-			break
-		}
-		for _, node := range body {
-			value := self.cmpl_evaluate_nodeStatement(node)
-			switch value.kind {
-			case valueResult:
-				switch value.evaluateBreakContinue(labels) {
-				case resultReturn:
-					return value
-				case resultBreak:
-					break resultBreakContinue
-				case resultContinue:
-					continue resultBreakContinue
-				}
-			case valueEmpty:
-			default:
-				result = value
-			}
-		}
-	}
-	return result
-}
-
-func (self *_runtime) cmpl_evaluate_nodeWithStatement(node *_nodeWithStatement) Value {
-	object := self.cmpl_evaluate_nodeExpression(node.object)
-	outer := self.scope.lexical
-	lexical := self.newObjectStash(self.toObject(object.resolve()), outer)
-	self.scope.lexical = lexical
-	defer func() {
-		self.scope.lexical = outer
-	}()
-
-	return self.cmpl_evaluate_nodeStatement(node.body)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_parse.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_parse.go
deleted file mode 100644
index f1e002d39..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/cmpl_parse.go
+++ /dev/null
@@ -1,653 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"regexp"
-
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-var trueLiteral = &_nodeLiteral{value: toValue_bool(true)}
-var falseLiteral = &_nodeLiteral{value: toValue_bool(false)}
-var nullLiteral = &_nodeLiteral{value: nullValue}
-var emptyStatement = &_nodeEmptyStatement{}
-
-func (cmpl *_compiler) parseExpression(in ast.Expression) _nodeExpression {
-	if in == nil {
-		return nil
-	}
-
-	switch in := in.(type) {
-
-	case *ast.ArrayLiteral:
-		out := &_nodeArrayLiteral{
-			value: make([]_nodeExpression, len(in.Value)),
-		}
-		for i, value := range in.Value {
-			out.value[i] = cmpl.parseExpression(value)
-		}
-		return out
-
-	case *ast.AssignExpression:
-		return &_nodeAssignExpression{
-			operator: in.Operator,
-			left:     cmpl.parseExpression(in.Left),
-			right:    cmpl.parseExpression(in.Right),
-		}
-
-	case *ast.BinaryExpression:
-		return &_nodeBinaryExpression{
-			operator:   in.Operator,
-			left:       cmpl.parseExpression(in.Left),
-			right:      cmpl.parseExpression(in.Right),
-			comparison: in.Comparison,
-		}
-
-	case *ast.BooleanLiteral:
-		if in.Value {
-			return trueLiteral
-		}
-		return falseLiteral
-
-	case *ast.BracketExpression:
-		return &_nodeBracketExpression{
-			idx:    in.Left.Idx0(),
-			left:   cmpl.parseExpression(in.Left),
-			member: cmpl.parseExpression(in.Member),
-		}
-
-	case *ast.CallExpression:
-		out := &_nodeCallExpression{
-			callee:       cmpl.parseExpression(in.Callee),
-			argumentList: make([]_nodeExpression, len(in.ArgumentList)),
-		}
-		for i, value := range in.ArgumentList {
-			out.argumentList[i] = cmpl.parseExpression(value)
-		}
-		return out
-
-	case *ast.ConditionalExpression:
-		return &_nodeConditionalExpression{
-			test:       cmpl.parseExpression(in.Test),
-			consequent: cmpl.parseExpression(in.Consequent),
-			alternate:  cmpl.parseExpression(in.Alternate),
-		}
-
-	case *ast.DotExpression:
-		return &_nodeDotExpression{
-			idx:        in.Left.Idx0(),
-			left:       cmpl.parseExpression(in.Left),
-			identifier: in.Identifier.Name,
-		}
-
-	case *ast.EmptyExpression:
-		return nil
-
-	case *ast.FunctionLiteral:
-		name := ""
-		if in.Name != nil {
-			name = in.Name.Name
-		}
-		out := &_nodeFunctionLiteral{
-			name:   name,
-			body:   cmpl.parseStatement(in.Body),
-			source: in.Source,
-			file:   cmpl.file,
-		}
-		if in.ParameterList != nil {
-			list := in.ParameterList.List
-			out.parameterList = make([]string, len(list))
-			for i, value := range list {
-				out.parameterList[i] = value.Name
-			}
-		}
-		for _, value := range in.DeclarationList {
-			switch value := value.(type) {
-			case *ast.FunctionDeclaration:
-				out.functionList = append(out.functionList, cmpl.parseExpression(value.Function).(*_nodeFunctionLiteral))
-			case *ast.VariableDeclaration:
-				for _, value := range value.List {
-					out.varList = append(out.varList, value.Name)
-				}
-			default:
-				panic(fmt.Errorf("Here be dragons: parseProgram.declaration(%T)", value))
-			}
-		}
-		return out
-
-	case *ast.Identifier:
-		return &_nodeIdentifier{
-			idx:  in.Idx,
-			name: in.Name,
-		}
-
-	case *ast.NewExpression:
-		out := &_nodeNewExpression{
-			callee:       cmpl.parseExpression(in.Callee),
-			argumentList: make([]_nodeExpression, len(in.ArgumentList)),
-		}
-		for i, value := range in.ArgumentList {
-			out.argumentList[i] = cmpl.parseExpression(value)
-		}
-		return out
-
-	case *ast.NullLiteral:
-		return nullLiteral
-
-	case *ast.NumberLiteral:
-		return &_nodeLiteral{
-			value: toValue(in.Value),
-		}
-
-	case *ast.ObjectLiteral:
-		out := &_nodeObjectLiteral{
-			value: make([]_nodeProperty, len(in.Value)),
-		}
-		for i, value := range in.Value {
-			out.value[i] = _nodeProperty{
-				key:   value.Key,
-				kind:  value.Kind,
-				value: cmpl.parseExpression(value.Value),
-			}
-		}
-		return out
-
-	case *ast.RegExpLiteral:
-		return &_nodeRegExpLiteral{
-			flags:   in.Flags,
-			pattern: in.Pattern,
-		}
-
-	case *ast.SequenceExpression:
-		out := &_nodeSequenceExpression{
-			sequence: make([]_nodeExpression, len(in.Sequence)),
-		}
-		for i, value := range in.Sequence {
-			out.sequence[i] = cmpl.parseExpression(value)
-		}
-		return out
-
-	case *ast.StringLiteral:
-		return &_nodeLiteral{
-			value: toValue_string(in.Value),
-		}
-
-	case *ast.ThisExpression:
-		return &_nodeThisExpression{}
-
-	case *ast.UnaryExpression:
-		return &_nodeUnaryExpression{
-			operator: in.Operator,
-			operand:  cmpl.parseExpression(in.Operand),
-			postfix:  in.Postfix,
-		}
-
-	case *ast.VariableExpression:
-		return &_nodeVariableExpression{
-			idx:         in.Idx0(),
-			name:        in.Name,
-			initializer: cmpl.parseExpression(in.Initializer),
-		}
-
-	}
-
-	panic(fmt.Errorf("Here be dragons: cmpl.parseExpression(%T)", in))
-}
-
-func (cmpl *_compiler) parseStatement(in ast.Statement) _nodeStatement {
-	if in == nil {
-		return nil
-	}
-
-	switch in := in.(type) {
-
-	case *ast.BlockStatement:
-		out := &_nodeBlockStatement{
-			list: make([]_nodeStatement, len(in.List)),
-		}
-		for i, value := range in.List {
-			out.list[i] = cmpl.parseStatement(value)
-		}
-		return out
-
-	case *ast.BranchStatement:
-		out := &_nodeBranchStatement{
-			branch: in.Token,
-		}
-		if in.Label != nil {
-			out.label = in.Label.Name
-		}
-		return out
-
-	case *ast.DebuggerStatement:
-		return &_nodeDebuggerStatement{}
-
-	case *ast.DoWhileStatement:
-		out := &_nodeDoWhileStatement{
-			test: cmpl.parseExpression(in.Test),
-		}
-		body := cmpl.parseStatement(in.Body)
-		if block, ok := body.(*_nodeBlockStatement); ok {
-			out.body = block.list
-		} else {
-			out.body = append(out.body, body)
-		}
-		return out
-
-	case *ast.EmptyStatement:
-		return emptyStatement
-
-	case *ast.ExpressionStatement:
-		return &_nodeExpressionStatement{
-			expression: cmpl.parseExpression(in.Expression),
-		}
-
-	case *ast.ForInStatement:
-		out := &_nodeForInStatement{
-			into:   cmpl.parseExpression(in.Into),
-			source: cmpl.parseExpression(in.Source),
-		}
-		body := cmpl.parseStatement(in.Body)
-		if block, ok := body.(*_nodeBlockStatement); ok {
-			out.body = block.list
-		} else {
-			out.body = append(out.body, body)
-		}
-		return out
-
-	case *ast.ForStatement:
-		out := &_nodeForStatement{
-			initializer: cmpl.parseExpression(in.Initializer),
-			update:      cmpl.parseExpression(in.Update),
-			test:        cmpl.parseExpression(in.Test),
-		}
-		body := cmpl.parseStatement(in.Body)
-		if block, ok := body.(*_nodeBlockStatement); ok {
-			out.body = block.list
-		} else {
-			out.body = append(out.body, body)
-		}
-		return out
-
-	case *ast.IfStatement:
-		return &_nodeIfStatement{
-			test:       cmpl.parseExpression(in.Test),
-			consequent: cmpl.parseStatement(in.Consequent),
-			alternate:  cmpl.parseStatement(in.Alternate),
-		}
-
-	case *ast.LabelledStatement:
-		return &_nodeLabelledStatement{
-			label:     in.Label.Name,
-			statement: cmpl.parseStatement(in.Statement),
-		}
-
-	case *ast.ReturnStatement:
-		return &_nodeReturnStatement{
-			argument: cmpl.parseExpression(in.Argument),
-		}
-
-	case *ast.SwitchStatement:
-		out := &_nodeSwitchStatement{
-			discriminant: cmpl.parseExpression(in.Discriminant),
-			default_:     in.Default,
-			body:         make([]*_nodeCaseStatement, len(in.Body)),
-		}
-		for i, clause := range in.Body {
-			out.body[i] = &_nodeCaseStatement{
-				test:       cmpl.parseExpression(clause.Test),
-				consequent: make([]_nodeStatement, len(clause.Consequent)),
-			}
-			for j, value := range clause.Consequent {
-				out.body[i].consequent[j] = cmpl.parseStatement(value)
-			}
-		}
-		return out
-
-	case *ast.ThrowStatement:
-		return &_nodeThrowStatement{
-			argument: cmpl.parseExpression(in.Argument),
-		}
-
-	case *ast.TryStatement:
-		out := &_nodeTryStatement{
-			body:    cmpl.parseStatement(in.Body),
-			finally: cmpl.parseStatement(in.Finally),
-		}
-		if in.Catch != nil {
-			out.catch = &_nodeCatchStatement{
-				parameter: in.Catch.Parameter.Name,
-				body:      cmpl.parseStatement(in.Catch.Body),
-			}
-		}
-		return out
-
-	case *ast.VariableStatement:
-		out := &_nodeVariableStatement{
-			list: make([]_nodeExpression, len(in.List)),
-		}
-		for i, value := range in.List {
-			out.list[i] = cmpl.parseExpression(value)
-		}
-		return out
-
-	case *ast.WhileStatement:
-		out := &_nodeWhileStatement{
-			test: cmpl.parseExpression(in.Test),
-		}
-		body := cmpl.parseStatement(in.Body)
-		if block, ok := body.(*_nodeBlockStatement); ok {
-			out.body = block.list
-		} else {
-			out.body = append(out.body, body)
-		}
-		return out
-
-	case *ast.WithStatement:
-		return &_nodeWithStatement{
-			object: cmpl.parseExpression(in.Object),
-			body:   cmpl.parseStatement(in.Body),
-		}
-
-	}
-
-	panic(fmt.Errorf("Here be dragons: cmpl.parseStatement(%T)", in))
-}
-
-func cmpl_parse(in *ast.Program) *_nodeProgram {
-	cmpl := _compiler{
-		program: in,
-	}
-	return cmpl.parse()
-}
-
-func (cmpl *_compiler) _parse(in *ast.Program) *_nodeProgram {
-	out := &_nodeProgram{
-		body: make([]_nodeStatement, len(in.Body)),
-		file: in.File,
-	}
-	for i, value := range in.Body {
-		out.body[i] = cmpl.parseStatement(value)
-	}
-	for _, value := range in.DeclarationList {
-		switch value := value.(type) {
-		case *ast.FunctionDeclaration:
-			out.functionList = append(out.functionList, cmpl.parseExpression(value.Function).(*_nodeFunctionLiteral))
-		case *ast.VariableDeclaration:
-			for _, value := range value.List {
-				out.varList = append(out.varList, value.Name)
-			}
-		default:
-			panic(fmt.Errorf("Here be dragons: cmpl.parseProgram.DeclarationList(%T)", value))
-		}
-	}
-	return out
-}
-
-type _nodeProgram struct {
-	body []_nodeStatement
-
-	varList      []string
-	functionList []*_nodeFunctionLiteral
-
-	variableList []_nodeDeclaration
-
-	file *file.File
-}
-
-type _nodeDeclaration struct {
-	name       string
-	definition _node
-}
-
-type _node interface {
-}
-
-type (
-	_nodeExpression interface {
-		_node
-		_expressionNode()
-	}
-
-	_nodeArrayLiteral struct {
-		value []_nodeExpression
-	}
-
-	_nodeAssignExpression struct {
-		operator token.Token
-		left     _nodeExpression
-		right    _nodeExpression
-	}
-
-	_nodeBinaryExpression struct {
-		operator   token.Token
-		left       _nodeExpression
-		right      _nodeExpression
-		comparison bool
-	}
-
-	_nodeBracketExpression struct {
-		idx    file.Idx
-		left   _nodeExpression
-		member _nodeExpression
-	}
-
-	_nodeCallExpression struct {
-		callee       _nodeExpression
-		argumentList []_nodeExpression
-	}
-
-	_nodeConditionalExpression struct {
-		test       _nodeExpression
-		consequent _nodeExpression
-		alternate  _nodeExpression
-	}
-
-	_nodeDotExpression struct {
-		idx        file.Idx
-		left       _nodeExpression
-		identifier string
-	}
-
-	_nodeFunctionLiteral struct {
-		name          string
-		body          _nodeStatement
-		source        string
-		parameterList []string
-		varList       []string
-		functionList  []*_nodeFunctionLiteral
-		file          *file.File
-	}
-
-	_nodeIdentifier struct {
-		idx  file.Idx
-		name string
-	}
-
-	_nodeLiteral struct {
-		value Value
-	}
-
-	_nodeNewExpression struct {
-		callee       _nodeExpression
-		argumentList []_nodeExpression
-	}
-
-	_nodeObjectLiteral struct {
-		value []_nodeProperty
-	}
-
-	_nodeProperty struct {
-		key   string
-		kind  string
-		value _nodeExpression
-	}
-
-	_nodeRegExpLiteral struct {
-		flags   string
-		pattern string // Value?
-		regexp  *regexp.Regexp
-	}
-
-	_nodeSequenceExpression struct {
-		sequence []_nodeExpression
-	}
-
-	_nodeThisExpression struct {
-	}
-
-	_nodeUnaryExpression struct {
-		operator token.Token
-		operand  _nodeExpression
-		postfix  bool
-	}
-
-	_nodeVariableExpression struct {
-		idx         file.Idx
-		name        string
-		initializer _nodeExpression
-	}
-)
-
-type (
-	_nodeStatement interface {
-		_node
-		_statementNode()
-	}
-
-	_nodeBlockStatement struct {
-		list []_nodeStatement
-	}
-
-	_nodeBranchStatement struct {
-		branch token.Token
-		label  string
-	}
-
-	_nodeCaseStatement struct {
-		test       _nodeExpression
-		consequent []_nodeStatement
-	}
-
-	_nodeCatchStatement struct {
-		parameter string
-		body      _nodeStatement
-	}
-
-	_nodeDebuggerStatement struct {
-	}
-
-	_nodeDoWhileStatement struct {
-		test _nodeExpression
-		body []_nodeStatement
-	}
-
-	_nodeEmptyStatement struct {
-	}
-
-	_nodeExpressionStatement struct {
-		expression _nodeExpression
-	}
-
-	_nodeForInStatement struct {
-		into   _nodeExpression
-		source _nodeExpression
-		body   []_nodeStatement
-	}
-
-	_nodeForStatement struct {
-		initializer _nodeExpression
-		update      _nodeExpression
-		test        _nodeExpression
-		body        []_nodeStatement
-	}
-
-	_nodeIfStatement struct {
-		test       _nodeExpression
-		consequent _nodeStatement
-		alternate  _nodeStatement
-	}
-
-	_nodeLabelledStatement struct {
-		label     string
-		statement _nodeStatement
-	}
-
-	_nodeReturnStatement struct {
-		argument _nodeExpression
-	}
-
-	_nodeSwitchStatement struct {
-		discriminant _nodeExpression
-		default_     int
-		body         []*_nodeCaseStatement
-	}
-
-	_nodeThrowStatement struct {
-		argument _nodeExpression
-	}
-
-	_nodeTryStatement struct {
-		body    _nodeStatement
-		catch   *_nodeCatchStatement
-		finally _nodeStatement
-	}
-
-	_nodeVariableStatement struct {
-		list []_nodeExpression
-	}
-
-	_nodeWhileStatement struct {
-		test _nodeExpression
-		body []_nodeStatement
-	}
-
-	_nodeWithStatement struct {
-		object _nodeExpression
-		body   _nodeStatement
-	}
-)
-
-// _expressionNode
-
-func (*_nodeArrayLiteral) _expressionNode()          {}
-func (*_nodeAssignExpression) _expressionNode()      {}
-func (*_nodeBinaryExpression) _expressionNode()      {}
-func (*_nodeBracketExpression) _expressionNode()     {}
-func (*_nodeCallExpression) _expressionNode()        {}
-func (*_nodeConditionalExpression) _expressionNode() {}
-func (*_nodeDotExpression) _expressionNode()         {}
-func (*_nodeFunctionLiteral) _expressionNode()       {}
-func (*_nodeIdentifier) _expressionNode()            {}
-func (*_nodeLiteral) _expressionNode()               {}
-func (*_nodeNewExpression) _expressionNode()         {}
-func (*_nodeObjectLiteral) _expressionNode()         {}
-func (*_nodeRegExpLiteral) _expressionNode()         {}
-func (*_nodeSequenceExpression) _expressionNode()    {}
-func (*_nodeThisExpression) _expressionNode()        {}
-func (*_nodeUnaryExpression) _expressionNode()       {}
-func (*_nodeVariableExpression) _expressionNode()    {}
-
-// _statementNode
-
-func (*_nodeBlockStatement) _statementNode()      {}
-func (*_nodeBranchStatement) _statementNode()     {}
-func (*_nodeCaseStatement) _statementNode()       {}
-func (*_nodeCatchStatement) _statementNode()      {}
-func (*_nodeDebuggerStatement) _statementNode()   {}
-func (*_nodeDoWhileStatement) _statementNode()    {}
-func (*_nodeEmptyStatement) _statementNode()      {}
-func (*_nodeExpressionStatement) _statementNode() {}
-func (*_nodeForInStatement) _statementNode()      {}
-func (*_nodeForStatement) _statementNode()        {}
-func (*_nodeIfStatement) _statementNode()         {}
-func (*_nodeLabelledStatement) _statementNode()   {}
-func (*_nodeReturnStatement) _statementNode()     {}
-func (*_nodeSwitchStatement) _statementNode()     {}
-func (*_nodeThrowStatement) _statementNode()      {}
-func (*_nodeTryStatement) _statementNode()        {}
-func (*_nodeVariableStatement) _statementNode()   {}
-func (*_nodeWhileStatement) _statementNode()      {}
-func (*_nodeWithStatement) _statementNode()       {}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/console.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/console.go
deleted file mode 100644
index 948face77..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/console.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-func formatForConsole(argumentList []Value) string {
-	output := []string{}
-	for _, argument := range argumentList {
-		output = append(output, fmt.Sprintf("%v", argument))
-	}
-	return strings.Join(output, " ")
-}
-
-func builtinConsole_log(call FunctionCall) Value {
-	fmt.Fprintln(os.Stdout, formatForConsole(call.ArgumentList))
-	return Value{}
-}
-
-func builtinConsole_error(call FunctionCall) Value {
-	fmt.Fprintln(os.Stdout, formatForConsole(call.ArgumentList))
-	return Value{}
-}
-
-// Nothing happens.
-func builtinConsole_dir(call FunctionCall) Value {
-	return Value{}
-}
-
-func builtinConsole_time(call FunctionCall) Value {
-	return Value{}
-}
-
-func builtinConsole_timeEnd(call FunctionCall) Value {
-	return Value{}
-}
-
-func builtinConsole_trace(call FunctionCall) Value {
-	return Value{}
-}
-
-func builtinConsole_assert(call FunctionCall) Value {
-	return Value{}
-}
-
-func (runtime *_runtime) newConsole() *_object {
-
-	return newConsoleObject(runtime)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg.go
deleted file mode 100644
index 51fbdc206..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// This file was AUTOMATICALLY GENERATED by dbg-import (smuggol) for github.com/robertkrimen/dbg
-
-package otto
-
-import (
-	Dbg "github.com/robertkrimen/otto/dbg"
-)
-
-var dbg, dbgf = Dbg.New()
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg/dbg.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg/dbg.go
deleted file mode 100644
index 8c27fa293..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/dbg/dbg.go
+++ /dev/null
@@ -1,387 +0,0 @@
-// This file was AUTOMATICALLY GENERATED by dbg-import (smuggol) from github.com/robertkrimen/dbg
-
-/*
-Package dbg is a println/printf/log-debugging utility library.
-
-    import (
-        Dbg "github.com/robertkrimen/dbg"
-    )
-
-    dbg, dbgf := Dbg.New()
-
-    dbg("Emit some debug stuff", []byte{120, 121, 122, 122, 121}, math.Pi)
-    # "2013/01/28 16:50:03 Emit some debug stuff [120 121 122 122 121] 3.141592653589793"
-
-    dbgf("With a %s formatting %.2f", "little", math.Pi)
-    # "2013/01/28 16:51:55 With a little formatting (3.14)"
-
-    dbgf("%/fatal//A fatal debug statement: should not be here")
-    # "A fatal debug statement: should not be here"
-    # ...and then, os.Exit(1)
-
-    dbgf("%/panic//Can also panic %s", "this")
-    # "Can also panic this"
-    # ...as a panic, equivalent to: panic("Can also panic this")
-
-    dbgf("Any %s arguments without a corresponding %%", "extra", "are treated like arguments to dbg()")
-    # "2013/01/28 17:14:40 Any extra arguments (without a corresponding %) are treated like arguments to dbg()"
-
-    dbgf("%d %d", 1, 2, 3, 4, 5)
-    # "2013/01/28 17:16:32 Another example: 1 2 3 4 5"
-
-    dbgf("%@: Include the function name for a little context (via %s)", "%@")
-    # "2013... github.com/robertkrimen/dbg.TestSynopsis: Include the function name for a little context (via %@)"
-
-By default, dbg uses log (log.Println, log.Printf, log.Panic, etc.) for output.
-However, you can also provide your own output destination by invoking dbg.New with
-a customization function:
-
-    import (
-        "bytes"
-        Dbg "github.com/robertkrimen/dbg"
-        "os"
-    )
-
-    # dbg to os.Stderr
-    dbg, dbgf := Dbg.New(func(dbgr *Dbgr) {
-        dbgr.SetOutput(os.Stderr)
-    })
-
-    # A slightly contrived example:
-    var buffer bytes.Buffer
-    dbg, dbgf := New(func(dbgr *Dbgr) {
-        dbgr.SetOutput(&buffer)
-    })
-
-*/
-package dbg
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"regexp"
-	"runtime"
-	"strings"
-	"unicode"
-)
-
-type _frmt struct {
-	ctl          string
-	format       string
-	operandCount int
-	panic        bool
-	fatal        bool
-	check        bool
-}
-
-var (
-	ctlTest = regexp.MustCompile(`^\s*%/`)
-	ctlScan = regexp.MustCompile(`%?/(panic|fatal|check)(?:\s|$)`)
-)
-
-func operandCount(format string) int {
-	count := 0
-	end := len(format)
-	for at := 0; at < end; {
-		for at < end && format[at] != '%' {
-			at++
-		}
-		at++
-		if at < end {
-			if format[at] != '%' && format[at] != '@' {
-				count++
-			}
-			at++
-		}
-	}
-	return count
-}
-
-func parseFormat(format string) (frmt _frmt) {
-	if ctlTest.MatchString(format) {
-		format = strings.TrimLeftFunc(format, unicode.IsSpace)
-		index := strings.Index(format, "//")
-		if index != -1 {
-			frmt.ctl = format[0:index]
-			format = format[index+2:] // Skip the second slash via +2 (instead of +1)
-		} else {
-			frmt.ctl = format
-			format = ""
-		}
-		for _, tmp := range ctlScan.FindAllStringSubmatch(frmt.ctl, -1) {
-			for _, value := range tmp[1:] {
-				switch value {
-				case "panic":
-					frmt.panic = true
-				case "fatal":
-					frmt.fatal = true
-				case "check":
-					frmt.check = true
-				}
-			}
-		}
-	}
-	frmt.format = format
-	frmt.operandCount = operandCount(format)
-	return
-}
-
-type Dbgr struct {
-	emit _emit
-}
-
-type DbgFunction func(values ...interface{})
-
-func NewDbgr() *Dbgr {
-	self := &Dbgr{}
-	return self
-}
-
-/*
-New will create and return a pair of debugging functions. You can customize where
-they output to by passing in an (optional) customization function:
-
-    import (
-        Dbg "github.com/robertkrimen/dbg"
-        "os"
-    )
-
-    # dbg to os.Stderr
-    dbg, dbgf := Dbg.New(func(dbgr *Dbgr) {
-        dbgr.SetOutput(os.Stderr)
-    })
-
-*/
-func New(options ...interface{}) (dbg DbgFunction, dbgf DbgFunction) {
-	dbgr := NewDbgr()
-	if len(options) > 0 {
-		if fn, ok := options[0].(func(*Dbgr)); ok {
-			fn(dbgr)
-		}
-	}
-	return dbgr.DbgDbgf()
-}
-
-func (self Dbgr) Dbg(values ...interface{}) {
-	self.getEmit().emit(_frmt{}, "", values...)
-}
-
-func (self Dbgr) Dbgf(values ...interface{}) {
-	self.dbgf(values...)
-}
-
-func (self Dbgr) DbgDbgf() (dbg DbgFunction, dbgf DbgFunction) {
-	dbg = func(vl ...interface{}) {
-		self.Dbg(vl...)
-	}
-	dbgf = func(vl ...interface{}) {
-		self.dbgf(vl...)
-	}
-	return dbg, dbgf // Redundant, but...
-}
-
-func (self Dbgr) dbgf(values ...interface{}) {
-
-	var frmt _frmt
-	if len(values) > 0 {
-		tmp := fmt.Sprint(values[0])
-		frmt = parseFormat(tmp)
-		values = values[1:]
-	}
-
-	buffer_f := bytes.Buffer{}
-	format := frmt.format
-	end := len(format)
-	for at := 0; at < end; {
-		last := at
-		for at < end && format[at] != '%' {
-			at++
-		}
-		if at > last {
-			buffer_f.WriteString(format[last:at])
-		}
-		if at >= end {
-			break
-		}
-		// format[at] == '%'
-		at++
-		// format[at] == ?
-		if format[at] == '@' {
-			depth := 2
-			pc, _, _, _ := runtime.Caller(depth)
-			name := runtime.FuncForPC(pc).Name()
-			buffer_f.WriteString(name)
-		} else {
-			buffer_f.WriteString(format[at-1 : at+1])
-		}
-		at++
-	}
-
-	//values_f := append([]interface{}{}, values[0:frmt.operandCount]...)
-	values_f := values[0:frmt.operandCount]
-	values_dbg := values[frmt.operandCount:]
-	if len(values_dbg) > 0 {
-		// Adjust frmt.format:
-		// (%v instead of %s because: frmt.check)
-		{
-			tmp := format
-			if len(tmp) > 0 {
-				if unicode.IsSpace(rune(tmp[len(tmp)-1])) {
-					buffer_f.WriteString("%v")
-				} else {
-					buffer_f.WriteString(" %v")
-				}
-			} else if frmt.check {
-				// Performing a check, so no output
-			} else {
-				buffer_f.WriteString("%v")
-			}
-		}
-
-		// Adjust values_f:
-		if !frmt.check {
-			tmp := []string{}
-			for _, value := range values_dbg {
-				tmp = append(tmp, fmt.Sprintf("%v", value))
-			}
-			// First, make a copy of values_f, so we avoid overwriting values_dbg when appending
-			values_f = append([]interface{}{}, values_f...)
-			values_f = append(values_f, strings.Join(tmp, " "))
-		}
-	}
-
-	format = buffer_f.String()
-	if frmt.check {
-		// We do not actually emit to the log, but panic if
-		// a non-nil value is detected (e.g. a non-nil error)
-		for _, value := range values_dbg {
-			if value != nil {
-				if format == "" {
-					panic(value)
-				} else {
-					panic(fmt.Sprintf(format, append(values_f, value)...))
-				}
-			}
-		}
-	} else {
-		self.getEmit().emit(frmt, format, values_f...)
-	}
-}
-
-// Idiot-proof &Dbgr{}, etc.
-func (self *Dbgr) getEmit() _emit {
-	if self.emit == nil {
-		self.emit = standardEmit()
-	}
-	return self.emit
-}
-
-// SetOutput will accept the following as a destination for output:
-//
-//      *log.Logger         Print*/Panic*/Fatal* of the logger
-//      io.Writer           -
-//      nil                 Reset to the default output (os.Stderr)
-//      "log"               Print*/Panic*/Fatal* via the "log" package
-//
-func (self *Dbgr) SetOutput(output interface{}) {
-	if output == nil {
-		self.emit = standardEmit()
-		return
-	}
-	switch output := output.(type) {
-	case *log.Logger:
-		self.emit = _emitLogger{
-			logger: output,
-		}
-		return
-	case io.Writer:
-		self.emit = _emitWriter{
-			writer: output,
-		}
-		return
-	case string:
-		if output == "log" {
-			self.emit = _emitLog{}
-			return
-		}
-	}
-	panic(output)
-}
-
-// ======== //
-// = emit = //
-// ======== //
-
-func standardEmit() _emit {
-	return _emitWriter{
-		writer: os.Stderr,
-	}
-}
-
-func ln(tmp string) string {
-	length := len(tmp)
-	if length > 0 && tmp[length-1] != '\n' {
-		return tmp + "\n"
-	}
-	return tmp
-}
-
-type _emit interface {
-	emit(_frmt, string, ...interface{})
-}
-
-type _emitWriter struct {
-	writer io.Writer
-}
-
-func (self _emitWriter) emit(frmt _frmt, format string, values ...interface{}) {
-	if format == "" {
-		fmt.Fprintln(self.writer, values...)
-	} else {
-		if frmt.panic {
-			panic(fmt.Sprintf(format, values...))
-		}
-		fmt.Fprintf(self.writer, ln(format), values...)
-		if frmt.fatal {
-			os.Exit(1)
-		}
-	}
-}
-
-type _emitLogger struct {
-	logger *log.Logger
-}
-
-func (self _emitLogger) emit(frmt _frmt, format string, values ...interface{}) {
-	if format == "" {
-		self.logger.Println(values...)
-	} else {
-		if frmt.panic {
-			self.logger.Panicf(format, values...)
-		} else if frmt.fatal {
-			self.logger.Fatalf(format, values...)
-		} else {
-			self.logger.Printf(format, values...)
-		}
-	}
-}
-
-type _emitLog struct {
-}
-
-func (self _emitLog) emit(frmt _frmt, format string, values ...interface{}) {
-	if format == "" {
-		log.Println(values...)
-	} else {
-		if frmt.panic {
-			log.Panicf(format, values...)
-		} else if frmt.fatal {
-			log.Fatalf(format, values...)
-		} else {
-			log.Printf(format, values...)
-		}
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/error.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/error.go
deleted file mode 100644
index 111471044..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/error.go
+++ /dev/null
@@ -1,245 +0,0 @@
-package otto
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/robertkrimen/otto/file"
-)
-
-type _exception struct {
-	value interface{}
-}
-
-func newException(value interface{}) *_exception {
-	return &_exception{
-		value: value,
-	}
-}
-
-func (self *_exception) eject() interface{} {
-	value := self.value
-	self.value = nil // Prevent Go from holding on to the value, whatever it is
-	return value
-}
-
-type _error struct {
-	name    string
-	message string
-	trace   []_frame
-
-	offset int
-}
-
-type _frame struct {
-	file   *file.File
-	offset int
-	callee string
-}
-
-var (
-	nativeFrame = _frame{}
-)
-
-type _at int
-
-func (fr _frame) location() string {
-	if fr.file == nil {
-		return "<unknown>"
-	}
-	path := fr.file.Name()
-	line, column := _position(fr.file, fr.offset)
-
-	if path == "" {
-		path = "<anonymous>"
-	}
-
-	str := fmt.Sprintf("%s:%d:%d", path, line, column)
-
-	if fr.callee != "" {
-		str = fmt.Sprintf("%s (%s)", fr.callee, str)
-	}
-
-	return str
-}
-
-func _position(file *file.File, offset int) (line, column int) {
-	{
-		offset := offset - file.Base()
-		if offset < 0 {
-			return -offset, -1
-		}
-
-		src := file.Source()
-		if offset >= len(src) {
-			return -offset, -len(src)
-		}
-		src = src[:offset]
-
-		line := 1 + strings.Count(src, "\n")
-		column := 0
-		if index := strings.LastIndex(src, "\n"); index >= 0 {
-			column = offset - index
-		} else {
-			column = 1 + len(src)
-		}
-		return line, column
-	}
-}
-
-// An Error represents a runtime error, e.g. a TypeError, a ReferenceError, etc.
-type Error struct {
-	_error
-}
-
-// Error returns a description of the error
-//
-//    TypeError: 'def' is not a function
-//
-func (err Error) Error() string {
-	if len(err.name) == 0 {
-		return err.message
-	}
-	if len(err.message) == 0 {
-		return err.name
-	}
-	return fmt.Sprintf("%s: %s", err.name, err.message)
-}
-
-// String returns a description of the error and a trace of where the
-// error occurred.
-//
-//    TypeError: 'def' is not a function
-//        at xyz (<anonymous>:3:9)
-//        at <anonymous>:7:1/
-//
-func (err Error) String() string {
-	str := err.Error() + "\n"
-	for _, frame := range err.trace {
-		str += "    at " + frame.location() + "\n"
-	}
-	return str
-}
-
-func (err _error) describe(format string, in ...interface{}) string {
-	return fmt.Sprintf(format, in...)
-}
-
-func (self _error) messageValue() Value {
-	if self.message == "" {
-		return Value{}
-	}
-	return toValue_string(self.message)
-}
-
-func (rt *_runtime) typeErrorResult(throw bool) bool {
-	if throw {
-		panic(rt.panicTypeError())
-	}
-	return false
-}
-
-func newError(rt *_runtime, name string, in ...interface{}) _error {
-	err := _error{
-		name:   name,
-		offset: -1,
-	}
-	description := ""
-	length := len(in)
-
-	if rt != nil {
-		scope := rt.scope
-		frame := scope.frame
-		if length > 0 {
-			if at, ok := in[length-1].(_at); ok {
-				in = in[0 : length-1]
-				if scope != nil {
-					frame.offset = int(at)
-				}
-				length -= 1
-			}
-			if length > 0 {
-				description, in = in[0].(string), in[1:]
-			}
-		}
-		limit := 10
-		err.trace = append(err.trace, frame)
-		if scope != nil {
-			for limit > 0 {
-				scope = scope.outer
-				if scope == nil {
-					break
-				}
-				if scope.frame.offset >= 0 {
-					err.trace = append(err.trace, scope.frame)
-				}
-				limit--
-			}
-		}
-	} else {
-		if length > 0 {
-			description, in = in[0].(string), in[1:]
-		}
-	}
-	err.message = err.describe(description, in...)
-	return err
-}
-
-func (rt *_runtime) panicTypeError(argumentList ...interface{}) *_exception {
-	return &_exception{
-		value: newError(rt, "TypeError", argumentList...),
-	}
-}
-
-func (rt *_runtime) panicReferenceError(argumentList ...interface{}) *_exception {
-	return &_exception{
-		value: newError(rt, "ReferenceError", argumentList...),
-	}
-}
-
-func (rt *_runtime) panicURIError(argumentList ...interface{}) *_exception {
-	return &_exception{
-		value: newError(rt, "URIError", argumentList...),
-	}
-}
-
-func (rt *_runtime) panicSyntaxError(argumentList ...interface{}) *_exception {
-	return &_exception{
-		value: newError(rt, "SyntaxError", argumentList...),
-	}
-}
-
-func (rt *_runtime) panicRangeError(argumentList ...interface{}) *_exception {
-	return &_exception{
-		value: newError(rt, "RangeError", argumentList...),
-	}
-}
-
-func catchPanic(function func()) (err error) {
-	defer func() {
-		if caught := recover(); caught != nil {
-			if exception, ok := caught.(*_exception); ok {
-				caught = exception.eject()
-			}
-			switch caught := caught.(type) {
-			case _error:
-				err = &Error{caught}
-				return
-			case Value:
-				if vl := caught._object(); vl != nil {
-					switch vl := vl.value.(type) {
-					case _error:
-						err = &Error{vl}
-						return
-					}
-				}
-				err = errors.New(caught.string())
-				return
-			}
-			panic(caught)
-		}
-	}()
-	function()
-	return nil
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/evaluate.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/evaluate.go
deleted file mode 100644
index 093054cc3..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/evaluate.go
+++ /dev/null
@@ -1,318 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"strings"
-
-	"github.com/robertkrimen/otto/token"
-)
-
-func (self *_runtime) evaluateMultiply(left float64, right float64) Value {
-	// TODO 11.5.1
-	return Value{}
-}
-
-func (self *_runtime) evaluateDivide(left float64, right float64) Value {
-	if math.IsNaN(left) || math.IsNaN(right) {
-		return NaNValue()
-	}
-	if math.IsInf(left, 0) && math.IsInf(right, 0) {
-		return NaNValue()
-	}
-	if left == 0 && right == 0 {
-		return NaNValue()
-	}
-	if math.IsInf(left, 0) {
-		if math.Signbit(left) == math.Signbit(right) {
-			return positiveInfinityValue()
-		} else {
-			return negativeInfinityValue()
-		}
-	}
-	if math.IsInf(right, 0) {
-		if math.Signbit(left) == math.Signbit(right) {
-			return positiveZeroValue()
-		} else {
-			return negativeZeroValue()
-		}
-	}
-	if right == 0 {
-		if math.Signbit(left) == math.Signbit(right) {
-			return positiveInfinityValue()
-		} else {
-			return negativeInfinityValue()
-		}
-	}
-	return toValue_float64(left / right)
-}
-
-func (self *_runtime) evaluateModulo(left float64, right float64) Value {
-	// TODO 11.5.3
-	return Value{}
-}
-
-func (self *_runtime) calculateBinaryExpression(operator token.Token, left Value, right Value) Value {
-
-	leftValue := left.resolve()
-
-	switch operator {
-
-	// Additive
-	case token.PLUS:
-		leftValue = toPrimitive(leftValue)
-		rightValue := right.resolve()
-		rightValue = toPrimitive(rightValue)
-
-		if leftValue.IsString() || rightValue.IsString() {
-			return toValue_string(strings.Join([]string{leftValue.string(), rightValue.string()}, ""))
-		} else {
-			return toValue_float64(leftValue.float64() + rightValue.float64())
-		}
-	case token.MINUS:
-		rightValue := right.resolve()
-		return toValue_float64(leftValue.float64() - rightValue.float64())
-
-		// Multiplicative
-	case token.MULTIPLY:
-		rightValue := right.resolve()
-		return toValue_float64(leftValue.float64() * rightValue.float64())
-	case token.SLASH:
-		rightValue := right.resolve()
-		return self.evaluateDivide(leftValue.float64(), rightValue.float64())
-	case token.REMAINDER:
-		rightValue := right.resolve()
-		return toValue_float64(math.Mod(leftValue.float64(), rightValue.float64()))
-
-		// Logical
-	case token.LOGICAL_AND:
-		left := leftValue.bool()
-		if !left {
-			return falseValue
-		}
-		return toValue_bool(right.resolve().bool())
-	case token.LOGICAL_OR:
-		left := leftValue.bool()
-		if left {
-			return trueValue
-		}
-		return toValue_bool(right.resolve().bool())
-
-		// Bitwise
-	case token.AND:
-		rightValue := right.resolve()
-		return toValue_int32(toInt32(leftValue) & toInt32(rightValue))
-	case token.OR:
-		rightValue := right.resolve()
-		return toValue_int32(toInt32(leftValue) | toInt32(rightValue))
-	case token.EXCLUSIVE_OR:
-		rightValue := right.resolve()
-		return toValue_int32(toInt32(leftValue) ^ toInt32(rightValue))
-
-		// Shift
-		// (Masking of 0x1f is to restrict the shift to a maximum of 31 places)
-	case token.SHIFT_LEFT:
-		rightValue := right.resolve()
-		return toValue_int32(toInt32(leftValue) << (toUint32(rightValue) & 0x1f))
-	case token.SHIFT_RIGHT:
-		rightValue := right.resolve()
-		return toValue_int32(toInt32(leftValue) >> (toUint32(rightValue) & 0x1f))
-	case token.UNSIGNED_SHIFT_RIGHT:
-		rightValue := right.resolve()
-		// Shifting an unsigned integer is a logical shift
-		return toValue_uint32(toUint32(leftValue) >> (toUint32(rightValue) & 0x1f))
-
-	case token.INSTANCEOF:
-		rightValue := right.resolve()
-		if !rightValue.IsObject() {
-			panic(self.panicTypeError("Expecting a function in instanceof check, but got: %v", rightValue))
-		}
-		return toValue_bool(rightValue._object().hasInstance(leftValue))
-
-	case token.IN:
-		rightValue := right.resolve()
-		if !rightValue.IsObject() {
-			panic(self.panicTypeError())
-		}
-		return toValue_bool(rightValue._object().hasProperty(leftValue.string()))
-	}
-
-	panic(hereBeDragons(operator))
-}
-
-func valueKindDispatchKey(left _valueKind, right _valueKind) int {
-	return (int(left) << 2) + int(right)
-}
-
-var equalDispatch map[int](func(Value, Value) bool) = makeEqualDispatch()
-
-func makeEqualDispatch() map[int](func(Value, Value) bool) {
-	key := valueKindDispatchKey
-	return map[int](func(Value, Value) bool){
-
-		key(valueNumber, valueObject): func(x Value, y Value) bool { return x.float64() == y.float64() },
-		key(valueString, valueObject): func(x Value, y Value) bool { return x.float64() == y.float64() },
-		key(valueObject, valueNumber): func(x Value, y Value) bool { return x.float64() == y.float64() },
-		key(valueObject, valueString): func(x Value, y Value) bool { return x.float64() == y.float64() },
-	}
-}
-
-type _lessThanResult int
-
-const (
-	lessThanFalse _lessThanResult = iota
-	lessThanTrue
-	lessThanUndefined
-)
-
-func calculateLessThan(left Value, right Value, leftFirst bool) _lessThanResult {
-
-	x := Value{}
-	y := x
-
-	if leftFirst {
-		x = toNumberPrimitive(left)
-		y = toNumberPrimitive(right)
-	} else {
-		y = toNumberPrimitive(right)
-		x = toNumberPrimitive(left)
-	}
-
-	result := false
-	if x.kind != valueString || y.kind != valueString {
-		x, y := x.float64(), y.float64()
-		if math.IsNaN(x) || math.IsNaN(y) {
-			return lessThanUndefined
-		}
-		result = x < y
-	} else {
-		x, y := x.string(), y.string()
-		result = x < y
-	}
-
-	if result {
-		return lessThanTrue
-	}
-
-	return lessThanFalse
-}
-
-// FIXME Probably a map is not the most efficient way to do this
-var lessThanTable [4](map[_lessThanResult]bool) = [4](map[_lessThanResult]bool){
-	// <
-	map[_lessThanResult]bool{
-		lessThanFalse:     false,
-		lessThanTrue:      true,
-		lessThanUndefined: false,
-	},
-
-	// >
-	map[_lessThanResult]bool{
-		lessThanFalse:     false,
-		lessThanTrue:      true,
-		lessThanUndefined: false,
-	},
-
-	// <=
-	map[_lessThanResult]bool{
-		lessThanFalse:     true,
-		lessThanTrue:      false,
-		lessThanUndefined: false,
-	},
-
-	// >=
-	map[_lessThanResult]bool{
-		lessThanFalse:     true,
-		lessThanTrue:      false,
-		lessThanUndefined: false,
-	},
-}
-
-func (self *_runtime) calculateComparison(comparator token.Token, left Value, right Value) bool {
-
-	// FIXME Use strictEqualityComparison?
-	// TODO This might be redundant now (with regards to evaluateComparison)
-	x := left.resolve()
-	y := right.resolve()
-
-	kindEqualKind := false
-	result := true
-	negate := false
-
-	switch comparator {
-	case token.LESS:
-		result = lessThanTable[0][calculateLessThan(x, y, true)]
-	case token.GREATER:
-		result = lessThanTable[1][calculateLessThan(y, x, false)]
-	case token.LESS_OR_EQUAL:
-		result = lessThanTable[2][calculateLessThan(y, x, false)]
-	case token.GREATER_OR_EQUAL:
-		result = lessThanTable[3][calculateLessThan(x, y, true)]
-	case token.STRICT_NOT_EQUAL:
-		negate = true
-		fallthrough
-	case token.STRICT_EQUAL:
-		if x.kind != y.kind {
-			result = false
-		} else {
-			kindEqualKind = true
-		}
-	case token.NOT_EQUAL:
-		negate = true
-		fallthrough
-	case token.EQUAL:
-		if x.kind == y.kind {
-			kindEqualKind = true
-		} else if x.kind <= valueNull && y.kind <= valueNull {
-			result = true
-		} else if x.kind <= valueNull || y.kind <= valueNull {
-			result = false
-		} else if x.kind <= valueString && y.kind <= valueString {
-			result = x.float64() == y.float64()
-		} else if x.kind == valueBoolean {
-			result = self.calculateComparison(token.EQUAL, toValue_float64(x.float64()), y)
-		} else if y.kind == valueBoolean {
-			result = self.calculateComparison(token.EQUAL, x, toValue_float64(y.float64()))
-		} else if x.kind == valueObject {
-			result = self.calculateComparison(token.EQUAL, toPrimitive(x), y)
-		} else if y.kind == valueObject {
-			result = self.calculateComparison(token.EQUAL, x, toPrimitive(y))
-		} else {
-			panic(hereBeDragons("Unable to test for equality: %v ==? %v", x, y))
-		}
-	default:
-		panic(fmt.Errorf("Unknown comparator %s", comparator.String()))
-	}
-
-	if kindEqualKind {
-		switch x.kind {
-		case valueUndefined, valueNull:
-			result = true
-		case valueNumber:
-			x := x.float64()
-			y := y.float64()
-			if math.IsNaN(x) || math.IsNaN(y) {
-				result = false
-			} else {
-				result = x == y
-			}
-		case valueString:
-			result = x.string() == y.string()
-		case valueBoolean:
-			result = x.bool() == y.bool()
-		case valueObject:
-			result = x._object() == y._object()
-		default:
-			goto ERROR
-		}
-	}
-
-	if negate {
-		result = !result
-	}
-
-	return result
-
-ERROR:
-	panic(hereBeDragons("%v (%v) %s %v (%v)", x, x.kind, comparator, y, y.kind))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/file/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/file/README.markdown
deleted file mode 100644
index 79757baa8..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/file/README.markdown
+++ /dev/null
@@ -1,110 +0,0 @@
-# file
---
-    import "github.com/robertkrimen/otto/file"
-
-Package file encapsulates the file abstractions used by the ast & parser.
-
-## Usage
-
-#### type File
-
-```go
-type File struct {
-}
-```
-
-
-#### func  NewFile
-
-```go
-func NewFile(filename, src string, base int) *File
-```
-
-#### func (*File) Base
-
-```go
-func (fl *File) Base() int
-```
-
-#### func (*File) Name
-
-```go
-func (fl *File) Name() string
-```
-
-#### func (*File) Source
-
-```go
-func (fl *File) Source() string
-```
-
-#### type FileSet
-
-```go
-type FileSet struct {
-}
-```
-
-A FileSet represents a set of source files.
-
-#### func (*FileSet) AddFile
-
-```go
-func (self *FileSet) AddFile(filename, src string) int
-```
-AddFile adds a new file with the given filename and src.
-
-This an internal method, but exported for cross-package use.
-
-#### func (*FileSet) File
-
-```go
-func (self *FileSet) File(idx Idx) *File
-```
-
-#### func (*FileSet) Position
-
-```go
-func (self *FileSet) Position(idx Idx) *Position
-```
-Position converts an Idx in the FileSet into a Position.
-
-#### type Idx
-
-```go
-type Idx int
-```
-
-Idx is a compact encoding of a source position within a file set. It can be
-converted into a Position for a more convenient, but much larger,
-representation.
-
-#### type Position
-
-```go
-type Position struct {
-	Filename string // The filename where the error occurred, if any
-	Offset   int    // The src offset
-	Line     int    // The line number, starting at 1
-	Column   int    // The column number, starting at 1 (The character count)
-
-}
-```
-
-Position describes an arbitrary source position including the filename, line,
-and column location.
-
-#### func (*Position) String
-
-```go
-func (self *Position) String() string
-```
-String returns a string in one of several forms:
-
-    file:line:column    A valid position with filename
-    line:column         A valid position without filename
-    file                An invalid position with filename
-    -                   An invalid position without filename
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/file/file.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/file/file.go
deleted file mode 100644
index 76524ac39..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/file/file.go
+++ /dev/null
@@ -1,135 +0,0 @@
-// Package file encapsulates the file abstractions used by the ast & parser.
-//
-package file
-
-import (
-	"fmt"
-	"strings"
-)
-
-// Idx is a compact encoding of a source position within a file set.
-// It can be converted into a Position for a more convenient, but much
-// larger, representation.
-type Idx int
-
-// Position describes an arbitrary source position
-// including the filename, line, and column location.
-type Position struct {
-	Filename string // The filename where the error occurred, if any
-	Offset   int    // The src offset
-	Line     int    // The line number, starting at 1
-	Column   int    // The column number, starting at 1 (The character count)
-
-}
-
-// A Position is valid if the line number is > 0.
-
-func (self *Position) isValid() bool {
-	return self.Line > 0
-}
-
-// String returns a string in one of several forms:
-//
-//	file:line:column    A valid position with filename
-//	line:column         A valid position without filename
-//	file                An invalid position with filename
-//	-                   An invalid position without filename
-//
-func (self *Position) String() string {
-	str := self.Filename
-	if self.isValid() {
-		if str != "" {
-			str += ":"
-		}
-		str += fmt.Sprintf("%d:%d", self.Line, self.Column)
-	}
-	if str == "" {
-		str = "-"
-	}
-	return str
-}
-
-// FileSet
-
-// A FileSet represents a set of source files.
-type FileSet struct {
-	files []*File
-	last  *File
-}
-
-// AddFile adds a new file with the given filename and src.
-//
-// This an internal method, but exported for cross-package use.
-func (self *FileSet) AddFile(filename, src string) int {
-	base := self.nextBase()
-	file := &File{
-		name: filename,
-		src:  src,
-		base: base,
-	}
-	self.files = append(self.files, file)
-	self.last = file
-	return base
-}
-
-func (self *FileSet) nextBase() int {
-	if self.last == nil {
-		return 1
-	}
-	return self.last.base + len(self.last.src) + 1
-}
-
-func (self *FileSet) File(idx Idx) *File {
-	for _, file := range self.files {
-		if idx <= Idx(file.base+len(file.src)) {
-			return file
-		}
-	}
-	return nil
-}
-
-// Position converts an Idx in the FileSet into a Position.
-func (self *FileSet) Position(idx Idx) *Position {
-	position := &Position{}
-	for _, file := range self.files {
-		if idx <= Idx(file.base+len(file.src)) {
-			offset := int(idx) - file.base
-			src := file.src[:offset]
-			position.Filename = file.name
-			position.Offset = offset
-			position.Line = 1 + strings.Count(src, "\n")
-			if index := strings.LastIndex(src, "\n"); index >= 0 {
-				position.Column = offset - index
-			} else {
-				position.Column = 1 + len(src)
-			}
-		}
-	}
-	return position
-}
-
-type File struct {
-	name string
-	src  string
-	base int // This will always be 1 or greater
-}
-
-func NewFile(filename, src string, base int) *File {
-	return &File{
-		name: filename,
-		src:  src,
-		base: base,
-	}
-}
-
-func (fl *File) Name() string {
-	return fl.name
-}
-
-func (fl *File) Source() string {
-	return fl.src
-}
-
-func (fl *File) Base() int {
-	return fl.base
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/global.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/global.go
deleted file mode 100644
index 4f035314a..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/global.go
+++ /dev/null
@@ -1,221 +0,0 @@
-package otto
-
-import (
-	"strconv"
-	"time"
-)
-
-var (
-	prototypeValueObject   = interface{}(nil)
-	prototypeValueFunction = _nativeFunctionObject{
-		call: func(_ FunctionCall) Value {
-			return Value{}
-		},
-	}
-	prototypeValueString = _stringASCII("")
-	// TODO Make this just false?
-	prototypeValueBoolean = Value{
-		kind:  valueBoolean,
-		value: false,
-	}
-	prototypeValueNumber = Value{
-		kind:  valueNumber,
-		value: 0,
-	}
-	prototypeValueDate = _dateObject{
-		epoch: 0,
-		isNaN: false,
-		time:  time.Unix(0, 0).UTC(),
-		value: Value{
-			kind:  valueNumber,
-			value: 0,
-		},
-	}
-	prototypeValueRegExp = _regExpObject{
-		regularExpression: nil,
-		global:            false,
-		ignoreCase:        false,
-		multiline:         false,
-		source:            "",
-		flags:             "",
-	}
-)
-
-func newContext() *_runtime {
-
-	self := &_runtime{}
-
-	self.globalStash = self.newObjectStash(nil, nil)
-	self.globalObject = self.globalStash.object
-
-	_newContext(self)
-
-	self.eval = self.globalObject.property["eval"].value.(Value).value.(*_object)
-	self.globalObject.prototype = self.global.ObjectPrototype
-
-	return self
-}
-
-func (runtime *_runtime) newBaseObject() *_object {
-	self := newObject(runtime, "")
-	return self
-}
-
-func (runtime *_runtime) newClassObject(class string) *_object {
-	return newObject(runtime, class)
-}
-
-func (runtime *_runtime) newPrimitiveObject(class string, value Value) *_object {
-	self := runtime.newClassObject(class)
-	self.value = value
-	return self
-}
-
-func (self *_object) primitiveValue() Value {
-	switch value := self.value.(type) {
-	case Value:
-		return value
-	case _stringObject:
-		return toValue_string(value.String())
-	}
-	return Value{}
-}
-
-func (self *_object) hasPrimitive() bool {
-	switch self.value.(type) {
-	case Value, _stringObject:
-		return true
-	}
-	return false
-}
-
-func (runtime *_runtime) newObject() *_object {
-	self := runtime.newClassObject("Object")
-	self.prototype = runtime.global.ObjectPrototype
-	return self
-}
-
-func (runtime *_runtime) newArray(length uint32) *_object {
-	self := runtime.newArrayObject(length)
-	self.prototype = runtime.global.ArrayPrototype
-	return self
-}
-
-func (runtime *_runtime) newArrayOf(valueArray []Value) *_object {
-	self := runtime.newArray(uint32(len(valueArray)))
-	for index, value := range valueArray {
-		if value.isEmpty() {
-			continue
-		}
-		self.defineProperty(strconv.FormatInt(int64(index), 10), value, 0111, false)
-	}
-	return self
-}
-
-func (runtime *_runtime) newString(value Value) *_object {
-	self := runtime.newStringObject(value)
-	self.prototype = runtime.global.StringPrototype
-	return self
-}
-
-func (runtime *_runtime) newBoolean(value Value) *_object {
-	self := runtime.newBooleanObject(value)
-	self.prototype = runtime.global.BooleanPrototype
-	return self
-}
-
-func (runtime *_runtime) newNumber(value Value) *_object {
-	self := runtime.newNumberObject(value)
-	self.prototype = runtime.global.NumberPrototype
-	return self
-}
-
-func (runtime *_runtime) newRegExp(patternValue Value, flagsValue Value) *_object {
-
-	pattern := ""
-	flags := ""
-	if object := patternValue._object(); object != nil && object.class == "RegExp" {
-		if flagsValue.IsDefined() {
-			panic(runtime.panicTypeError("Cannot supply flags when constructing one RegExp from another"))
-		}
-		regExp := object.regExpValue()
-		pattern = regExp.source
-		flags = regExp.flags
-	} else {
-		if patternValue.IsDefined() {
-			pattern = patternValue.string()
-		}
-		if flagsValue.IsDefined() {
-			flags = flagsValue.string()
-		}
-	}
-
-	return runtime._newRegExp(pattern, flags)
-}
-
-func (runtime *_runtime) _newRegExp(pattern string, flags string) *_object {
-	self := runtime.newRegExpObject(pattern, flags)
-	self.prototype = runtime.global.RegExpPrototype
-	return self
-}
-
-// TODO Should (probably) be one argument, right? This is redundant
-func (runtime *_runtime) newDate(epoch float64) *_object {
-	self := runtime.newDateObject(epoch)
-	self.prototype = runtime.global.DatePrototype
-	return self
-}
-
-func (runtime *_runtime) newError(name string, message Value) *_object {
-	var self *_object
-	switch name {
-	case "EvalError":
-		return runtime.newEvalError(message)
-	case "TypeError":
-		return runtime.newTypeError(message)
-	case "RangeError":
-		return runtime.newRangeError(message)
-	case "ReferenceError":
-		return runtime.newReferenceError(message)
-	case "SyntaxError":
-		return runtime.newSyntaxError(message)
-	case "URIError":
-		return runtime.newURIError(message)
-	}
-
-	self = runtime.newErrorObject(name, message)
-	self.prototype = runtime.global.ErrorPrototype
-	if name != "" {
-		self.defineProperty("name", toValue_string(name), 0111, false)
-	}
-	return self
-}
-
-func (runtime *_runtime) newNativeFunction(name string, _nativeFunction _nativeFunction) *_object {
-	self := runtime.newNativeFunctionObject(name, _nativeFunction, 0)
-	self.prototype = runtime.global.FunctionPrototype
-	prototype := runtime.newObject()
-	self.defineProperty("prototype", toValue_object(prototype), 0100, false)
-	prototype.defineProperty("constructor", toValue_object(self), 0100, false)
-	return self
-}
-
-func (runtime *_runtime) newNodeFunction(node *_nodeFunctionLiteral, scopeEnvironment _stash) *_object {
-	// TODO Implement 13.2 fully
-	self := runtime.newNodeFunctionObject(node, scopeEnvironment)
-	self.prototype = runtime.global.FunctionPrototype
-	prototype := runtime.newObject()
-	self.defineProperty("prototype", toValue_object(prototype), 0100, false)
-	prototype.defineProperty("constructor", toValue_object(self), 0101, false)
-	return self
-}
-
-// FIXME Only in one place...
-func (runtime *_runtime) newBoundFunction(target *_object, this Value, argumentList []Value) *_object {
-	self := runtime.newBoundFunctionObject(target, this, argumentList)
-	self.prototype = runtime.global.FunctionPrototype
-	prototype := runtime.newObject()
-	self.defineProperty("prototype", toValue_object(prototype), 0100, false)
-	prototype.defineProperty("constructor", toValue_object(self), 0100, false)
-	return self
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/inline b/Godeps/_workspace/src/github.com/robertkrimen/otto/inline
deleted file mode 100644
index c3620b4a2..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/inline
+++ /dev/null
@@ -1,1086 +0,0 @@
-#!/usr/bin/env perl
-
-my $_fmt;
-$_fmt = "gofmt";
-$_fmt = "cat -n" if "cat" eq ($ARGV[0] || "");
-
-use strict;
-use warnings;
-use IO::File;
-
-my $self = __PACKAGE__;
-
-sub functionLabel ($) {
-    return "$_[0]_function";
-}
-
-sub trim ($) {
-    local $_ = shift;
-    s/^\s*//, s/\s*$// for $_;
-    return $_;
-}
-
-open my $fmt, "|-", "$_fmt" or die $!;
-
-$fmt->print(<<_END_);
-package otto
-
-import (
-    "math"
-)
-
-func _newContext(runtime *_runtime) {
-@{[ join "\n", $self->newContext() ]}
-}    
-
-func newConsoleObject(runtime *_runtime) *_object {
-@{[ join "\n", $self->newConsoleObject() ]}
-}    
-_END_
-
-for (qw/int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 float32 float64/) {
-    $fmt->print(<<_END_);
-
-func toValue_$_(value $_) Value {
-    return Value{
-        kind: valueNumber,
-        value: value,
-    }
-}
-_END_
-}
-
-$fmt->print(<<_END_);
-
-func toValue_string(value string) Value {
-    return Value{
-        kind: valueString,
-        value: value,
-    }
-}
-
-func toValue_string16(value []uint16) Value {
-    return Value{
-        kind: valueString,
-        value: value,
-    }
-}
-
-func toValue_bool(value bool) Value {
-    return Value{
-        kind: valueBoolean,
-        value: value,
-    }
-}
-
-func toValue_object(value *_object) Value {
-    return Value{
-        kind: valueObject,
-        value: value,
-    }
-}
-_END_
-
-close $fmt;
-
-sub newConsoleObject {
-    my $self = shift;
-
-    return
-        $self->block(sub {
-            my $class = "Console";
-            my @got = $self->functionDeclare(
-                $class,
-                "log", 0,
-                "debug:log", 0,
-                "info:log", 0,
-                "error", 0,
-                "warn:error", 0,
-                "dir", 0,
-                "time", 0,
-                "timeEnd", 0,
-                "trace", 0,
-                "assert", 0,
-            );
-            return
-            "return @{[ $self->newObject(@got) ]}"
-        }),
-    ;
-}
-
-sub newContext {
-    my $self = shift;
-    return
-        # ObjectPrototype
-        $self->block(sub {
-            my $class = "Object";
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                undef,
-                "prototypeValueObject",
-            ),
-        }),
-
-        # FunctionPrototype
-        $self->block(sub {
-            my $class = "Function";
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                "prototypeValueFunction",
-            ),
-        }),
-
-        # ObjectPrototype
-        $self->block(sub {
-            my $class = "Object";
-            my @got = $self->functionDeclare(
-                $class,
-                "valueOf", 0,
-                "toString", 0,
-                "toLocaleString", 0,
-                "hasOwnProperty", 1,
-                "isPrototypeOf", 1,
-                "propertyIsEnumerable", 1,
-            );
-            my @propertyMap = $self->propertyMap(
-                @got,
-                $self->property("constructor", undef),
-            );
-            my $propertyOrder = $self->propertyOrder(@propertyMap);
-            $propertyOrder =~ s/^propertyOrder: //;
-            return
-            ".${class}Prototype.property =", @propertyMap,
-            ".${class}Prototype.propertyOrder =", $propertyOrder,
-        }),
-
-        # FunctionPrototype
-        $self->block(sub {
-            my $class = "Function";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "apply", 2,
-                "call", 1,
-                "bind", 1,
-            );
-            my @propertyMap = $self->propertyMap(
-                @got,
-                $self->property("constructor", undef),
-                $self->property("length", $self->numberValue(0), "0"),
-            );
-            my $propertyOrder = $self->propertyOrder(@propertyMap);
-            $propertyOrder =~ s/^propertyOrder: //;
-            return
-            ".${class}Prototype.property =", @propertyMap,
-            ".${class}Prototype.propertyOrder =", $propertyOrder,
-        }),
-
-        # Object
-        $self->block(sub {
-            my $class = "Object";
-            return
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-                    "getPrototypeOf", 1,
-                    "getOwnPropertyDescriptor", 2,
-                    "defineProperty", 3,
-                    "defineProperties", 2,
-                    "create", 2,
-                    "isExtensible", 1,
-                    "preventExtensions", 1,
-                    "isSealed", 1,
-                    "seal", 1,
-                    "isFrozen", 1,
-                    "freeze", 1,
-                    "keys", 1,
-                    "getOwnPropertyNames", 1,
-                ),
-            ),
-        }),
-
-        # Function
-        $self->block(sub {
-            my $class = "Function";
-            return
-            "Function :=",
-            $self->globalFunction(
-                $class,
-                1,
-            ),
-            ".$class = Function",
-        }),
-
-        # Array
-        $self->block(sub {
-            my $class = "Array";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "toLocaleString", 0,
-                "concat", 1,
-                "join", 1,
-                "splice", 2,
-                "shift", 0,
-                "pop", 0,
-                "push", 1,
-                "slice", 2,
-                "unshift", 1,
-                "reverse", 0,
-                "sort", 1,
-                "indexOf", 1,
-                "lastIndexOf", 1,
-                "every", 1,
-                "some", 1,
-                "forEach", 1,
-                "map", 1,
-                "filter", 1,
-                "reduce", 1,
-                "reduceRight", 1,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classArray",
-                ".ObjectPrototype",
-                undef,
-                $self->property("length", $self->numberValue("uint32(0)"), "0100"),
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-                    "isArray", 1,
-                ),
-            ),
-        }),
-
-        # String
-        $self->block(sub {
-            my $class = "String";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "valueOf", 0,
-                "charAt", 1,
-                "charCodeAt", 1,
-                "concat", 1,
-                "indexOf", 1,
-                "lastIndexOf", 1,
-                "match", 1,
-                "replace", 2,
-                "search", 1,
-                "split", 2,
-                "slice", 2,
-                "substring", 2,
-                "toLowerCase", 0,
-                "toUpperCase", 0,
-                "substr", 2,
-                "trim", 0,
-                "trimLeft", 0,
-                "trimRight", 0,
-                "localeCompare", 1,
-                "toLocaleLowerCase", 0,
-                "toLocaleUpperCase", 0,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classString",
-                ".ObjectPrototype",
-                "prototypeValueString",
-                $self->property("length", $self->numberValue("int(0)"), "0"),
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-		            "fromCharCode", 1,
-                ),
-            ),
-        }),
-
-        # Boolean
-        $self->block(sub {
-            my $class = "Boolean";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "valueOf", 0,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                "prototypeValueBoolean",
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-                ),
-            ),
-        }),
-
-        # Number
-        $self->block(sub {
-            my $class = "Number";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "valueOf", 0,
-                "toFixed", 1,
-                "toExponential", 1,
-                "toPrecision", 1,
-                "toLocaleString", 1,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                "prototypeValueNumber",
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-                ),
-                $self->numberConstantDeclare(
-                    "MAX_VALUE", "math.MaxFloat64",
-                    "MIN_VALUE", "math.SmallestNonzeroFloat64",
-                    "NaN", "math.NaN()",
-                    "NEGATIVE_INFINITY", "math.Inf(-1)",
-                    "POSITIVE_INFINITY", "math.Inf(+1)",
-                ),
-            ),
-        }),
-
-        # Math
-        $self->block(sub {
-            my $class = "Math";
-            return
-            ".$class =",
-            $self->globalObject(
-                $class,
-                $self->functionDeclare(
-                    $class,
-                    "abs", 1,
-                    "acos", 1,
-                    "asin", 1,
-                    "atan", 1,
-                    "atan2", 1,
-                    "ceil", 1,
-                    "cos", 1,
-                    "exp", 1,
-                    "floor", 1,
-                    "log", 1,
-                    "max", 2,
-                    "min", 2,
-                    "pow", 2,
-                    "random", 0,
-                    "round", 1,
-                    "sin", 1,
-                    "sqrt", 1,
-                    "tan", 1,
-                ),
-                $self->numberConstantDeclare(
-                    "E", "math.E",
-                    "LN10", "math.Ln10",
-                    "LN2", "math.Ln2",
-                    "LOG2E", "math.Log2E",
-                    "LOG10E", "math.Log10E",
-                    "PI", "math.Pi",
-                    "SQRT1_2", "sqrt1_2",
-                    "SQRT2", "math.Sqrt2",
-                )
-            ),
-        }),
-
-        # Date
-        $self->block(sub {
-            my $class = "Date";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "toDateString", 0,
-                "toTimeString", 0,
-                "toUTCString", 0,
-                "toISOString", 0,
-                "toJSON", 1,
-                "toGMTString", 0,
-                "toLocaleString", 0,
-                "toLocaleDateString", 0,
-                "toLocaleTimeString", 0,
-                "valueOf", 0,
-                "getTime", 0,
-                "getYear", 0,
-                "getFullYear", 0,
-                "getUTCFullYear", 0,
-                "getMonth", 0,
-                "getUTCMonth", 0,
-                "getDate", 0,
-                "getUTCDate", 0,
-                "getDay", 0,
-                "getUTCDay", 0,
-                "getHours", 0,
-                "getUTCHours", 0,
-                "getMinutes", 0,
-                "getUTCMinutes", 0,
-                "getSeconds", 0,
-                "getUTCSeconds", 0,
-                "getMilliseconds", 0,
-                "getUTCMilliseconds", 0,
-                "getTimezoneOffset", 0,
-                "setTime", 1,
-                "setMilliseconds", 1,
-                "setUTCMilliseconds", 1,
-                "setSeconds", 2,
-                "setUTCSeconds", 2,
-                "setMinutes", 3,
-                "setUTCMinutes", 3,
-                "setHours", 4,
-                "setUTCHours", 4,
-                "setDate", 1,
-                "setUTCDate", 1,
-                "setMonth", 2,
-                "setUTCMonth", 2,
-                "setYear", 1,
-                "setFullYear", 3,
-                "setUTCFullYear", 3,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                "prototypeValueDate",
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                7,
-                $self->functionDeclare(
-                    $class,
-                    "parse", 1,
-                    "UTC", 7,
-                    "now", 0,
-                ),
-            ),
-        }),
-
-        # RegExp
-        $self->block(sub {
-            my $class = "RegExp";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-                "exec", 1,
-                "test", 1,
-                "compile", 1,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                "prototypeValueRegExp",
-                @got,
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                2,
-                $self->functionDeclare(
-                    $class,
-                ),
-            ),
-        }),
-
-        # Error
-        $self->block(sub {
-            my $class = "Error";
-            my @got = $self->functionDeclare(
-                $class,
-                "toString", 0,
-            );
-            return
-            ".${class}Prototype =",
-            $self->globalPrototype(
-                $class,
-                "_classObject",
-                ".ObjectPrototype",
-                undef,
-                @got,
-                $self->property("name", $self->stringValue("Error")),
-                $self->property("message", $self->stringValue("")),
-            ),
-            ".$class =",
-            $self->globalFunction(
-                $class,
-                1,
-                $self->functionDeclare(
-                    $class,
-                ),
-            ),
-        }),
-
-        (map {
-            my $class = "${_}Error";
-            $self->block(sub {
-                my @got = $self->functionDeclare(
-                    $class,
-                );
-                return
-                ".${class}Prototype =",
-                $self->globalPrototype(
-                    $class,
-                    "_classObject",
-                    ".ErrorPrototype",
-                    undef,
-                    @got,
-                    $self->property("name", $self->stringValue($class)),
-                ),
-                ".$class =",
-                $self->globalFunction(
-                    $class,
-                    1,
-                    $self->functionDeclare(
-                        $class,
-                    ),
-                ),
-            });
-        } qw/Eval Type Range Reference Syntax URI/),
-
-        # JSON
-        $self->block(sub {
-            my $class = "JSON";
-            return
-            ".$class =",
-            $self->globalObject(
-                $class,
-                $self->functionDeclare(
-                    $class,
-                    "parse", 2,
-                    "stringify", 3,
-                ),
-            ),
-        }),
-
-        # Global
-        $self->block(sub {
-            my $class = "Global";
-            my @got = $self->functionDeclare(
-                $class,
-                "eval", 1,
-                "parseInt", 2,
-                "parseFloat", 1,
-                "isNaN", 1,
-                "isFinite", 1,
-                "decodeURI", 1,
-                "decodeURIComponent", 1,
-                "encodeURI", 1,
-                "encodeURIComponent", 1,
-                "escape", 1,
-                "unescape", 1,
-            );
-            my @propertyMap = $self->propertyMap(
-                @got,
-                $self->globalDeclare(
-                    "Object",
-                    "Function",
-                    "Array",
-                    "String",
-                    "Boolean",
-                    "Number",
-                    "Math",
-                    "Date",
-                    "RegExp",
-                    "Error",
-                    "EvalError",
-                    "TypeError",
-                    "RangeError",
-                    "ReferenceError",
-                    "SyntaxError",
-                    "URIError",
-                    "JSON",
-                ),
-                $self->property("undefined", $self->undefinedValue(), "0"),
-                $self->property("NaN", $self->numberValue("math.NaN()"), "0"),
-                $self->property("Infinity", $self->numberValue("math.Inf(+1)"), "0"),
-            );
-            my $propertyOrder = $self->propertyOrder(@propertyMap);
-            $propertyOrder =~ s/^propertyOrder: //;
-            return
-            "runtime.globalObject.property =",
-            @propertyMap,
-            "runtime.globalObject.propertyOrder =",
-            $propertyOrder,
-            ;
-        }),
-    ;
-}
-
-sub propertyMap {
-    my $self = shift;
-    return "map[string]_property{", (join ",\n", @_, ""), "}",
-}
-
-our (@preblock, @postblock);
-sub block {
-    my $self = shift;
-    local @preblock = ();
-    local @postblock = ();
-    my @input = $_[0]->();
-    my @output;
-    while (@input) {
-        local $_ = shift @input;
-        if (m/^\./) {
-            $_ = "runtime.global$_";
-        }
-        if (m/ :?=$/) {
-            $_ .= shift @input;
-        }
-        push @output, $_;
-    }
-    return
-    "{",
-        @preblock,
-        @output,
-        @postblock,
-    "}",
-    ;
-}
-
-sub numberConstantDeclare {
-    my $self = shift;
-    my @got;
-    while (@_) {
-        my $name = shift;
-        my $value = shift;
-        push @got, $self->property($name, $self->numberValue($value), "0"),
-    }
-    return @got;
-}
-
-sub functionDeclare {
-    my $self = shift;
-    my $class = shift;
-    my $builtin = "builtin${class}";
-    my @got;
-    while (@_) {
-        my $name = shift;
-        my $length = shift;
-        $name = $self->newFunction($name, "${builtin}_", $length);
-        push @got, $self->functionProperty($name),
-    }
-    return @got;
-}
-
-sub globalDeclare {
-    my $self = shift;
-    my @got;
-    while (@_) {
-        my $name = shift;
-        push @got, $self->property($name, $self->objectValue("runtime.global.$name"), "0101"),
-    }
-    return @got;
-}
-
-sub propertyOrder {
-    my $self = shift;
-    my $propertyMap = join "", @_;
-
-    my (@keys) = $propertyMap =~ m/("\w+"):/g;
-    my $propertyOrder =
-        join "\n", "propertyOrder: []string{", (join ",\n", @keys, ""), "}";
-    return $propertyOrder;
-}
-
-sub globalObject {
-    my $self = shift;
-    my $name = shift;
-    
-    my $propertyMap = "";
-    if (@_) {
-        $propertyMap = join "\n", $self->propertyMap(@_);
-        my $propertyOrder = $self->propertyOrder($propertyMap);
-        $propertyMap = "property: $propertyMap,\n$propertyOrder,";
-    }
-
-    return trim <<_END_;
-&_object{
-    runtime: runtime,
-    class: "$name",
-    objectClass: _classObject,
-    prototype: runtime.global.ObjectPrototype,
-    extensible: true,
-    $propertyMap
-}
-_END_
-}
-
-sub globalFunction {
-    my $self = shift;
-    my $name = shift;
-    my $length = shift;
-    
-    my $builtin = "builtin${name}";
-    my $builtinNew = "builtinNew${name}";
-    my $prototype = "runtime.global.${name}Prototype";
-    my $propertyMap = "";
-    unshift @_,
-        $self->property("length", $self->numberValue($length), "0"),
-        $self->property("prototype", $self->objectValue($prototype), "0"),
-    ;
-
-    if (@_) {
-        $propertyMap = join "\n", $self->propertyMap(@_);
-        my $propertyOrder = $self->propertyOrder($propertyMap);
-        $propertyMap = "property: $propertyMap,\n$propertyOrder,";
-    }
-
-    push @postblock, $self->statement(
-        "$prototype.property[\"constructor\"] =",
-        $self->property(undef, $self->objectValue("runtime.global.${name}"), "0101"),
-    );
-
-    return trim <<_END_;
-&_object{
-    runtime: runtime,
-    class: "Function",
-    objectClass: _classObject,
-    prototype: runtime.global.FunctionPrototype,
-    extensible: true,
-    value: @{[ $self->nativeFunctionOf($name, $builtin, $builtinNew) ]},
-    $propertyMap
-}
-_END_
-}
-
-sub nativeCallFunction {
-    my $self = shift;
-    my $name = shift;
-    my $func = shift;
-    return trim <<_END_;
-_nativeCallFunction{ "$name", $func }
-_END_
-}
-
-sub globalPrototype {
-    my $self = shift;
-    my $class = shift;
-    my $classObject = shift;
-    my $prototype = shift;
-    my $value = shift;
-
-    if (!defined $prototype) {
-        $prototype = "nil";
-    }
-
-    if (!defined $value) {
-        $value = "nil";
-    }
-
-    if ($prototype =~ m/^\./) {
-        $prototype = "runtime.global$prototype";
-    }
-
-    my $propertyMap = "";
-    if (@_) {
-        $propertyMap = join "\n", $self->propertyMap(@_);
-        my $propertyOrder = $self->propertyOrder($propertyMap);
-        $propertyMap = "property: $propertyMap,\n$propertyOrder,";
-    }
-
-    return trim <<_END_;
-&_object{
-    runtime: runtime,
-    class: "$class",
-    objectClass: $classObject,
-    prototype: $prototype,
-    extensible: true,
-    value: $value,
-    $propertyMap
-}
-_END_
-}
-
-sub newFunction {
-    my $self = shift;
-    my $name = shift;
-    my $func = shift;
-    my $length = shift;
-
-    my @name = ($name, $name);
-    if ($name =~ m/^(\w+):(\w+)$/) {
-        @name = ($1, $2);
-        $name = $name[0];
-    }
-
-    if ($func =~ m/^builtin\w+_$/) {
-        $func = "$func$name[1]";
-    }
-
-    my $propertyOrder = "";
-    my @propertyMap = (
-        $self->property("length", $self->numberValue($length), "0"),
-    );
-
-    if (@propertyMap) {
-        $propertyOrder = $self->propertyOrder(@propertyMap);
-        $propertyOrder = "$propertyOrder,";
-    }
-
-    my $label = functionLabel($name);
-    push @preblock, $self->statement(
-        "$label := @{[ trim <<_END_ ]}",
-&_object{
-    runtime: runtime,
-    class: "Function",
-    objectClass: _classObject,
-    prototype: runtime.global.FunctionPrototype,
-    extensible: true,
-    property: @{[ join "\n", $self->propertyMap(@propertyMap) ]},
-    $propertyOrder
-    value: @{[ $self->nativeFunctionOf($name, $func) ]},
-} 
-_END_
-    );
-
-    return $name;
-}
-
-sub newObject {
-    my $self = shift;
-
-    my $propertyMap = join "\n", $self->propertyMap(@_);
-    my $propertyOrder = $self->propertyOrder($propertyMap);
-
-    return trim <<_END_;
-&_object{
-    runtime: runtime,
-    class: "Object",
-    objectClass: _classObject,
-    prototype: runtime.global.ObjectPrototype,
-    extensible: true,
-    property: $propertyMap,
-    $propertyOrder,
-} 
-_END_
-}
-
-sub newPrototypeObject {
-    my $self = shift;
-    my $class = shift;
-    my $objectClass = shift;
-    my $value = shift;
-    if (defined $value) {
-        $value = "value: $value,";
-    }
-
-    my $propertyMap = join "\n", $self->propertyMap(@_);
-    my $propertyOrder = $self->propertyOrder($propertyMap);
-
-    return trim <<_END_;
-&_object{
-    runtime: runtime,
-    class: "$class",
-    objectClass: $objectClass,
-    prototype: runtime.global.ObjectPrototype,
-    extensible: true,
-    property: $propertyMap,
-    $propertyOrder,
-    $value
-} 
-_END_
-}
-
-sub functionProperty {
-    my $self = shift;
-    my $name = shift;
-
-    return $self->property(
-        $name,
-        $self->objectValue(functionLabel($name))
-    );
-}
-
-sub statement {
-    my $self = shift;
-    return join "\n", @_;
-}
-
-sub functionOf {
-    my $self = shift;
-    my $call = shift;
-    my $construct = shift;
-    if ($construct) {
-        $construct = "construct: $construct,";
-    } else {
-        $construct = "";
-    }
-
-    return trim <<_END_
-_functionObject{
-    call: $call,
-    $construct
-}
-_END_
-}
-
-sub nativeFunctionOf {
-    my $self = shift;
-    my $name = shift;
-    my $call = shift;
-    my $construct = shift;
-    if ($construct) {
-        $construct = "construct: $construct,";
-    } else {
-        $construct = "";
-    }
-
-    return trim <<_END_
-_nativeFunctionObject{
-    name: "$name",
-    call: $call,
-    $construct
-}
-_END_
-}
-
-sub nameProperty {
-    my $self = shift;
-    my $name = shift;
-    my $value = shift;
-
-    return trim <<_END_;
-"$name": _property{
-    mode: 0101,
-    value: $value,
-}
-_END_
-}
-
-sub numberValue {
-    my $self = shift;
-    my $value = shift;
-    return trim <<_END_;
-Value{
-    kind: valueNumber,
-    value: $value,
-}
-_END_
-}
-
-sub property {
-    my $self = shift;
-    my $name = shift;
-    my $value = shift;
-    my $mode = shift;
-    $mode = "0101" unless defined $mode;
-    if (! defined $value) {
-        $value = "Value{}";
-    }
-    if (defined $name) {
-        return trim <<_END_;
-"$name": _property{
-    mode: $mode,
-    value: $value,
-}
-_END_
-    } else {
-        return trim <<_END_;
-_property{
-    mode: $mode,
-    value: $value,
-}
-_END_
-    }
-
-}
-
-sub objectProperty {
-    my $self = shift;
-    my $name = shift;
-    my $value = shift;
-
-    return trim <<_END_;
-"$name": _property{
-    mode: 0101,
-    value: @{[ $self->objectValue($value)]},
-}
-_END_
-}
-
-sub objectValue {
-    my $self = shift;
-    my $value = shift;
-    return trim <<_END_
-Value{
-    kind: valueObject,
-    value: $value,
-}
-_END_
-}
-
-sub stringValue {
-    my $self = shift;
-    my $value = shift;
-    return trim <<_END_
-Value{
-    kind: valueString,
-    value: "$value",
-}
-_END_
-}
-
-sub booleanValue {
-    my $self = shift;
-    my $value = shift;
-    return trim <<_END_
-Value{
-    kind: valueBoolean,
-    value: $value,
-}
-_END_
-}
-
-sub undefinedValue {
-    my $self = shift;
-    return trim <<_END_
-Value{
-    kind: valueUndefined,
-}
-_END_
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/inline.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/inline.go
deleted file mode 100644
index 6e5df8393..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/inline.go
+++ /dev/null
@@ -1,6649 +0,0 @@
-package otto
-
-import (
-	"math"
-)
-
-func _newContext(runtime *_runtime) {
-	{
-		runtime.global.ObjectPrototype = &_object{
-			runtime:     runtime,
-			class:       "Object",
-			objectClass: _classObject,
-			prototype:   nil,
-			extensible:  true,
-			value:       prototypeValueObject,
-		}
-	}
-	{
-		runtime.global.FunctionPrototype = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueFunction,
-		}
-	}
-	{
-		valueOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "valueOf",
-				call: builtinObject_valueOf,
-			},
-		}
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinObject_toString,
-			},
-		}
-		toLocaleString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleString",
-				call: builtinObject_toLocaleString,
-			},
-		}
-		hasOwnProperty_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "hasOwnProperty",
-				call: builtinObject_hasOwnProperty,
-			},
-		}
-		isPrototypeOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isPrototypeOf",
-				call: builtinObject_isPrototypeOf,
-			},
-		}
-		propertyIsEnumerable_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "propertyIsEnumerable",
-				call: builtinObject_propertyIsEnumerable,
-			},
-		}
-		runtime.global.ObjectPrototype.property = map[string]_property{
-			"valueOf": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: valueOf_function,
-				},
-			},
-			"toString": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: toString_function,
-				},
-			},
-			"toLocaleString": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: toLocaleString_function,
-				},
-			},
-			"hasOwnProperty": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: hasOwnProperty_function,
-				},
-			},
-			"isPrototypeOf": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: isPrototypeOf_function,
-				},
-			},
-			"propertyIsEnumerable": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: propertyIsEnumerable_function,
-				},
-			},
-			"constructor": _property{
-				mode:  0101,
-				value: Value{},
-			},
-		}
-		runtime.global.ObjectPrototype.propertyOrder = []string{
-			"valueOf",
-			"toString",
-			"toLocaleString",
-			"hasOwnProperty",
-			"isPrototypeOf",
-			"propertyIsEnumerable",
-			"constructor",
-		}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinFunction_toString,
-			},
-		}
-		apply_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "apply",
-				call: builtinFunction_apply,
-			},
-		}
-		call_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "call",
-				call: builtinFunction_call,
-			},
-		}
-		bind_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "bind",
-				call: builtinFunction_bind,
-			},
-		}
-		runtime.global.FunctionPrototype.property = map[string]_property{
-			"toString": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: toString_function,
-				},
-			},
-			"apply": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: apply_function,
-				},
-			},
-			"call": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: call_function,
-				},
-			},
-			"bind": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: bind_function,
-				},
-			},
-			"constructor": _property{
-				mode:  0101,
-				value: Value{},
-			},
-			"length": _property{
-				mode: 0,
-				value: Value{
-					kind:  valueNumber,
-					value: 0,
-				},
-			},
-		}
-		runtime.global.FunctionPrototype.propertyOrder = []string{
-			"toString",
-			"apply",
-			"call",
-			"bind",
-			"constructor",
-			"length",
-		}
-	}
-	{
-		getPrototypeOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getPrototypeOf",
-				call: builtinObject_getPrototypeOf,
-			},
-		}
-		getOwnPropertyDescriptor_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getOwnPropertyDescriptor",
-				call: builtinObject_getOwnPropertyDescriptor,
-			},
-		}
-		defineProperty_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "defineProperty",
-				call: builtinObject_defineProperty,
-			},
-		}
-		defineProperties_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "defineProperties",
-				call: builtinObject_defineProperties,
-			},
-		}
-		create_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "create",
-				call: builtinObject_create,
-			},
-		}
-		isExtensible_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isExtensible",
-				call: builtinObject_isExtensible,
-			},
-		}
-		preventExtensions_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "preventExtensions",
-				call: builtinObject_preventExtensions,
-			},
-		}
-		isSealed_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isSealed",
-				call: builtinObject_isSealed,
-			},
-		}
-		seal_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "seal",
-				call: builtinObject_seal,
-			},
-		}
-		isFrozen_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isFrozen",
-				call: builtinObject_isFrozen,
-			},
-		}
-		freeze_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "freeze",
-				call: builtinObject_freeze,
-			},
-		}
-		keys_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "keys",
-				call: builtinObject_keys,
-			},
-		}
-		getOwnPropertyNames_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getOwnPropertyNames",
-				call: builtinObject_getOwnPropertyNames,
-			},
-		}
-		runtime.global.Object = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Object",
-				call:      builtinObject,
-				construct: builtinNewObject,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.ObjectPrototype,
-					},
-				},
-				"getPrototypeOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getPrototypeOf_function,
-					},
-				},
-				"getOwnPropertyDescriptor": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getOwnPropertyDescriptor_function,
-					},
-				},
-				"defineProperty": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: defineProperty_function,
-					},
-				},
-				"defineProperties": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: defineProperties_function,
-					},
-				},
-				"create": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: create_function,
-					},
-				},
-				"isExtensible": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: isExtensible_function,
-					},
-				},
-				"preventExtensions": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: preventExtensions_function,
-					},
-				},
-				"isSealed": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: isSealed_function,
-					},
-				},
-				"seal": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: seal_function,
-					},
-				},
-				"isFrozen": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: isFrozen_function,
-					},
-				},
-				"freeze": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: freeze_function,
-					},
-				},
-				"keys": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: keys_function,
-					},
-				},
-				"getOwnPropertyNames": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getOwnPropertyNames_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-				"getPrototypeOf",
-				"getOwnPropertyDescriptor",
-				"defineProperty",
-				"defineProperties",
-				"create",
-				"isExtensible",
-				"preventExtensions",
-				"isSealed",
-				"seal",
-				"isFrozen",
-				"freeze",
-				"keys",
-				"getOwnPropertyNames",
-			},
-		}
-		runtime.global.ObjectPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Object,
-				},
-			}
-	}
-	{
-		Function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Function",
-				call:      builtinFunction,
-				construct: builtinNewFunction,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.FunctionPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.Function = Function
-		runtime.global.FunctionPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Function,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinArray_toString,
-			},
-		}
-		toLocaleString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleString",
-				call: builtinArray_toLocaleString,
-			},
-		}
-		concat_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "concat",
-				call: builtinArray_concat,
-			},
-		}
-		join_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "join",
-				call: builtinArray_join,
-			},
-		}
-		splice_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "splice",
-				call: builtinArray_splice,
-			},
-		}
-		shift_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "shift",
-				call: builtinArray_shift,
-			},
-		}
-		pop_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "pop",
-				call: builtinArray_pop,
-			},
-		}
-		push_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "push",
-				call: builtinArray_push,
-			},
-		}
-		slice_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "slice",
-				call: builtinArray_slice,
-			},
-		}
-		unshift_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "unshift",
-				call: builtinArray_unshift,
-			},
-		}
-		reverse_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "reverse",
-				call: builtinArray_reverse,
-			},
-		}
-		sort_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "sort",
-				call: builtinArray_sort,
-			},
-		}
-		indexOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "indexOf",
-				call: builtinArray_indexOf,
-			},
-		}
-		lastIndexOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "lastIndexOf",
-				call: builtinArray_lastIndexOf,
-			},
-		}
-		every_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "every",
-				call: builtinArray_every,
-			},
-		}
-		some_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "some",
-				call: builtinArray_some,
-			},
-		}
-		forEach_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "forEach",
-				call: builtinArray_forEach,
-			},
-		}
-		map_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "map",
-				call: builtinArray_map,
-			},
-		}
-		filter_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "filter",
-				call: builtinArray_filter,
-			},
-		}
-		reduce_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "reduce",
-				call: builtinArray_reduce,
-			},
-		}
-		reduceRight_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "reduceRight",
-				call: builtinArray_reduceRight,
-			},
-		}
-		isArray_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isArray",
-				call: builtinArray_isArray,
-			},
-		}
-		runtime.global.ArrayPrototype = &_object{
-			runtime:     runtime,
-			class:       "Array",
-			objectClass: _classArray,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0100,
-					value: Value{
-						kind:  valueNumber,
-						value: uint32(0),
-					},
-				},
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"toLocaleString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleString_function,
-					},
-				},
-				"concat": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: concat_function,
-					},
-				},
-				"join": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: join_function,
-					},
-				},
-				"splice": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: splice_function,
-					},
-				},
-				"shift": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: shift_function,
-					},
-				},
-				"pop": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: pop_function,
-					},
-				},
-				"push": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: push_function,
-					},
-				},
-				"slice": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: slice_function,
-					},
-				},
-				"unshift": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: unshift_function,
-					},
-				},
-				"reverse": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: reverse_function,
-					},
-				},
-				"sort": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: sort_function,
-					},
-				},
-				"indexOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: indexOf_function,
-					},
-				},
-				"lastIndexOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: lastIndexOf_function,
-					},
-				},
-				"every": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: every_function,
-					},
-				},
-				"some": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: some_function,
-					},
-				},
-				"forEach": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: forEach_function,
-					},
-				},
-				"map": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: map_function,
-					},
-				},
-				"filter": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: filter_function,
-					},
-				},
-				"reduce": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: reduce_function,
-					},
-				},
-				"reduceRight": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: reduceRight_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"toString",
-				"toLocaleString",
-				"concat",
-				"join",
-				"splice",
-				"shift",
-				"pop",
-				"push",
-				"slice",
-				"unshift",
-				"reverse",
-				"sort",
-				"indexOf",
-				"lastIndexOf",
-				"every",
-				"some",
-				"forEach",
-				"map",
-				"filter",
-				"reduce",
-				"reduceRight",
-			},
-		}
-		runtime.global.Array = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Array",
-				call:      builtinArray,
-				construct: builtinNewArray,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.ArrayPrototype,
-					},
-				},
-				"isArray": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: isArray_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-				"isArray",
-			},
-		}
-		runtime.global.ArrayPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Array,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinString_toString,
-			},
-		}
-		valueOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "valueOf",
-				call: builtinString_valueOf,
-			},
-		}
-		charAt_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "charAt",
-				call: builtinString_charAt,
-			},
-		}
-		charCodeAt_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "charCodeAt",
-				call: builtinString_charCodeAt,
-			},
-		}
-		concat_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "concat",
-				call: builtinString_concat,
-			},
-		}
-		indexOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "indexOf",
-				call: builtinString_indexOf,
-			},
-		}
-		lastIndexOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "lastIndexOf",
-				call: builtinString_lastIndexOf,
-			},
-		}
-		match_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "match",
-				call: builtinString_match,
-			},
-		}
-		replace_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "replace",
-				call: builtinString_replace,
-			},
-		}
-		search_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "search",
-				call: builtinString_search,
-			},
-		}
-		split_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "split",
-				call: builtinString_split,
-			},
-		}
-		slice_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "slice",
-				call: builtinString_slice,
-			},
-		}
-		substring_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "substring",
-				call: builtinString_substring,
-			},
-		}
-		toLowerCase_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLowerCase",
-				call: builtinString_toLowerCase,
-			},
-		}
-		toUpperCase_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toUpperCase",
-				call: builtinString_toUpperCase,
-			},
-		}
-		substr_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "substr",
-				call: builtinString_substr,
-			},
-		}
-		trim_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "trim",
-				call: builtinString_trim,
-			},
-		}
-		trimLeft_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "trimLeft",
-				call: builtinString_trimLeft,
-			},
-		}
-		trimRight_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "trimRight",
-				call: builtinString_trimRight,
-			},
-		}
-		localeCompare_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "localeCompare",
-				call: builtinString_localeCompare,
-			},
-		}
-		toLocaleLowerCase_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleLowerCase",
-				call: builtinString_toLocaleLowerCase,
-			},
-		}
-		toLocaleUpperCase_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleUpperCase",
-				call: builtinString_toLocaleUpperCase,
-			},
-		}
-		fromCharCode_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "fromCharCode",
-				call: builtinString_fromCharCode,
-			},
-		}
-		runtime.global.StringPrototype = &_object{
-			runtime:     runtime,
-			class:       "String",
-			objectClass: _classString,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueString,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: int(0),
-					},
-				},
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"valueOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: valueOf_function,
-					},
-				},
-				"charAt": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: charAt_function,
-					},
-				},
-				"charCodeAt": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: charCodeAt_function,
-					},
-				},
-				"concat": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: concat_function,
-					},
-				},
-				"indexOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: indexOf_function,
-					},
-				},
-				"lastIndexOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: lastIndexOf_function,
-					},
-				},
-				"match": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: match_function,
-					},
-				},
-				"replace": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: replace_function,
-					},
-				},
-				"search": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: search_function,
-					},
-				},
-				"split": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: split_function,
-					},
-				},
-				"slice": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: slice_function,
-					},
-				},
-				"substring": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: substring_function,
-					},
-				},
-				"toLowerCase": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLowerCase_function,
-					},
-				},
-				"toUpperCase": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toUpperCase_function,
-					},
-				},
-				"substr": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: substr_function,
-					},
-				},
-				"trim": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: trim_function,
-					},
-				},
-				"trimLeft": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: trimLeft_function,
-					},
-				},
-				"trimRight": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: trimRight_function,
-					},
-				},
-				"localeCompare": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: localeCompare_function,
-					},
-				},
-				"toLocaleLowerCase": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleLowerCase_function,
-					},
-				},
-				"toLocaleUpperCase": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleUpperCase_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"toString",
-				"valueOf",
-				"charAt",
-				"charCodeAt",
-				"concat",
-				"indexOf",
-				"lastIndexOf",
-				"match",
-				"replace",
-				"search",
-				"split",
-				"slice",
-				"substring",
-				"toLowerCase",
-				"toUpperCase",
-				"substr",
-				"trim",
-				"trimLeft",
-				"trimRight",
-				"localeCompare",
-				"toLocaleLowerCase",
-				"toLocaleUpperCase",
-			},
-		}
-		runtime.global.String = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "String",
-				call:      builtinString,
-				construct: builtinNewString,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.StringPrototype,
-					},
-				},
-				"fromCharCode": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: fromCharCode_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-				"fromCharCode",
-			},
-		}
-		runtime.global.StringPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.String,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinBoolean_toString,
-			},
-		}
-		valueOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "valueOf",
-				call: builtinBoolean_valueOf,
-			},
-		}
-		runtime.global.BooleanPrototype = &_object{
-			runtime:     runtime,
-			class:       "Boolean",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueBoolean,
-			property: map[string]_property{
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"valueOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: valueOf_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"toString",
-				"valueOf",
-			},
-		}
-		runtime.global.Boolean = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Boolean",
-				call:      builtinBoolean,
-				construct: builtinNewBoolean,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.BooleanPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.BooleanPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Boolean,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinNumber_toString,
-			},
-		}
-		valueOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "valueOf",
-				call: builtinNumber_valueOf,
-			},
-		}
-		toFixed_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toFixed",
-				call: builtinNumber_toFixed,
-			},
-		}
-		toExponential_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toExponential",
-				call: builtinNumber_toExponential,
-			},
-		}
-		toPrecision_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toPrecision",
-				call: builtinNumber_toPrecision,
-			},
-		}
-		toLocaleString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleString",
-				call: builtinNumber_toLocaleString,
-			},
-		}
-		runtime.global.NumberPrototype = &_object{
-			runtime:     runtime,
-			class:       "Number",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueNumber,
-			property: map[string]_property{
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"valueOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: valueOf_function,
-					},
-				},
-				"toFixed": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toFixed_function,
-					},
-				},
-				"toExponential": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toExponential_function,
-					},
-				},
-				"toPrecision": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toPrecision_function,
-					},
-				},
-				"toLocaleString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleString_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"toString",
-				"valueOf",
-				"toFixed",
-				"toExponential",
-				"toPrecision",
-				"toLocaleString",
-			},
-		}
-		runtime.global.Number = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Number",
-				call:      builtinNumber,
-				construct: builtinNewNumber,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.NumberPrototype,
-					},
-				},
-				"MAX_VALUE": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.MaxFloat64,
-					},
-				},
-				"MIN_VALUE": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.SmallestNonzeroFloat64,
-					},
-				},
-				"NaN": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.NaN(),
-					},
-				},
-				"NEGATIVE_INFINITY": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Inf(-1),
-					},
-				},
-				"POSITIVE_INFINITY": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Inf(+1),
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-				"MAX_VALUE",
-				"MIN_VALUE",
-				"NaN",
-				"NEGATIVE_INFINITY",
-				"POSITIVE_INFINITY",
-			},
-		}
-		runtime.global.NumberPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Number,
-				},
-			}
-	}
-	{
-		abs_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "abs",
-				call: builtinMath_abs,
-			},
-		}
-		acos_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "acos",
-				call: builtinMath_acos,
-			},
-		}
-		asin_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "asin",
-				call: builtinMath_asin,
-			},
-		}
-		atan_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "atan",
-				call: builtinMath_atan,
-			},
-		}
-		atan2_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "atan2",
-				call: builtinMath_atan2,
-			},
-		}
-		ceil_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "ceil",
-				call: builtinMath_ceil,
-			},
-		}
-		cos_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "cos",
-				call: builtinMath_cos,
-			},
-		}
-		exp_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "exp",
-				call: builtinMath_exp,
-			},
-		}
-		floor_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "floor",
-				call: builtinMath_floor,
-			},
-		}
-		log_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "log",
-				call: builtinMath_log,
-			},
-		}
-		max_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "max",
-				call: builtinMath_max,
-			},
-		}
-		min_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "min",
-				call: builtinMath_min,
-			},
-		}
-		pow_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "pow",
-				call: builtinMath_pow,
-			},
-		}
-		random_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "random",
-				call: builtinMath_random,
-			},
-		}
-		round_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "round",
-				call: builtinMath_round,
-			},
-		}
-		sin_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "sin",
-				call: builtinMath_sin,
-			},
-		}
-		sqrt_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "sqrt",
-				call: builtinMath_sqrt,
-			},
-		}
-		tan_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "tan",
-				call: builtinMath_tan,
-			},
-		}
-		runtime.global.Math = &_object{
-			runtime:     runtime,
-			class:       "Math",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"abs": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: abs_function,
-					},
-				},
-				"acos": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: acos_function,
-					},
-				},
-				"asin": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: asin_function,
-					},
-				},
-				"atan": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: atan_function,
-					},
-				},
-				"atan2": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: atan2_function,
-					},
-				},
-				"ceil": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: ceil_function,
-					},
-				},
-				"cos": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: cos_function,
-					},
-				},
-				"exp": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: exp_function,
-					},
-				},
-				"floor": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: floor_function,
-					},
-				},
-				"log": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: log_function,
-					},
-				},
-				"max": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: max_function,
-					},
-				},
-				"min": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: min_function,
-					},
-				},
-				"pow": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: pow_function,
-					},
-				},
-				"random": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: random_function,
-					},
-				},
-				"round": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: round_function,
-					},
-				},
-				"sin": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: sin_function,
-					},
-				},
-				"sqrt": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: sqrt_function,
-					},
-				},
-				"tan": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: tan_function,
-					},
-				},
-				"E": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.E,
-					},
-				},
-				"LN10": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Ln10,
-					},
-				},
-				"LN2": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Ln2,
-					},
-				},
-				"LOG2E": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Log2E,
-					},
-				},
-				"LOG10E": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Log10E,
-					},
-				},
-				"PI": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Pi,
-					},
-				},
-				"SQRT1_2": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: sqrt1_2,
-					},
-				},
-				"SQRT2": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: math.Sqrt2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"abs",
-				"acos",
-				"asin",
-				"atan",
-				"atan2",
-				"ceil",
-				"cos",
-				"exp",
-				"floor",
-				"log",
-				"max",
-				"min",
-				"pow",
-				"random",
-				"round",
-				"sin",
-				"sqrt",
-				"tan",
-				"E",
-				"LN10",
-				"LN2",
-				"LOG2E",
-				"LOG10E",
-				"PI",
-				"SQRT1_2",
-				"SQRT2",
-			},
-		}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinDate_toString,
-			},
-		}
-		toDateString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toDateString",
-				call: builtinDate_toDateString,
-			},
-		}
-		toTimeString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toTimeString",
-				call: builtinDate_toTimeString,
-			},
-		}
-		toUTCString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toUTCString",
-				call: builtinDate_toUTCString,
-			},
-		}
-		toISOString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toISOString",
-				call: builtinDate_toISOString,
-			},
-		}
-		toJSON_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toJSON",
-				call: builtinDate_toJSON,
-			},
-		}
-		toGMTString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toGMTString",
-				call: builtinDate_toGMTString,
-			},
-		}
-		toLocaleString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleString",
-				call: builtinDate_toLocaleString,
-			},
-		}
-		toLocaleDateString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleDateString",
-				call: builtinDate_toLocaleDateString,
-			},
-		}
-		toLocaleTimeString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toLocaleTimeString",
-				call: builtinDate_toLocaleTimeString,
-			},
-		}
-		valueOf_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "valueOf",
-				call: builtinDate_valueOf,
-			},
-		}
-		getTime_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getTime",
-				call: builtinDate_getTime,
-			},
-		}
-		getYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getYear",
-				call: builtinDate_getYear,
-			},
-		}
-		getFullYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getFullYear",
-				call: builtinDate_getFullYear,
-			},
-		}
-		getUTCFullYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCFullYear",
-				call: builtinDate_getUTCFullYear,
-			},
-		}
-		getMonth_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getMonth",
-				call: builtinDate_getMonth,
-			},
-		}
-		getUTCMonth_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCMonth",
-				call: builtinDate_getUTCMonth,
-			},
-		}
-		getDate_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getDate",
-				call: builtinDate_getDate,
-			},
-		}
-		getUTCDate_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCDate",
-				call: builtinDate_getUTCDate,
-			},
-		}
-		getDay_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getDay",
-				call: builtinDate_getDay,
-			},
-		}
-		getUTCDay_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCDay",
-				call: builtinDate_getUTCDay,
-			},
-		}
-		getHours_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getHours",
-				call: builtinDate_getHours,
-			},
-		}
-		getUTCHours_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCHours",
-				call: builtinDate_getUTCHours,
-			},
-		}
-		getMinutes_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getMinutes",
-				call: builtinDate_getMinutes,
-			},
-		}
-		getUTCMinutes_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCMinutes",
-				call: builtinDate_getUTCMinutes,
-			},
-		}
-		getSeconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getSeconds",
-				call: builtinDate_getSeconds,
-			},
-		}
-		getUTCSeconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCSeconds",
-				call: builtinDate_getUTCSeconds,
-			},
-		}
-		getMilliseconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getMilliseconds",
-				call: builtinDate_getMilliseconds,
-			},
-		}
-		getUTCMilliseconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getUTCMilliseconds",
-				call: builtinDate_getUTCMilliseconds,
-			},
-		}
-		getTimezoneOffset_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "getTimezoneOffset",
-				call: builtinDate_getTimezoneOffset,
-			},
-		}
-		setTime_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setTime",
-				call: builtinDate_setTime,
-			},
-		}
-		setMilliseconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setMilliseconds",
-				call: builtinDate_setMilliseconds,
-			},
-		}
-		setUTCMilliseconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCMilliseconds",
-				call: builtinDate_setUTCMilliseconds,
-			},
-		}
-		setSeconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setSeconds",
-				call: builtinDate_setSeconds,
-			},
-		}
-		setUTCSeconds_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCSeconds",
-				call: builtinDate_setUTCSeconds,
-			},
-		}
-		setMinutes_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setMinutes",
-				call: builtinDate_setMinutes,
-			},
-		}
-		setUTCMinutes_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCMinutes",
-				call: builtinDate_setUTCMinutes,
-			},
-		}
-		setHours_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 4,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setHours",
-				call: builtinDate_setHours,
-			},
-		}
-		setUTCHours_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 4,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCHours",
-				call: builtinDate_setUTCHours,
-			},
-		}
-		setDate_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setDate",
-				call: builtinDate_setDate,
-			},
-		}
-		setUTCDate_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCDate",
-				call: builtinDate_setUTCDate,
-			},
-		}
-		setMonth_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setMonth",
-				call: builtinDate_setMonth,
-			},
-		}
-		setUTCMonth_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCMonth",
-				call: builtinDate_setUTCMonth,
-			},
-		}
-		setYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setYear",
-				call: builtinDate_setYear,
-			},
-		}
-		setFullYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setFullYear",
-				call: builtinDate_setFullYear,
-			},
-		}
-		setUTCFullYear_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "setUTCFullYear",
-				call: builtinDate_setUTCFullYear,
-			},
-		}
-		parse_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "parse",
-				call: builtinDate_parse,
-			},
-		}
-		UTC_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 7,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "UTC",
-				call: builtinDate_UTC,
-			},
-		}
-		now_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "now",
-				call: builtinDate_now,
-			},
-		}
-		runtime.global.DatePrototype = &_object{
-			runtime:     runtime,
-			class:       "Date",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueDate,
-			property: map[string]_property{
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"toDateString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toDateString_function,
-					},
-				},
-				"toTimeString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toTimeString_function,
-					},
-				},
-				"toUTCString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toUTCString_function,
-					},
-				},
-				"toISOString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toISOString_function,
-					},
-				},
-				"toJSON": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toJSON_function,
-					},
-				},
-				"toGMTString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toGMTString_function,
-					},
-				},
-				"toLocaleString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleString_function,
-					},
-				},
-				"toLocaleDateString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleDateString_function,
-					},
-				},
-				"toLocaleTimeString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toLocaleTimeString_function,
-					},
-				},
-				"valueOf": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: valueOf_function,
-					},
-				},
-				"getTime": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getTime_function,
-					},
-				},
-				"getYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getYear_function,
-					},
-				},
-				"getFullYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getFullYear_function,
-					},
-				},
-				"getUTCFullYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCFullYear_function,
-					},
-				},
-				"getMonth": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getMonth_function,
-					},
-				},
-				"getUTCMonth": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCMonth_function,
-					},
-				},
-				"getDate": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getDate_function,
-					},
-				},
-				"getUTCDate": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCDate_function,
-					},
-				},
-				"getDay": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getDay_function,
-					},
-				},
-				"getUTCDay": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCDay_function,
-					},
-				},
-				"getHours": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getHours_function,
-					},
-				},
-				"getUTCHours": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCHours_function,
-					},
-				},
-				"getMinutes": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getMinutes_function,
-					},
-				},
-				"getUTCMinutes": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCMinutes_function,
-					},
-				},
-				"getSeconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getSeconds_function,
-					},
-				},
-				"getUTCSeconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCSeconds_function,
-					},
-				},
-				"getMilliseconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getMilliseconds_function,
-					},
-				},
-				"getUTCMilliseconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getUTCMilliseconds_function,
-					},
-				},
-				"getTimezoneOffset": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: getTimezoneOffset_function,
-					},
-				},
-				"setTime": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setTime_function,
-					},
-				},
-				"setMilliseconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setMilliseconds_function,
-					},
-				},
-				"setUTCMilliseconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCMilliseconds_function,
-					},
-				},
-				"setSeconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setSeconds_function,
-					},
-				},
-				"setUTCSeconds": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCSeconds_function,
-					},
-				},
-				"setMinutes": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setMinutes_function,
-					},
-				},
-				"setUTCMinutes": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCMinutes_function,
-					},
-				},
-				"setHours": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setHours_function,
-					},
-				},
-				"setUTCHours": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCHours_function,
-					},
-				},
-				"setDate": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setDate_function,
-					},
-				},
-				"setUTCDate": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCDate_function,
-					},
-				},
-				"setMonth": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setMonth_function,
-					},
-				},
-				"setUTCMonth": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCMonth_function,
-					},
-				},
-				"setYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setYear_function,
-					},
-				},
-				"setFullYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setFullYear_function,
-					},
-				},
-				"setUTCFullYear": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: setUTCFullYear_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"toString",
-				"toDateString",
-				"toTimeString",
-				"toUTCString",
-				"toISOString",
-				"toJSON",
-				"toGMTString",
-				"toLocaleString",
-				"toLocaleDateString",
-				"toLocaleTimeString",
-				"valueOf",
-				"getTime",
-				"getYear",
-				"getFullYear",
-				"getUTCFullYear",
-				"getMonth",
-				"getUTCMonth",
-				"getDate",
-				"getUTCDate",
-				"getDay",
-				"getUTCDay",
-				"getHours",
-				"getUTCHours",
-				"getMinutes",
-				"getUTCMinutes",
-				"getSeconds",
-				"getUTCSeconds",
-				"getMilliseconds",
-				"getUTCMilliseconds",
-				"getTimezoneOffset",
-				"setTime",
-				"setMilliseconds",
-				"setUTCMilliseconds",
-				"setSeconds",
-				"setUTCSeconds",
-				"setMinutes",
-				"setUTCMinutes",
-				"setHours",
-				"setUTCHours",
-				"setDate",
-				"setUTCDate",
-				"setMonth",
-				"setUTCMonth",
-				"setYear",
-				"setFullYear",
-				"setUTCFullYear",
-			},
-		}
-		runtime.global.Date = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Date",
-				call:      builtinDate,
-				construct: builtinNewDate,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 7,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.DatePrototype,
-					},
-				},
-				"parse": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: parse_function,
-					},
-				},
-				"UTC": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: UTC_function,
-					},
-				},
-				"now": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: now_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-				"parse",
-				"UTC",
-				"now",
-			},
-		}
-		runtime.global.DatePrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Date,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinRegExp_toString,
-			},
-		}
-		exec_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "exec",
-				call: builtinRegExp_exec,
-			},
-		}
-		test_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "test",
-				call: builtinRegExp_test,
-			},
-		}
-		compile_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "compile",
-				call: builtinRegExp_compile,
-			},
-		}
-		runtime.global.RegExpPrototype = &_object{
-			runtime:     runtime,
-			class:       "RegExp",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       prototypeValueRegExp,
-			property: map[string]_property{
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"exec": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: exec_function,
-					},
-				},
-				"test": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: test_function,
-					},
-				},
-				"compile": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: compile_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"toString",
-				"exec",
-				"test",
-				"compile",
-			},
-		}
-		runtime.global.RegExp = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "RegExp",
-				call:      builtinRegExp,
-				construct: builtinNewRegExp,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.RegExpPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.RegExpPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.RegExp,
-				},
-			}
-	}
-	{
-		toString_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "toString",
-				call: builtinError_toString,
-			},
-		}
-		runtime.global.ErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "Error",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"toString": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: toString_function,
-					},
-				},
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "Error",
-					},
-				},
-				"message": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"toString",
-				"name",
-				"message",
-			},
-		}
-		runtime.global.Error = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "Error",
-				call:      builtinError,
-				construct: builtinNewError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.ErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.ErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Error,
-				},
-			}
-	}
-	{
-		runtime.global.EvalErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "EvalError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "EvalError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.EvalError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "EvalError",
-				call:      builtinEvalError,
-				construct: builtinNewEvalError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.EvalErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.EvalErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.EvalError,
-				},
-			}
-	}
-	{
-		runtime.global.TypeErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "TypeError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "TypeError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.TypeError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "TypeError",
-				call:      builtinTypeError,
-				construct: builtinNewTypeError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.TypeErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.TypeErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.TypeError,
-				},
-			}
-	}
-	{
-		runtime.global.RangeErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "RangeError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "RangeError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.RangeError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "RangeError",
-				call:      builtinRangeError,
-				construct: builtinNewRangeError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.RangeErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.RangeErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.RangeError,
-				},
-			}
-	}
-	{
-		runtime.global.ReferenceErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "ReferenceError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "ReferenceError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.ReferenceError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "ReferenceError",
-				call:      builtinReferenceError,
-				construct: builtinNewReferenceError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.ReferenceErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.ReferenceErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.ReferenceError,
-				},
-			}
-	}
-	{
-		runtime.global.SyntaxErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "SyntaxError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "SyntaxError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.SyntaxError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "SyntaxError",
-				call:      builtinSyntaxError,
-				construct: builtinNewSyntaxError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.SyntaxErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.SyntaxErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.SyntaxError,
-				},
-			}
-	}
-	{
-		runtime.global.URIErrorPrototype = &_object{
-			runtime:     runtime,
-			class:       "URIError",
-			objectClass: _classObject,
-			prototype:   runtime.global.ErrorPrototype,
-			extensible:  true,
-			value:       nil,
-			property: map[string]_property{
-				"name": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueString,
-						value: "URIError",
-					},
-				},
-			},
-			propertyOrder: []string{
-				"name",
-			},
-		}
-		runtime.global.URIError = &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			value: _nativeFunctionObject{
-				name:      "URIError",
-				call:      builtinURIError,
-				construct: builtinNewURIError,
-			},
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-				"prototype": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueObject,
-						value: runtime.global.URIErrorPrototype,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-				"prototype",
-			},
-		}
-		runtime.global.URIErrorPrototype.property["constructor"] =
-			_property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.URIError,
-				},
-			}
-	}
-	{
-		parse_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "parse",
-				call: builtinJSON_parse,
-			},
-		}
-		stringify_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 3,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "stringify",
-				call: builtinJSON_stringify,
-			},
-		}
-		runtime.global.JSON = &_object{
-			runtime:     runtime,
-			class:       "JSON",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"parse": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: parse_function,
-					},
-				},
-				"stringify": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: stringify_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"parse",
-				"stringify",
-			},
-		}
-	}
-	{
-		eval_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "eval",
-				call: builtinGlobal_eval,
-			},
-		}
-		parseInt_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 2,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "parseInt",
-				call: builtinGlobal_parseInt,
-			},
-		}
-		parseFloat_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "parseFloat",
-				call: builtinGlobal_parseFloat,
-			},
-		}
-		isNaN_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isNaN",
-				call: builtinGlobal_isNaN,
-			},
-		}
-		isFinite_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "isFinite",
-				call: builtinGlobal_isFinite,
-			},
-		}
-		decodeURI_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "decodeURI",
-				call: builtinGlobal_decodeURI,
-			},
-		}
-		decodeURIComponent_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "decodeURIComponent",
-				call: builtinGlobal_decodeURIComponent,
-			},
-		}
-		encodeURI_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "encodeURI",
-				call: builtinGlobal_encodeURI,
-			},
-		}
-		encodeURIComponent_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "encodeURIComponent",
-				call: builtinGlobal_encodeURIComponent,
-			},
-		}
-		escape_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "escape",
-				call: builtinGlobal_escape,
-			},
-		}
-		unescape_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 1,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "unescape",
-				call: builtinGlobal_unescape,
-			},
-		}
-		runtime.globalObject.property = map[string]_property{
-			"eval": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: eval_function,
-				},
-			},
-			"parseInt": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: parseInt_function,
-				},
-			},
-			"parseFloat": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: parseFloat_function,
-				},
-			},
-			"isNaN": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: isNaN_function,
-				},
-			},
-			"isFinite": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: isFinite_function,
-				},
-			},
-			"decodeURI": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: decodeURI_function,
-				},
-			},
-			"decodeURIComponent": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: decodeURIComponent_function,
-				},
-			},
-			"encodeURI": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: encodeURI_function,
-				},
-			},
-			"encodeURIComponent": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: encodeURIComponent_function,
-				},
-			},
-			"escape": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: escape_function,
-				},
-			},
-			"unescape": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: unescape_function,
-				},
-			},
-			"Object": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Object,
-				},
-			},
-			"Function": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Function,
-				},
-			},
-			"Array": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Array,
-				},
-			},
-			"String": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.String,
-				},
-			},
-			"Boolean": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Boolean,
-				},
-			},
-			"Number": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Number,
-				},
-			},
-			"Math": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Math,
-				},
-			},
-			"Date": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Date,
-				},
-			},
-			"RegExp": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.RegExp,
-				},
-			},
-			"Error": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.Error,
-				},
-			},
-			"EvalError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.EvalError,
-				},
-			},
-			"TypeError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.TypeError,
-				},
-			},
-			"RangeError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.RangeError,
-				},
-			},
-			"ReferenceError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.ReferenceError,
-				},
-			},
-			"SyntaxError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.SyntaxError,
-				},
-			},
-			"URIError": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.URIError,
-				},
-			},
-			"JSON": _property{
-				mode: 0101,
-				value: Value{
-					kind:  valueObject,
-					value: runtime.global.JSON,
-				},
-			},
-			"undefined": _property{
-				mode: 0,
-				value: Value{
-					kind: valueUndefined,
-				},
-			},
-			"NaN": _property{
-				mode: 0,
-				value: Value{
-					kind:  valueNumber,
-					value: math.NaN(),
-				},
-			},
-			"Infinity": _property{
-				mode: 0,
-				value: Value{
-					kind:  valueNumber,
-					value: math.Inf(+1),
-				},
-			},
-		}
-		runtime.globalObject.propertyOrder = []string{
-			"eval",
-			"parseInt",
-			"parseFloat",
-			"isNaN",
-			"isFinite",
-			"decodeURI",
-			"decodeURIComponent",
-			"encodeURI",
-			"encodeURIComponent",
-			"escape",
-			"unescape",
-			"Object",
-			"Function",
-			"Array",
-			"String",
-			"Boolean",
-			"Number",
-			"Math",
-			"Date",
-			"RegExp",
-			"Error",
-			"EvalError",
-			"TypeError",
-			"RangeError",
-			"ReferenceError",
-			"SyntaxError",
-			"URIError",
-			"JSON",
-			"undefined",
-			"NaN",
-			"Infinity",
-		}
-	}
-}
-
-func newConsoleObject(runtime *_runtime) *_object {
-	{
-		log_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "log",
-				call: builtinConsole_log,
-			},
-		}
-		debug_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "debug",
-				call: builtinConsole_log,
-			},
-		}
-		info_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "info",
-				call: builtinConsole_log,
-			},
-		}
-		error_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "error",
-				call: builtinConsole_error,
-			},
-		}
-		warn_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "warn",
-				call: builtinConsole_error,
-			},
-		}
-		dir_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "dir",
-				call: builtinConsole_dir,
-			},
-		}
-		time_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "time",
-				call: builtinConsole_time,
-			},
-		}
-		timeEnd_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "timeEnd",
-				call: builtinConsole_timeEnd,
-			},
-		}
-		trace_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "trace",
-				call: builtinConsole_trace,
-			},
-		}
-		assert_function := &_object{
-			runtime:     runtime,
-			class:       "Function",
-			objectClass: _classObject,
-			prototype:   runtime.global.FunctionPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"length": _property{
-					mode: 0,
-					value: Value{
-						kind:  valueNumber,
-						value: 0,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"length",
-			},
-			value: _nativeFunctionObject{
-				name: "assert",
-				call: builtinConsole_assert,
-			},
-		}
-		return &_object{
-			runtime:     runtime,
-			class:       "Object",
-			objectClass: _classObject,
-			prototype:   runtime.global.ObjectPrototype,
-			extensible:  true,
-			property: map[string]_property{
-				"log": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: log_function,
-					},
-				},
-				"debug": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: debug_function,
-					},
-				},
-				"info": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: info_function,
-					},
-				},
-				"error": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: error_function,
-					},
-				},
-				"warn": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: warn_function,
-					},
-				},
-				"dir": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: dir_function,
-					},
-				},
-				"time": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: time_function,
-					},
-				},
-				"timeEnd": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: timeEnd_function,
-					},
-				},
-				"trace": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: trace_function,
-					},
-				},
-				"assert": _property{
-					mode: 0101,
-					value: Value{
-						kind:  valueObject,
-						value: assert_function,
-					},
-				},
-			},
-			propertyOrder: []string{
-				"log",
-				"debug",
-				"info",
-				"error",
-				"warn",
-				"dir",
-				"time",
-				"timeEnd",
-				"trace",
-				"assert",
-			},
-		}
-	}
-}
-
-func toValue_int(value int) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_int8(value int8) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_int16(value int16) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_int32(value int32) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_int64(value int64) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_uint(value uint) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_uint8(value uint8) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_uint16(value uint16) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_uint32(value uint32) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_uint64(value uint64) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_float32(value float32) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_float64(value float64) Value {
-	return Value{
-		kind:  valueNumber,
-		value: value,
-	}
-}
-
-func toValue_string(value string) Value {
-	return Value{
-		kind:  valueString,
-		value: value,
-	}
-}
-
-func toValue_string16(value []uint16) Value {
-	return Value{
-		kind:  valueString,
-		value: value,
-	}
-}
-
-func toValue_bool(value bool) Value {
-	return Value{
-		kind:  valueBoolean,
-		value: value,
-	}
-}
-
-func toValue_object(value *_object) Value {
-	return Value{
-		kind:  valueObject,
-		value: value,
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/object.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/object.go
deleted file mode 100644
index 849812c91..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/object.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package otto
-
-type _object struct {
-	runtime *_runtime
-
-	class       string
-	objectClass *_objectClass
-	value       interface{}
-
-	prototype  *_object
-	extensible bool
-
-	property      map[string]_property
-	propertyOrder []string
-}
-
-func newObject(runtime *_runtime, class string) *_object {
-	self := &_object{
-		runtime:     runtime,
-		class:       class,
-		objectClass: _classObject,
-		property:    make(map[string]_property),
-		extensible:  true,
-	}
-	return self
-}
-
-// 8.12
-
-// 8.12.1
-func (self *_object) getOwnProperty(name string) *_property {
-	return self.objectClass.getOwnProperty(self, name)
-}
-
-// 8.12.2
-func (self *_object) getProperty(name string) *_property {
-	return self.objectClass.getProperty(self, name)
-}
-
-// 8.12.3
-func (self *_object) get(name string) Value {
-	return self.objectClass.get(self, name)
-}
-
-// 8.12.4
-func (self *_object) canPut(name string) bool {
-	return self.objectClass.canPut(self, name)
-}
-
-// 8.12.5
-func (self *_object) put(name string, value Value, throw bool) {
-	self.objectClass.put(self, name, value, throw)
-}
-
-// 8.12.6
-func (self *_object) hasProperty(name string) bool {
-	return self.objectClass.hasProperty(self, name)
-}
-
-func (self *_object) hasOwnProperty(name string) bool {
-	return self.objectClass.hasOwnProperty(self, name)
-}
-
-type _defaultValueHint int
-
-const (
-	defaultValueNoHint _defaultValueHint = iota
-	defaultValueHintString
-	defaultValueHintNumber
-)
-
-// 8.12.8
-func (self *_object) DefaultValue(hint _defaultValueHint) Value {
-	if hint == defaultValueNoHint {
-		if self.class == "Date" {
-			// Date exception
-			hint = defaultValueHintString
-		} else {
-			hint = defaultValueHintNumber
-		}
-	}
-	methodSequence := []string{"valueOf", "toString"}
-	if hint == defaultValueHintString {
-		methodSequence = []string{"toString", "valueOf"}
-	}
-	for _, methodName := range methodSequence {
-		method := self.get(methodName)
-		// FIXME This is redundant...
-		if method.isCallable() {
-			result := method._object().call(toValue_object(self), nil, false, nativeFrame)
-			if result.IsPrimitive() {
-				return result
-			}
-		}
-	}
-
-	panic(self.runtime.panicTypeError())
-}
-
-func (self *_object) String() string {
-	return self.DefaultValue(defaultValueHintString).string()
-}
-
-func (self *_object) defineProperty(name string, value Value, mode _propertyMode, throw bool) bool {
-	return self.defineOwnProperty(name, _property{value, mode}, throw)
-}
-
-// 8.12.9
-func (self *_object) defineOwnProperty(name string, descriptor _property, throw bool) bool {
-	return self.objectClass.defineOwnProperty(self, name, descriptor, throw)
-}
-
-func (self *_object) delete(name string, throw bool) bool {
-	return self.objectClass.delete(self, name, throw)
-}
-
-func (self *_object) enumerate(all bool, each func(string) bool) {
-	self.objectClass.enumerate(self, all, each)
-}
-
-func (self *_object) _exists(name string) bool {
-	_, exists := self.property[name]
-	return exists
-}
-
-func (self *_object) _read(name string) (_property, bool) {
-	property, exists := self.property[name]
-	return property, exists
-}
-
-func (self *_object) _write(name string, value interface{}, mode _propertyMode) {
-	if value == nil {
-		value = Value{}
-	}
-	_, exists := self.property[name]
-	self.property[name] = _property{value, mode}
-	if !exists {
-		self.propertyOrder = append(self.propertyOrder, name)
-	}
-}
-
-func (self *_object) _delete(name string) {
-	_, exists := self.property[name]
-	delete(self.property, name)
-	if exists {
-		for index, property := range self.propertyOrder {
-			if name == property {
-				if index == len(self.propertyOrder)-1 {
-					self.propertyOrder = self.propertyOrder[:index]
-				} else {
-					self.propertyOrder = append(self.propertyOrder[:index], self.propertyOrder[index+1:]...)
-				}
-			}
-		}
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/object_class.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/object_class.go
deleted file mode 100644
index d18b9cede..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/object_class.go
+++ /dev/null
@@ -1,493 +0,0 @@
-package otto
-
-import (
-	"encoding/json"
-)
-
-type _objectClass struct {
-	getOwnProperty    func(*_object, string) *_property
-	getProperty       func(*_object, string) *_property
-	get               func(*_object, string) Value
-	canPut            func(*_object, string) bool
-	put               func(*_object, string, Value, bool)
-	hasProperty       func(*_object, string) bool
-	hasOwnProperty    func(*_object, string) bool
-	defineOwnProperty func(*_object, string, _property, bool) bool
-	delete            func(*_object, string, bool) bool
-	enumerate         func(*_object, bool, func(string) bool)
-	clone             func(*_object, *_object, *_clone) *_object
-	marshalJSON       func(*_object) json.Marshaler
-}
-
-func objectEnumerate(self *_object, all bool, each func(string) bool) {
-	for _, name := range self.propertyOrder {
-		if all || self.property[name].enumerable() {
-			if !each(name) {
-				return
-			}
-		}
-	}
-}
-
-var (
-	_classObject,
-	_classArray,
-	_classString,
-	_classArguments,
-	_classGoStruct,
-	_classGoMap,
-	_classGoArray,
-	_classGoSlice,
-	_ *_objectClass
-)
-
-func init() {
-	_classObject = &_objectClass{
-		objectGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		objectDefineOwnProperty,
-		objectDelete,
-		objectEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classArray = &_objectClass{
-		objectGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		arrayDefineOwnProperty,
-		objectDelete,
-		objectEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classString = &_objectClass{
-		stringGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		objectDefineOwnProperty,
-		objectDelete,
-		stringEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classArguments = &_objectClass{
-		argumentsGetOwnProperty,
-		objectGetProperty,
-		argumentsGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		argumentsDefineOwnProperty,
-		argumentsDelete,
-		objectEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classGoStruct = &_objectClass{
-		goStructGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		goStructCanPut,
-		goStructPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		objectDefineOwnProperty,
-		objectDelete,
-		goStructEnumerate,
-		objectClone,
-		goStructMarshalJSON,
-	}
-
-	_classGoMap = &_objectClass{
-		goMapGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		goMapDefineOwnProperty,
-		goMapDelete,
-		goMapEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classGoArray = &_objectClass{
-		goArrayGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		goArrayDefineOwnProperty,
-		goArrayDelete,
-		goArrayEnumerate,
-		objectClone,
-		nil,
-	}
-
-	_classGoSlice = &_objectClass{
-		goSliceGetOwnProperty,
-		objectGetProperty,
-		objectGet,
-		objectCanPut,
-		objectPut,
-		objectHasProperty,
-		objectHasOwnProperty,
-		goSliceDefineOwnProperty,
-		goSliceDelete,
-		goSliceEnumerate,
-		objectClone,
-		nil,
-	}
-}
-
-// Allons-y
-
-// 8.12.1
-func objectGetOwnProperty(self *_object, name string) *_property {
-	// Return a _copy_ of the property
-	property, exists := self._read(name)
-	if !exists {
-		return nil
-	}
-	return &property
-}
-
-// 8.12.2
-func objectGetProperty(self *_object, name string) *_property {
-	property := self.getOwnProperty(name)
-	if property != nil {
-		return property
-	}
-	if self.prototype != nil {
-		return self.prototype.getProperty(name)
-	}
-	return nil
-}
-
-// 8.12.3
-func objectGet(self *_object, name string) Value {
-	property := self.getProperty(name)
-	if property != nil {
-		return property.get(self)
-	}
-	return Value{}
-}
-
-// 8.12.4
-func objectCanPut(self *_object, name string) bool {
-	canPut, _, _ := _objectCanPut(self, name)
-	return canPut
-}
-
-func _objectCanPut(self *_object, name string) (canPut bool, property *_property, setter *_object) {
-	property = self.getOwnProperty(name)
-	if property != nil {
-		switch propertyValue := property.value.(type) {
-		case Value:
-			canPut = property.writable()
-			return
-		case _propertyGetSet:
-			setter = propertyValue[1]
-			canPut = setter != nil
-			return
-		default:
-			panic(self.runtime.panicTypeError())
-		}
-	}
-
-	if self.prototype == nil {
-		return self.extensible, nil, nil
-	}
-
-	property = self.prototype.getProperty(name)
-	if property == nil {
-		return self.extensible, nil, nil
-	}
-
-	switch propertyValue := property.value.(type) {
-	case Value:
-		if !self.extensible {
-			return false, nil, nil
-		}
-		return property.writable(), nil, nil
-	case _propertyGetSet:
-		setter = propertyValue[1]
-		canPut = setter != nil
-		return
-	default:
-		panic(self.runtime.panicTypeError())
-	}
-}
-
-// 8.12.5
-func objectPut(self *_object, name string, value Value, throw bool) {
-
-	if true {
-		// Shortcut...
-		//
-		// So, right now, every class is using objectCanPut and every class
-		// is using objectPut.
-		//
-		// If that were to no longer be the case, we would have to have
-		// something to detect that here, so that we do not use an
-		// incompatible canPut routine
-		canPut, property, setter := _objectCanPut(self, name)
-		if !canPut {
-			self.runtime.typeErrorResult(throw)
-		} else if setter != nil {
-			setter.call(toValue(self), []Value{value}, false, nativeFrame)
-		} else if property != nil {
-			property.value = value
-			self.defineOwnProperty(name, *property, throw)
-		} else {
-			self.defineProperty(name, value, 0111, throw)
-		}
-		return
-	}
-
-	// The long way...
-	//
-	// Right now, code should never get here, see above
-	if !self.canPut(name) {
-		self.runtime.typeErrorResult(throw)
-		return
-	}
-
-	property := self.getOwnProperty(name)
-	if property == nil {
-		property = self.getProperty(name)
-		if property != nil {
-			if getSet, isAccessor := property.value.(_propertyGetSet); isAccessor {
-				getSet[1].call(toValue(self), []Value{value}, false, nativeFrame)
-				return
-			}
-		}
-		self.defineProperty(name, value, 0111, throw)
-	} else {
-		switch propertyValue := property.value.(type) {
-		case Value:
-			property.value = value
-			self.defineOwnProperty(name, *property, throw)
-		case _propertyGetSet:
-			if propertyValue[1] != nil {
-				propertyValue[1].call(toValue(self), []Value{value}, false, nativeFrame)
-				return
-			}
-			if throw {
-				panic(self.runtime.panicTypeError())
-			}
-		default:
-			panic(self.runtime.panicTypeError())
-		}
-	}
-}
-
-// 8.12.6
-func objectHasProperty(self *_object, name string) bool {
-	return self.getProperty(name) != nil
-}
-
-func objectHasOwnProperty(self *_object, name string) bool {
-	return self.getOwnProperty(name) != nil
-}
-
-// 8.12.9
-func objectDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	property, exists := self._read(name)
-	{
-		if !exists {
-			if !self.extensible {
-				goto Reject
-			}
-			if newGetSet, isAccessor := descriptor.value.(_propertyGetSet); isAccessor {
-				if newGetSet[0] == &_nilGetSetObject {
-					newGetSet[0] = nil
-				}
-				if newGetSet[1] == &_nilGetSetObject {
-					newGetSet[1] = nil
-				}
-				descriptor.value = newGetSet
-			}
-			self._write(name, descriptor.value, descriptor.mode)
-			return true
-		}
-		if descriptor.isEmpty() {
-			return true
-		}
-
-		// TODO Per 8.12.9.6 - We should shortcut here (returning true) if
-		// the current and new (define) properties are the same
-
-		configurable := property.configurable()
-		if !configurable {
-			if descriptor.configurable() {
-				goto Reject
-			}
-			// Test that, if enumerable is set on the property descriptor, then it should
-			// be the same as the existing property
-			if descriptor.enumerateSet() && descriptor.enumerable() != property.enumerable() {
-				goto Reject
-			}
-		}
-		value, isDataDescriptor := property.value.(Value)
-		getSet, _ := property.value.(_propertyGetSet)
-		if descriptor.isGenericDescriptor() {
-			// GenericDescriptor
-		} else if isDataDescriptor != descriptor.isDataDescriptor() {
-			// DataDescriptor <=> AccessorDescriptor
-			if !configurable {
-				goto Reject
-			}
-		} else if isDataDescriptor && descriptor.isDataDescriptor() {
-			// DataDescriptor <=> DataDescriptor
-			if !configurable {
-				if !property.writable() && descriptor.writable() {
-					goto Reject
-				}
-				if !property.writable() {
-					if descriptor.value != nil && !sameValue(value, descriptor.value.(Value)) {
-						goto Reject
-					}
-				}
-			}
-		} else {
-			// AccessorDescriptor <=> AccessorDescriptor
-			newGetSet, _ := descriptor.value.(_propertyGetSet)
-			presentGet, presentSet := true, true
-			if newGetSet[0] == &_nilGetSetObject {
-				// Present, but nil
-				newGetSet[0] = nil
-			} else if newGetSet[0] == nil {
-				// Missing, not even nil
-				newGetSet[0] = getSet[0]
-				presentGet = false
-			}
-			if newGetSet[1] == &_nilGetSetObject {
-				// Present, but nil
-				newGetSet[1] = nil
-			} else if newGetSet[1] == nil {
-				// Missing, not even nil
-				newGetSet[1] = getSet[1]
-				presentSet = false
-			}
-			if !configurable {
-				if (presentGet && (getSet[0] != newGetSet[0])) || (presentSet && (getSet[1] != newGetSet[1])) {
-					goto Reject
-				}
-			}
-			descriptor.value = newGetSet
-		}
-		{
-			// This section will preserve attributes of
-			// the original property, if necessary
-			value1 := descriptor.value
-			if value1 == nil {
-				value1 = property.value
-			} else if newGetSet, isAccessor := descriptor.value.(_propertyGetSet); isAccessor {
-				if newGetSet[0] == &_nilGetSetObject {
-					newGetSet[0] = nil
-				}
-				if newGetSet[1] == &_nilGetSetObject {
-					newGetSet[1] = nil
-				}
-				value1 = newGetSet
-			}
-			mode1 := descriptor.mode
-			if mode1&0222 != 0 {
-				// TODO Factor this out into somewhere testable
-				// (Maybe put into switch ...)
-				mode0 := property.mode
-				if mode1&0200 != 0 {
-					if descriptor.isDataDescriptor() {
-						mode1 &= ^0200 // Turn off "writable" missing
-						mode1 |= (mode0 & 0100)
-					}
-				}
-				if mode1&020 != 0 {
-					mode1 |= (mode0 & 010)
-				}
-				if mode1&02 != 0 {
-					mode1 |= (mode0 & 01)
-				}
-				mode1 &= 0311 // 0311 to preserve the non-setting on "writable"
-			}
-			self._write(name, value1, mode1)
-		}
-		return true
-	}
-Reject:
-	if throw {
-		panic(self.runtime.panicTypeError())
-	}
-	return false
-}
-
-func objectDelete(self *_object, name string, throw bool) bool {
-	property_ := self.getOwnProperty(name)
-	if property_ == nil {
-		return true
-	}
-	if property_.configurable() {
-		self._delete(name)
-		return true
-	}
-	return self.runtime.typeErrorResult(throw)
-}
-
-func objectClone(in *_object, out *_object, clone *_clone) *_object {
-	*out = *in
-
-	out.runtime = clone.runtime
-	if out.prototype != nil {
-		out.prototype = clone.object(in.prototype)
-	}
-	out.property = make(map[string]_property, len(in.property))
-	out.propertyOrder = make([]string, len(in.propertyOrder))
-	copy(out.propertyOrder, in.propertyOrder)
-	for index, property := range in.property {
-		out.property[index] = clone.property(property)
-	}
-
-	switch value := in.value.(type) {
-	case _nativeFunctionObject:
-		out.value = value
-	case _bindFunctionObject:
-		out.value = _bindFunctionObject{
-			target:       clone.object(value.target),
-			this:         clone.value(value.this),
-			argumentList: clone.valueArray(value.argumentList),
-		}
-	case _nodeFunctionObject:
-		out.value = _nodeFunctionObject{
-			node:  value.node,
-			stash: clone.stash(value.stash),
-		}
-	case _argumentsObject:
-		out.value = value.clone(clone)
-	}
-
-	return out
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/otto.go
deleted file mode 100644
index 613533082..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto.go
+++ /dev/null
@@ -1,673 +0,0 @@
-/*
-Package otto is a JavaScript parser and interpreter written natively in Go.
-
-http://godoc.org/github.com/robertkrimen/otto
-
-    import (
-        "github.com/robertkrimen/otto"
-    )
-
-Run something in the VM
-
-    vm := otto.New()
-    vm.Run(`
-        abc = 2 + 2;
-    	console.log("The value of abc is " + abc); // 4
-    `)
-
-Get a value out of the VM
-
-    value, err := vm.Get("abc")
-    	value, _ := value.ToInteger()
-    }
-
-Set a number
-
-    vm.Set("def", 11)
-    vm.Run(`
-    	console.log("The value of def is " + def);
-    	// The value of def is 11
-    `)
-
-Set a string
-
-    vm.Set("xyzzy", "Nothing happens.")
-    vm.Run(`
-    	console.log(xyzzy.length); // 16
-    `)
-
-Get the value of an expression
-
-    value, _ = vm.Run("xyzzy.length")
-    {
-    	// value is an int64 with a value of 16
-    	value, _ := value.ToInteger()
-    }
-
-An error happens
-
-    value, err = vm.Run("abcdefghijlmnopqrstuvwxyz.length")
-    if err != nil {
-    	// err = ReferenceError: abcdefghijlmnopqrstuvwxyz is not defined
-    	// If there is an error, then value.IsUndefined() is true
-    	...
-    }
-
-Set a Go function
-
-    vm.Set("sayHello", func(call otto.FunctionCall) otto.Value {
-        fmt.Printf("Hello, %s.\n", call.Argument(0).String())
-        return otto.Value{}
-    })
-
-Set a Go function that returns something useful
-
-    vm.Set("twoPlus", func(call otto.FunctionCall) otto.Value {
-        right, _ := call.Argument(0).ToInteger()
-        result, _ := vm.ToValue(2 + right)
-        return result
-    })
-
-Use the functions in JavaScript
-
-    result, _ = vm.Run(`
-        sayHello("Xyzzy");      // Hello, Xyzzy.
-        sayHello();             // Hello, undefined
-
-        result = twoPlus(2.0); // 4
-    `)
-
-Parser
-
-A separate parser is available in the parser package if you're just interested in building an AST.
-
-http://godoc.org/github.com/robertkrimen/otto/parser
-
-Parse and return an AST
-
-    filename := "" // A filename is optional
-    src := `
-        // Sample xyzzy example
-        (function(){
-            if (3.14159 > 0) {
-                console.log("Hello, World.");
-                return;
-            }
-
-            var xyzzy = NaN;
-            console.log("Nothing happens.");
-            return xyzzy;
-        })();
-    `
-
-    // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-    program, err := parser.ParseFile(nil, filename, src, 0)
-
-otto
-
-You can run (Go) JavaScript from the commandline with: http://github.com/robertkrimen/otto/tree/master/otto
-
-	$ go get -v github.com/robertkrimen/otto/otto
-
-Run JavaScript by entering some source on stdin or by giving otto a filename:
-
-	$ otto example.js
-
-underscore
-
-Optionally include the JavaScript utility-belt library, underscore, with this import:
-
-	import (
-		"github.com/robertkrimen/otto"
-		_ "github.com/robertkrimen/otto/underscore"
-	)
-
-	// Now every otto runtime will come loaded with underscore
-
-For more information: http://github.com/robertkrimen/otto/tree/master/underscore
-
-Caveat Emptor
-
-The following are some limitations with otto:
-
-    * "use strict" will parse, but does nothing.
-    * The regular expression engine (re2/regexp) is not fully compatible with the ECMA5 specification.
-
-Regular Expression Incompatibility
-
-Go translates JavaScript-style regular expressions into something that is "regexp" compatible via `parser.TransformRegExp`.
-Unfortunately, RegExp requires backtracking for some patterns, and backtracking is not supported by the standard Go engine: https://code.google.com/p/re2/wiki/Syntax
-
-Therefore, the following syntax is incompatible:
-
-    (?=)  // Lookahead (positive), currently a parsing error
-    (?!)  // Lookahead (backhead), currently a parsing error
-    \1    // Backreference (\1, \2, \3, ...), currently a parsing error
-
-A brief discussion of these limitations: "Regexp (?!re)" https://groups.google.com/forum/?fromgroups=#%21topic/golang-nuts/7qgSDWPIh_E
-
-More information about re2: https://code.google.com/p/re2/
-
-In addition to the above, re2 (Go) has a different definition for \s: [\t\n\f\r ].
-The JavaScript definition, on the other hand, also includes \v, Unicode "Separator, Space", etc.
-
-Halting Problem
-
-If you want to stop long running executions (like third-party code), you can use the interrupt channel to do this:
-
-    package main
-
-    import (
-        "errors"
-        "fmt"
-        "os"
-        "time"
-
-        "github.com/robertkrimen/otto"
-    )
-
-    var halt = errors.New("Stahp")
-
-    func main() {
-        runUnsafe(`var abc = [];`)
-        runUnsafe(`
-        while (true) {
-            // Loop forever
-        }`)
-    }
-
-    func runUnsafe(unsafe string) {
-        start := time.Now()
-        defer func() {
-            duration := time.Since(start)
-            if caught := recover(); caught != nil {
-                if caught == halt {
-                    fmt.Fprintf(os.Stderr, "Some code took to long! Stopping after: %v\n", duration)
-                    return
-                }
-                panic(caught) // Something else happened, repanic!
-            }
-            fmt.Fprintf(os.Stderr, "Ran code successfully: %v\n", duration)
-        }()
-
-        vm := otto.New()
-        vm.Interrupt = make(chan func(), 1) // The buffer prevents blocking
-
-        go func() {
-            time.Sleep(2 * time.Second) // Stop after two seconds
-            vm.Interrupt <- func() {
-                panic(halt)
-            }
-        }()
-
-        vm.Run(unsafe) // Here be dragons (risky code)
-    }
-
-Where is setTimeout/setInterval?
-
-These timing functions are not actually part of the ECMA-262 specification. Typically, they belong to the `windows` object (in the browser).
-It would not be difficult to provide something like these via Go, but you probably want to wrap otto in an event loop in that case.
-
-For an example of how this could be done in Go with otto, see natto:
-
-http://github.com/robertkrimen/natto
-
-Here is some more discussion of the issue:
-
-* http://book.mixu.net/node/ch2.html
-
-* http://en.wikipedia.org/wiki/Reentrancy_%28computing%29
-
-* http://aaroncrane.co.uk/2009/02/perl_safe_signals/
-
-*/
-package otto
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/robertkrimen/otto/registry"
-)
-
-// Otto is the representation of the JavaScript runtime. Each instance of Otto has a self-contained namespace.
-type Otto struct {
-	// Interrupt is a channel for interrupting the runtime. You can use this to halt a long running execution, for example.
-	// See "Halting Problem" for more information.
-	Interrupt chan func()
-	runtime   *_runtime
-}
-
-// New will allocate a new JavaScript runtime
-func New() *Otto {
-	self := &Otto{
-		runtime: newContext(),
-	}
-	self.runtime.otto = self
-	self.Set("console", self.runtime.newConsole())
-
-	registry.Apply(func(entry registry.Entry) {
-		self.Run(entry.Source())
-	})
-
-	return self
-}
-
-func (otto *Otto) clone() *Otto {
-	self := &Otto{
-		runtime: otto.runtime.clone(),
-	}
-	self.runtime.otto = self
-	return self
-}
-
-// Run will allocate a new JavaScript runtime, run the given source
-// on the allocated runtime, and return the runtime, resulting value, and
-// error (if any).
-//
-// src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST always be in UTF-8.
-//
-// src may also be a Script.
-//
-// src may also be a Program, but if the AST has been modified, then runtime behavior is undefined.
-//
-func Run(src interface{}) (*Otto, Value, error) {
-	otto := New()
-	value, err := otto.Run(src) // This already does safety checking
-	return otto, value, err
-}
-
-// Run will run the given source (parsing it first if necessary), returning the resulting value and error (if any)
-//
-// src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST always be in UTF-8.
-//
-// If the runtime is unable to parse source, then this function will return undefined and the parse error (nothing
-// will be evaluated in this case).
-//
-// src may also be a Script.
-//
-// src may also be a Program, but if the AST has been modified, then runtime behavior is undefined.
-//
-func (self Otto) Run(src interface{}) (Value, error) {
-	value, err := self.runtime.cmpl_run(src)
-	if !value.safe() {
-		value = Value{}
-	}
-	return value, err
-}
-
-// Eval will do the same thing as Run, except without leaving the current scope.
-//
-// By staying in the same scope, the code evaluated has access to everything
-// already defined in the current stack frame. This is most useful in, for
-// example, a debugger call.
-func (self Otto) Eval(src interface{}) (Value, error) {
-	if self.runtime.scope == nil {
-		self.runtime.enterGlobalScope()
-		defer self.runtime.leaveScope()
-	}
-
-	value, err := self.runtime.cmpl_eval(src)
-	if !value.safe() {
-		value = Value{}
-	}
-	return value, err
-}
-
-// Get the value of the top-level binding of the given name.
-//
-// If there is an error (like the binding does not exist), then the value
-// will be undefined.
-func (self Otto) Get(name string) (Value, error) {
-	value := Value{}
-	err := catchPanic(func() {
-		value = self.getValue(name)
-	})
-	if !value.safe() {
-		value = Value{}
-	}
-	return value, err
-}
-
-func (self Otto) getValue(name string) Value {
-	return self.runtime.globalStash.getBinding(name, false)
-}
-
-// Set the top-level binding of the given name to the given value.
-//
-// Set will automatically apply ToValue to the given value in order
-// to convert it to a JavaScript value (type Value).
-//
-// If there is an error (like the binding is read-only, or the ToValue conversion
-// fails), then an error is returned.
-//
-// If the top-level binding does not exist, it will be created.
-func (self Otto) Set(name string, value interface{}) error {
-	{
-		value, err := self.ToValue(value)
-		if err != nil {
-			return err
-		}
-		err = catchPanic(func() {
-			self.setValue(name, value)
-		})
-		return err
-	}
-}
-
-func (self Otto) setValue(name string, value Value) {
-	self.runtime.globalStash.setValue(name, value, false)
-}
-
-func (self Otto) SetDebuggerHandler(fn func(vm *Otto)) {
-	self.runtime.debugger = fn
-}
-
-func (self Otto) SetRandomSource(fn func() float64) {
-	self.runtime.random = fn
-}
-
-// Context is a structure that contains information about the current execution
-// context.
-type Context struct {
-	Filename   string
-	Line       int
-	Column     int
-	Callee     string
-	Symbols    map[string]Value
-	This       Value
-	Stacktrace []string
-}
-
-// Context returns the current execution context of the vm
-func (self Otto) Context() (ctx Context) {
-	// Ensure we are operating in a scope
-	if self.runtime.scope == nil {
-		self.runtime.enterGlobalScope()
-		defer self.runtime.leaveScope()
-	}
-
-	scope := self.runtime.scope
-	frame := scope.frame
-
-	// Get location information
-	ctx.Filename = "<unknown>"
-	ctx.Callee = frame.callee
-	if frame.file != nil {
-		ctx.Filename = frame.file.Name()
-		if ctx.Filename == "" {
-			ctx.Filename = "<anonymous>"
-		}
-		ctx.Line, ctx.Column = _position(frame.file, frame.offset)
-	}
-
-	// Get the current scope this Value
-	ctx.This = toValue_object(scope.this)
-
-	// Build stacktrace (up to 10 levels deep)
-	limit := 10
-	ctx.Symbols = make(map[string]Value)
-	ctx.Stacktrace = append(ctx.Stacktrace, frame.location())
-	for limit > 0 {
-		// Get variables
-		stash := scope.lexical
-		for {
-			for _, name := range getStashProperties(stash) {
-				if _, ok := ctx.Symbols[name]; !ok {
-					ctx.Symbols[name] = stash.getBinding(name, true)
-				}
-			}
-			stash = stash.outer()
-			if stash == nil || stash.outer() == nil {
-				break
-			}
-		}
-
-		scope = scope.outer
-		if scope == nil {
-			break
-		}
-		if scope.frame.offset >= 0 {
-			ctx.Stacktrace = append(ctx.Stacktrace, scope.frame.location())
-		}
-		limit--
-	}
-
-	return
-}
-
-// Call the given JavaScript with a given this and arguments.
-//
-// If this is nil, then some special handling takes place to determine the proper
-// this value, falling back to a "standard" invocation if necessary (where this is
-// undefined).
-//
-// If source begins with "new " (A lowercase new followed by a space), then
-// Call will invoke the function constructor rather than performing a function call.
-// In this case, the this argument has no effect.
-//
-//      // value is a String object
-//      value, _ := vm.Call("Object", nil, "Hello, World.")
-//
-//      // Likewise...
-//      value, _ := vm.Call("new Object", nil, "Hello, World.")
-//
-//      // This will perform a concat on the given array and return the result
-//      // value is [ 1, 2, 3, undefined, 4, 5, 6, 7, "abc" ]
-//      value, _ := vm.Call(`[ 1, 2, 3, undefined, 4 ].concat`, nil, 5, 6, 7, "abc")
-//
-func (self Otto) Call(source string, this interface{}, argumentList ...interface{}) (Value, error) {
-
-	thisValue := Value{}
-
-	construct := false
-	if strings.HasPrefix(source, "new ") {
-		source = source[4:]
-		construct = true
-	}
-
-	// FIXME enterGlobalScope
-	self.runtime.enterGlobalScope()
-	defer func() {
-		self.runtime.leaveScope()
-	}()
-
-	if !construct && this == nil {
-		program, err := self.runtime.cmpl_parse("", source+"()")
-		if err == nil {
-			if node, ok := program.body[0].(*_nodeExpressionStatement); ok {
-				if node, ok := node.expression.(*_nodeCallExpression); ok {
-					var value Value
-					err := catchPanic(func() {
-						value = self.runtime.cmpl_evaluate_nodeCallExpression(node, argumentList)
-					})
-					if err != nil {
-						return Value{}, err
-					}
-					return value, nil
-				}
-			}
-		}
-	} else {
-		value, err := self.ToValue(this)
-		if err != nil {
-			return Value{}, err
-		}
-		thisValue = value
-	}
-
-	{
-		this := thisValue
-
-		fn, err := self.Run(source)
-		if err != nil {
-			return Value{}, err
-		}
-
-		if construct {
-			result, err := fn.constructSafe(self.runtime, this, argumentList...)
-			if err != nil {
-				return Value{}, err
-			}
-			return result, nil
-		}
-
-		result, err := fn.Call(this, argumentList...)
-		if err != nil {
-			return Value{}, err
-		}
-		return result, nil
-	}
-}
-
-// Object will run the given source and return the result as an object.
-//
-// For example, accessing an existing object:
-//
-//		object, _ := vm.Object(`Number`)
-//
-// Or, creating a new object:
-//
-//		object, _ := vm.Object(`({ xyzzy: "Nothing happens." })`)
-//
-// Or, creating and assigning an object:
-//
-//		object, _ := vm.Object(`xyzzy = {}`)
-//		object.Set("volume", 11)
-//
-// If there is an error (like the source does not result in an object), then
-// nil and an error is returned.
-func (self Otto) Object(source string) (*Object, error) {
-	value, err := self.runtime.cmpl_run(source)
-	if err != nil {
-		return nil, err
-	}
-	if value.IsObject() {
-		return value.Object(), nil
-	}
-	return nil, fmt.Errorf("value is not an object")
-}
-
-// ToValue will convert an interface{} value to a value digestible by otto/JavaScript.
-func (self Otto) ToValue(value interface{}) (Value, error) {
-	return self.runtime.safeToValue(value)
-}
-
-// Copy will create a copy/clone of the runtime.
-//
-// Copy is useful for saving some time when creating many similar runtimes.
-//
-// This method works by walking the original runtime and cloning each object, scope, stash,
-// etc. into a new runtime.
-//
-// Be on the lookout for memory leaks or inadvertent sharing of resources.
-func (in *Otto) Copy() *Otto {
-	out := &Otto{
-		runtime: in.runtime.clone(),
-	}
-	out.runtime.otto = out
-	return out
-}
-
-// Object{}
-
-// Object is the representation of a JavaScript object.
-type Object struct {
-	object *_object
-	value  Value
-}
-
-func _newObject(object *_object, value Value) *Object {
-	// value MUST contain object!
-	return &Object{
-		object: object,
-		value:  value,
-	}
-}
-
-// Call a method on the object.
-//
-// It is essentially equivalent to:
-//
-//		var method, _ := object.Get(name)
-//		method.Call(object, argumentList...)
-//
-// An undefined value and an error will result if:
-//
-//		1. There is an error during conversion of the argument list
-//		2. The property is not actually a function
-//		3. An (uncaught) exception is thrown
-//
-func (self Object) Call(name string, argumentList ...interface{}) (Value, error) {
-	// TODO: Insert an example using JavaScript below...
-	// e.g., Object("JSON").Call("stringify", ...)
-
-	function, err := self.Get(name)
-	if err != nil {
-		return Value{}, err
-	}
-	return function.Call(self.Value(), argumentList...)
-}
-
-// Value will return self as a value.
-func (self Object) Value() Value {
-	return self.value
-}
-
-// Get the value of the property with the given name.
-func (self Object) Get(name string) (Value, error) {
-	value := Value{}
-	err := catchPanic(func() {
-		value = self.object.get(name)
-	})
-	if !value.safe() {
-		value = Value{}
-	}
-	return value, err
-}
-
-// Set the property of the given name to the given value.
-//
-// An error will result if the setting the property triggers an exception (i.e. read-only),
-// or there is an error during conversion of the given value.
-func (self Object) Set(name string, value interface{}) error {
-	{
-		value, err := self.object.runtime.safeToValue(value)
-		if err != nil {
-			return err
-		}
-		err = catchPanic(func() {
-			self.object.put(name, value, true)
-		})
-		return err
-	}
-}
-
-// Get the keys for the object
-//
-// Equivalent to calling Object.keys on the object
-func (self Object) Keys() []string {
-	var keys []string
-	self.object.enumerate(false, func(name string) bool {
-		keys = append(keys, name)
-		return true
-	})
-	return keys
-}
-
-// Class will return the class string of the object.
-//
-// The return value will (generally) be one of:
-//
-//		Object
-//		Function
-//		Array
-//		String
-//		Number
-//		Boolean
-//		Date
-//		RegExp
-//
-func (self Object) Class() string {
-	return self.object.class
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/Makefile
deleted file mode 100644
index bac5cd4a5..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-.PHONY: build
-
-build:
-	go build -a
-	-gxc build-darwin-386 -a
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/main.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/main.go
deleted file mode 100644
index f379e42a9..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto/main.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-
-	"github.com/robertkrimen/otto"
-	"github.com/robertkrimen/otto/underscore"
-)
-
-var flag_underscore *bool = flag.Bool("underscore", true, "Load underscore into the runtime environment")
-
-func readSource(filename string) ([]byte, error) {
-	if filename == "" || filename == "-" {
-		return ioutil.ReadAll(os.Stdin)
-	}
-	return ioutil.ReadFile(filename)
-}
-
-func main() {
-	flag.Parse()
-
-	if !*flag_underscore {
-		underscore.Disable()
-	}
-
-	err := func() error {
-		src, err := readSource(flag.Arg(0))
-		if err != nil {
-			return err
-		}
-
-		vm := otto.New()
-		_, err = vm.Run(src)
-		return err
-	}()
-	if err != nil {
-		switch err := err.(type) {
-		case *otto.Error:
-			fmt.Print(err.String())
-		default:
-			fmt.Println(err)
-		}
-		os.Exit(64)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto_.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/otto_.go
deleted file mode 100644
index 304a83150..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/otto_.go
+++ /dev/null
@@ -1,178 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"regexp"
-	runtime_ "runtime"
-	"strconv"
-	"strings"
-)
-
-var isIdentifier_Regexp *regexp.Regexp = regexp.MustCompile(`^[a-zA-Z\$][a-zA-Z0-9\$]*$`)
-
-func isIdentifier(string_ string) bool {
-	return isIdentifier_Regexp.MatchString(string_)
-}
-
-func (self *_runtime) toValueArray(arguments ...interface{}) []Value {
-	length := len(arguments)
-	if length == 1 {
-		if valueArray, ok := arguments[0].([]Value); ok {
-			return valueArray
-		}
-		return []Value{self.toValue(arguments[0])}
-	}
-
-	valueArray := make([]Value, length)
-	for index, value := range arguments {
-		valueArray[index] = self.toValue(value)
-	}
-
-	return valueArray
-}
-
-func stringToArrayIndex(name string) int64 {
-	index, err := strconv.ParseInt(name, 10, 64)
-	if err != nil {
-		return -1
-	}
-	if index < 0 {
-		return -1
-	}
-	if index >= maxUint32 {
-		// The value 2^32 (or above) is not a valid index because
-		// you cannot store a uint32 length for an index of uint32
-		return -1
-	}
-	return index
-}
-
-func isUint32(value int64) bool {
-	return value >= 0 && value <= maxUint32
-}
-
-func arrayIndexToString(index int64) string {
-	return strconv.FormatInt(index, 10)
-}
-
-func valueOfArrayIndex(array []Value, index int) Value {
-	value, _ := getValueOfArrayIndex(array, index)
-	return value
-}
-
-func getValueOfArrayIndex(array []Value, index int) (Value, bool) {
-	if index >= 0 && index < len(array) {
-		value := array[index]
-		if !value.isEmpty() {
-			return value, true
-		}
-	}
-	return Value{}, false
-}
-
-// A range index can be anything from 0 up to length. It is NOT safe to use as an index
-// to an array, but is useful for slicing and in some ECMA algorithms.
-func valueToRangeIndex(indexValue Value, length int64, negativeIsZero bool) int64 {
-	index := indexValue.number().int64
-	if negativeIsZero {
-		if index < 0 {
-			index = 0
-		}
-		// minimum(index, length)
-		if index >= length {
-			index = length
-		}
-		return index
-	}
-
-	if index < 0 {
-		index += length
-		if index < 0 {
-			index = 0
-		}
-	} else {
-		if index > length {
-			index = length
-		}
-	}
-	return index
-}
-
-func rangeStartEnd(array []Value, size int64, negativeIsZero bool) (start, end int64) {
-	start = valueToRangeIndex(valueOfArrayIndex(array, 0), size, negativeIsZero)
-	if len(array) == 1 {
-		// If there is only the start argument, then end = size
-		end = size
-		return
-	}
-
-	// Assuming the argument is undefined...
-	end = size
-	endValue := valueOfArrayIndex(array, 1)
-	if !endValue.IsUndefined() {
-		// Which it is not, so get the value as an array index
-		end = valueToRangeIndex(endValue, size, negativeIsZero)
-	}
-	return
-}
-
-func rangeStartLength(source []Value, size int64) (start, length int64) {
-	start = valueToRangeIndex(valueOfArrayIndex(source, 0), size, false)
-
-	// Assume the second argument is missing or undefined
-	length = int64(size)
-	if len(source) == 1 {
-		// If there is only the start argument, then length = size
-		return
-	}
-
-	lengthValue := valueOfArrayIndex(source, 1)
-	if !lengthValue.IsUndefined() {
-		// Which it is not, so get the value as an array index
-		length = lengthValue.number().int64
-	}
-	return
-}
-
-func boolFields(input string) (result map[string]bool) {
-	result = map[string]bool{}
-	for _, word := range strings.Fields(input) {
-		result[word] = true
-	}
-	return result
-}
-
-func hereBeDragons(arguments ...interface{}) string {
-	pc, _, _, _ := runtime_.Caller(1)
-	name := runtime_.FuncForPC(pc).Name()
-	message := fmt.Sprintf("Here be dragons -- %s", name)
-	if len(arguments) > 0 {
-		message += ": "
-		argument0 := fmt.Sprintf("%s", arguments[0])
-		if len(arguments) == 1 {
-			message += argument0
-		} else {
-			message += fmt.Sprintf(argument0, arguments[1:]...)
-		}
-	} else {
-		message += "."
-	}
-	return message
-}
-
-func throwHereBeDragons(arguments ...interface{}) {
-	panic(hereBeDragons(arguments...))
-}
-
-func eachPair(list []interface{}, fn func(_0, _1 interface{})) {
-	for len(list) > 0 {
-		var _0, _1 interface{}
-		_0 = list[0]
-		list = list[1:] // Pop off first
-		if len(list) > 0 {
-			_1 = list[0]
-			list = list[1:] // Pop off second
-		}
-		fn(_0, _1)
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/Makefile
deleted file mode 100644
index 766fd4d0b..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/Makefile
+++ /dev/null
@@ -1,4 +0,0 @@
-.PHONY: test
-
-test:
-	go test
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/README.markdown
deleted file mode 100644
index c3cae5b60..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/README.markdown
+++ /dev/null
@@ -1,190 +0,0 @@
-# parser
---
-    import "github.com/robertkrimen/otto/parser"
-
-Package parser implements a parser for JavaScript.
-
-    import (
-        "github.com/robertkrimen/otto/parser"
-    )
-
-Parse and return an AST
-
-    filename := "" // A filename is optional
-    src := `
-        // Sample xyzzy example
-        (function(){
-            if (3.14159 > 0) {
-                console.log("Hello, World.");
-                return;
-            }
-
-            var xyzzy = NaN;
-            console.log("Nothing happens.");
-            return xyzzy;
-        })();
-    `
-
-    // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-    program, err := parser.ParseFile(nil, filename, src, 0)
-
-
-### Warning
-
-The parser and AST interfaces are still works-in-progress (particularly where
-node types are concerned) and may change in the future.
-
-## Usage
-
-#### func  ParseFile
-
-```go
-func ParseFile(fileSet *file.FileSet, filename string, src interface{}, mode Mode) (*ast.Program, error)
-```
-ParseFile parses the source code of a single JavaScript/ECMAScript source file
-and returns the corresponding ast.Program node.
-
-If fileSet == nil, ParseFile parses source without a FileSet. If fileSet != nil,
-ParseFile first adds filename and src to fileSet.
-
-The filename argument is optional and is used for labelling errors, etc.
-
-src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST
-always be in UTF-8.
-
-    // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-    program, err := parser.ParseFile(nil, "", `if (abc > 1) {}`, 0)
-
-#### func  ParseFunction
-
-```go
-func ParseFunction(parameterList, body string) (*ast.FunctionLiteral, error)
-```
-ParseFunction parses a given parameter list and body as a function and returns
-the corresponding ast.FunctionLiteral node.
-
-The parameter list, if any, should be a comma-separated list of identifiers.
-
-#### func  ReadSource
-
-```go
-func ReadSource(filename string, src interface{}) ([]byte, error)
-```
-
-#### func  TransformRegExp
-
-```go
-func TransformRegExp(pattern string) (string, error)
-```
-TransformRegExp transforms a JavaScript pattern into a Go "regexp" pattern.
-
-re2 (Go) cannot do backtracking, so the presence of a lookahead (?=) (?!) or
-backreference (\1, \2, ...) will cause an error.
-
-re2 (Go) has a different definition for \s: [\t\n\f\r ]. The JavaScript
-definition, on the other hand, also includes \v, Unicode "Separator, Space",
-etc.
-
-If the pattern is invalid (not valid even in JavaScript), then this function
-returns the empty string and an error.
-
-If the pattern is valid, but incompatible (contains a lookahead or
-backreference), then this function returns the transformation (a non-empty
-string) AND an error.
-
-#### type Error
-
-```go
-type Error struct {
-	Position file.Position
-	Message  string
-}
-```
-
-An Error represents a parsing error. It includes the position where the error
-occurred and a message/description.
-
-#### func (Error) Error
-
-```go
-func (self Error) Error() string
-```
-
-#### type ErrorList
-
-```go
-type ErrorList []*Error
-```
-
-ErrorList is a list of *Errors.
-
-#### func (*ErrorList) Add
-
-```go
-func (self *ErrorList) Add(position file.Position, msg string)
-```
-Add adds an Error with given position and message to an ErrorList.
-
-#### func (ErrorList) Err
-
-```go
-func (self ErrorList) Err() error
-```
-Err returns an error equivalent to this ErrorList. If the list is empty, Err
-returns nil.
-
-#### func (ErrorList) Error
-
-```go
-func (self ErrorList) Error() string
-```
-Error implements the Error interface.
-
-#### func (ErrorList) Len
-
-```go
-func (self ErrorList) Len() int
-```
-
-#### func (ErrorList) Less
-
-```go
-func (self ErrorList) Less(i, j int) bool
-```
-
-#### func (*ErrorList) Reset
-
-```go
-func (self *ErrorList) Reset()
-```
-Reset resets an ErrorList to no errors.
-
-#### func (ErrorList) Sort
-
-```go
-func (self ErrorList) Sort()
-```
-
-#### func (ErrorList) Swap
-
-```go
-func (self ErrorList) Swap(i, j int)
-```
-
-#### type Mode
-
-```go
-type Mode uint
-```
-
-A Mode value is a set of flags (or 0). They control optional parser
-functionality.
-
-```go
-const (
-	IgnoreRegExpErrors Mode = 1 << iota // Ignore RegExp compatibility errors (allow backtracking)
-)
-```
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/dbg.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/dbg.go
deleted file mode 100644
index 3c5f2f698..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/dbg.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// This file was AUTOMATICALLY GENERATED by dbg-import (smuggol) for github.com/robertkrimen/dbg
-
-package parser
-
-import (
-	Dbg "github.com/robertkrimen/otto/dbg"
-)
-
-var dbg, dbgf = Dbg.New()
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/error.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/error.go
deleted file mode 100644
index e0f74a5cf..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/error.go
+++ /dev/null
@@ -1,175 +0,0 @@
-package parser
-
-import (
-	"fmt"
-	"sort"
-
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-const (
-	err_UnexpectedToken      = "Unexpected token %v"
-	err_UnexpectedEndOfInput = "Unexpected end of input"
-	err_UnexpectedEscape     = "Unexpected escape"
-)
-
-//    UnexpectedNumber:  'Unexpected number',
-//    UnexpectedString:  'Unexpected string',
-//    UnexpectedIdentifier:  'Unexpected identifier',
-//    UnexpectedReserved:  'Unexpected reserved word',
-//    NewlineAfterThrow:  'Illegal newline after throw',
-//    InvalidRegExp: 'Invalid regular expression',
-//    UnterminatedRegExp:  'Invalid regular expression: missing /',
-//    InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
-//    InvalidLHSInForIn:  'Invalid left-hand side in for-in',
-//    MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
-//    NoCatchOrFinally:  'Missing catch or finally after try',
-//    UnknownLabel: 'Undefined label \'%0\'',
-//    Redeclaration: '%0 \'%1\' has already been declared',
-//    IllegalContinue: 'Illegal continue statement',
-//    IllegalBreak: 'Illegal break statement',
-//    IllegalReturn: 'Illegal return statement',
-//    StrictModeWith:  'Strict mode code may not include a with statement',
-//    StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
-//    StrictVarName:  'Variable name may not be eval or arguments in strict mode',
-//    StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
-//    StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
-//    StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
-//    StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
-//    StrictDelete:  'Delete of an unqualified identifier in strict mode.',
-//    StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
-//    AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
-//    AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
-//    StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
-//    StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
-//    StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
-//    StrictReservedWord:  'Use of future reserved word in strict mode'
-
-// A SyntaxError is a description of an ECMAScript syntax error.
-
-// An Error represents a parsing error. It includes the position where the error occurred and a message/description.
-type Error struct {
-	Position file.Position
-	Message  string
-}
-
-// FIXME Should this be "SyntaxError"?
-
-func (self Error) Error() string {
-	filename := self.Position.Filename
-	if filename == "" {
-		filename = "(anonymous)"
-	}
-	return fmt.Sprintf("%s: Line %d:%d %s",
-		filename,
-		self.Position.Line,
-		self.Position.Column,
-		self.Message,
-	)
-}
-
-func (self *_parser) error(place interface{}, msg string, msgValues ...interface{}) *Error {
-	idx := file.Idx(0)
-	switch place := place.(type) {
-	case int:
-		idx = self.idxOf(place)
-	case file.Idx:
-		if place == 0 {
-			idx = self.idxOf(self.chrOffset)
-		} else {
-			idx = place
-		}
-	default:
-		panic(fmt.Errorf("error(%T, ...)", place))
-	}
-
-	position := self.position(idx)
-	msg = fmt.Sprintf(msg, msgValues...)
-	self.errors.Add(position, msg)
-	return self.errors[len(self.errors)-1]
-}
-
-func (self *_parser) errorUnexpected(idx file.Idx, chr rune) error {
-	if chr == -1 {
-		return self.error(idx, err_UnexpectedEndOfInput)
-	}
-	return self.error(idx, err_UnexpectedToken, token.ILLEGAL)
-}
-
-func (self *_parser) errorUnexpectedToken(tkn token.Token) error {
-	switch tkn {
-	case token.EOF:
-		return self.error(file.Idx(0), err_UnexpectedEndOfInput)
-	}
-	value := tkn.String()
-	switch tkn {
-	case token.BOOLEAN, token.NULL:
-		value = self.literal
-	case token.IDENTIFIER:
-		return self.error(self.idx, "Unexpected identifier")
-	case token.KEYWORD:
-		// TODO Might be a future reserved word
-		return self.error(self.idx, "Unexpected reserved word")
-	case token.NUMBER:
-		return self.error(self.idx, "Unexpected number")
-	case token.STRING:
-		return self.error(self.idx, "Unexpected string")
-	}
-	return self.error(self.idx, err_UnexpectedToken, value)
-}
-
-// ErrorList is a list of *Errors.
-//
-type ErrorList []*Error
-
-// Add adds an Error with given position and message to an ErrorList.
-func (self *ErrorList) Add(position file.Position, msg string) {
-	*self = append(*self, &Error{position, msg})
-}
-
-// Reset resets an ErrorList to no errors.
-func (self *ErrorList) Reset() { *self = (*self)[0:0] }
-
-func (self ErrorList) Len() int      { return len(self) }
-func (self ErrorList) Swap(i, j int) { self[i], self[j] = self[j], self[i] }
-func (self ErrorList) Less(i, j int) bool {
-	x := &self[i].Position
-	y := &self[j].Position
-	if x.Filename < y.Filename {
-		return true
-	}
-	if x.Filename == y.Filename {
-		if x.Line < y.Line {
-			return true
-		}
-		if x.Line == y.Line {
-			return x.Column < y.Column
-		}
-	}
-	return false
-}
-
-func (self ErrorList) Sort() {
-	sort.Sort(self)
-}
-
-// Error implements the Error interface.
-func (self ErrorList) Error() string {
-	switch len(self) {
-	case 0:
-		return "no errors"
-	case 1:
-		return self[0].Error()
-	}
-	return fmt.Sprintf("%s (and %d more errors)", self[0].Error(), len(self)-1)
-}
-
-// Err returns an error equivalent to this ErrorList.
-// If the list is empty, Err returns nil.
-func (self ErrorList) Err() error {
-	if len(self) == 0 {
-		return nil
-	}
-	return self
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/expression.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/expression.go
deleted file mode 100644
index a23a7279a..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/expression.go
+++ /dev/null
@@ -1,1054 +0,0 @@
-package parser
-
-import (
-	"regexp"
-
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-func (self *_parser) parseIdentifier() *ast.Identifier {
-	literal := self.literal
-	idx := self.idx
-	self.next()
-	comments := self.findComments(false)
-	exp := &ast.Identifier{
-		Name: literal,
-		Idx:  idx,
-	}
-
-	self.commentMap.AddComments(exp, comments, ast.TRAILING)
-	return exp
-}
-
-func (self *_parser) parsePrimaryExpression() ast.Expression {
-	literal := self.literal
-	idx := self.idx
-	switch self.token {
-	case token.IDENTIFIER:
-		self.next()
-		if len(literal) > 1 {
-			tkn, strict := token.IsKeyword(literal)
-			if tkn == token.KEYWORD {
-				if !strict {
-					self.error(idx, "Unexpected reserved word")
-				}
-			}
-		}
-		return &ast.Identifier{
-			Name: literal,
-			Idx:  idx,
-		}
-	case token.NULL:
-		self.next()
-		return &ast.NullLiteral{
-			Idx:     idx,
-			Literal: literal,
-		}
-	case token.BOOLEAN:
-		self.next()
-		value := false
-		switch literal {
-		case "true":
-			value = true
-		case "false":
-			value = false
-		default:
-			self.error(idx, "Illegal boolean literal")
-		}
-		return &ast.BooleanLiteral{
-			Idx:     idx,
-			Literal: literal,
-			Value:   value,
-		}
-	case token.STRING:
-		self.next()
-		value, err := parseStringLiteral(literal[1 : len(literal)-1])
-		if err != nil {
-			self.error(idx, err.Error())
-		}
-		return &ast.StringLiteral{
-			Idx:     idx,
-			Literal: literal,
-			Value:   value,
-		}
-	case token.NUMBER:
-		self.next()
-		value, err := parseNumberLiteral(literal)
-		if err != nil {
-			self.error(idx, err.Error())
-			value = 0
-		}
-		return &ast.NumberLiteral{
-			Idx:     idx,
-			Literal: literal,
-			Value:   value,
-		}
-	case token.SLASH, token.QUOTIENT_ASSIGN:
-		return self.parseRegExpLiteral()
-	case token.LEFT_BRACE:
-		return self.parseObjectLiteral()
-	case token.LEFT_BRACKET:
-		return self.parseArrayLiteral()
-	case token.LEFT_PARENTHESIS:
-		self.expect(token.LEFT_PARENTHESIS)
-		expression := self.parseExpression()
-		self.expect(token.RIGHT_PARENTHESIS)
-		return expression
-	case token.THIS:
-		self.next()
-		return &ast.ThisExpression{
-			Idx: idx,
-		}
-	case token.FUNCTION:
-		return self.parseFunction(false)
-	}
-
-	self.errorUnexpectedToken(self.token)
-	self.nextStatement()
-	return &ast.BadExpression{From: idx, To: self.idx}
-}
-
-func (self *_parser) parseRegExpLiteral() *ast.RegExpLiteral {
-
-	offset := self.chrOffset - 1 // Opening slash already gotten
-	if self.token == token.QUOTIENT_ASSIGN {
-		offset -= 1 // =
-	}
-	idx := self.idxOf(offset)
-
-	pattern, err := self.scanString(offset)
-	endOffset := self.chrOffset
-
-	self.next()
-	if err == nil {
-		pattern = pattern[1 : len(pattern)-1]
-	}
-
-	flags := ""
-	if self.token == token.IDENTIFIER { // gim
-
-		flags = self.literal
-		self.next()
-		endOffset = self.chrOffset - 1
-	}
-
-	var value string
-	// TODO 15.10
-	{
-		// Test during parsing that this is a valid regular expression
-		// Sorry, (?=) and (?!) are invalid (for now)
-		pattern, err := TransformRegExp(pattern)
-		if err != nil {
-			if pattern == "" || self.mode&IgnoreRegExpErrors == 0 {
-				self.error(idx, "Invalid regular expression: %s", err.Error())
-			}
-		} else {
-			_, err = regexp.Compile(pattern)
-			if err != nil {
-				// We should not get here, ParseRegExp should catch any errors
-				self.error(idx, "Invalid regular expression: %s", err.Error()[22:]) // Skip redundant "parse regexp error"
-			} else {
-				value = pattern
-			}
-		}
-	}
-
-	literal := self.str[offset:endOffset]
-
-	return &ast.RegExpLiteral{
-		Idx:     idx,
-		Literal: literal,
-		Pattern: pattern,
-		Flags:   flags,
-		Value:   value,
-	}
-}
-
-func (self *_parser) parseVariableDeclaration(declarationList *[]*ast.VariableExpression) ast.Expression {
-
-	if self.token != token.IDENTIFIER {
-		idx := self.expect(token.IDENTIFIER)
-		self.nextStatement()
-		return &ast.BadExpression{From: idx, To: self.idx}
-	}
-
-	literal := self.literal
-	idx := self.idx
-	self.next()
-	node := &ast.VariableExpression{
-		Name: literal,
-		Idx:  idx,
-	}
-
-	if declarationList != nil {
-		*declarationList = append(*declarationList, node)
-	}
-
-	if self.token == token.ASSIGN {
-		self.next()
-		node.Initializer = self.parseAssignmentExpression()
-	}
-
-	return node
-}
-
-func (self *_parser) parseVariableDeclarationList(var_ file.Idx) []ast.Expression {
-
-	var declarationList []*ast.VariableExpression // Avoid bad expressions
-	var list []ast.Expression
-
-	for {
-		comments := self.findComments(false)
-
-		decl := self.parseVariableDeclaration(&declarationList)
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(decl, comments, ast.LEADING)
-			self.commentMap.AddComments(decl, self.findComments(false), ast.TRAILING)
-		}
-
-		list = append(list, decl)
-		if self.token != token.COMMA {
-			break
-		}
-		self.next()
-
-	}
-
-	self.scope.declare(&ast.VariableDeclaration{
-		Var:  var_,
-		List: declarationList,
-	})
-
-	return list
-}
-
-func (self *_parser) parseObjectPropertyKey() (string, string, []*ast.Comment) {
-	idx, tkn, literal := self.idx, self.token, self.literal
-	value := ""
-	self.next()
-
-	comments := self.findComments(false)
-
-	switch tkn {
-	case token.IDENTIFIER:
-		value = literal
-	case token.NUMBER:
-		var err error
-		_, err = parseNumberLiteral(literal)
-		if err != nil {
-			self.error(idx, err.Error())
-		} else {
-			value = literal
-		}
-	case token.STRING:
-		var err error
-		value, err = parseStringLiteral(literal[1 : len(literal)-1])
-		if err != nil {
-			self.error(idx, err.Error())
-		}
-	default:
-		// null, false, class, etc.
-		if matchIdentifier.MatchString(literal) {
-			value = literal
-		}
-	}
-	return literal, value, comments
-}
-
-func (self *_parser) parseObjectProperty() ast.Property {
-	literal, value, comments := self.parseObjectPropertyKey()
-	if literal == "get" && self.token != token.COLON {
-		idx := self.idx
-		_, value, _ := self.parseObjectPropertyKey()
-		parameterList := self.parseFunctionParameterList()
-
-		node := &ast.FunctionLiteral{
-			Function:      idx,
-			ParameterList: parameterList,
-		}
-		self.parseFunctionBlock(node)
-		return ast.Property{
-			Key:   value,
-			Kind:  "get",
-			Value: node,
-		}
-	} else if literal == "set" && self.token != token.COLON {
-		idx := self.idx
-		_, value, _ := self.parseObjectPropertyKey()
-		parameterList := self.parseFunctionParameterList()
-
-		node := &ast.FunctionLiteral{
-			Function:      idx,
-			ParameterList: parameterList,
-		}
-		self.parseFunctionBlock(node)
-		return ast.Property{
-			Key:   value,
-			Kind:  "set",
-			Value: node,
-		}
-	}
-
-	self.expect(token.COLON)
-	comments2 := self.findComments(false)
-
-	exp := ast.Property{
-		Key:   value,
-		Kind:  "value",
-		Value: self.parseAssignmentExpression(),
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(exp.Value, comments, ast.KEY)
-		self.commentMap.AddComments(exp.Value, comments2, ast.COLON)
-	}
-	return exp
-}
-
-func (self *_parser) parseObjectLiteral() ast.Expression {
-	var value []ast.Property
-	idx0 := self.expect(token.LEFT_BRACE)
-
-	var comments2 []*ast.Comment
-	for self.token != token.RIGHT_BRACE && self.token != token.EOF {
-
-		// Leading comments for object literal
-		comments := self.findComments(false)
-		property := self.parseObjectProperty()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(property.Value, comments, ast.LEADING)
-			self.commentMap.AddComments(property.Value, comments2, ast.LEADING)
-		}
-		value = append(value, property)
-		if self.token == token.COMMA {
-			self.next()
-
-			// Find leading comments after trailing comma
-			comments2 = self.findComments(false)
-			continue
-		}
-	}
-	idx1 := self.expect(token.RIGHT_BRACE)
-
-	exp := &ast.ObjectLiteral{
-		LeftBrace:  idx0,
-		RightBrace: idx1,
-		Value:      value,
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(exp, comments2, ast.FINAL)
-	}
-	self.consumeComments(exp, ast.FINAL)
-
-	return exp
-}
-
-func (self *_parser) parseArrayLiteral() ast.Expression {
-	idx0 := self.expect(token.LEFT_BRACKET)
-	var comments2 []*ast.Comment
-	var comments []*ast.Comment
-	var value []ast.Expression
-	for self.token != token.RIGHT_BRACKET && self.token != token.EOF {
-		// Find leading comments for both empty and non-empty expressions
-		comments = self.findComments(false)
-
-		if self.token == token.COMMA {
-			self.next()
-
-			// This kind of comment requires a special empty expression node.
-			empty := &ast.EmptyExpression{self.idx, self.idx}
-
-			if self.mode&StoreComments != 0 {
-				self.commentMap.AddComments(empty, comments, ast.LEADING)
-				self.commentMap.AddComments(empty, comments2, ast.LEADING)
-			}
-
-			value = append(value, empty)
-
-			// This comment belongs to the following expression, or trailing
-			comments2 = self.findComments(false)
-
-			continue
-		}
-
-		exp := self.parseAssignmentExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp, comments, ast.LEADING)
-			self.commentMap.AddComments(exp, comments2, ast.LEADING)
-		}
-
-		value = append(value, exp)
-		if self.token != token.RIGHT_BRACKET {
-			self.expect(token.COMMA)
-		}
-
-		// This comment belongs to the following expression, or trailing
-		comments2 = self.findComments(false)
-	}
-	idx1 := self.expect(token.RIGHT_BRACKET)
-
-	array := &ast.ArrayLiteral{
-		LeftBracket:  idx0,
-		RightBracket: idx1,
-		Value:        value,
-	}
-
-	// This is where comments after a possible trailing comma are added
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(array, comments2, ast.FINAL)
-	}
-
-	return array
-}
-
-func (self *_parser) parseArgumentList() (argumentList []ast.Expression, idx0, idx1 file.Idx) {
-	idx0 = self.expect(token.LEFT_PARENTHESIS)
-	if self.token != token.RIGHT_PARENTHESIS {
-		for {
-			comments := self.findComments(false)
-			exp := self.parseAssignmentExpression()
-			if self.mode&StoreComments != 0 {
-				self.commentMap.AddComments(exp, comments, ast.LEADING)
-			}
-			argumentList = append(argumentList, exp)
-			if self.token != token.COMMA {
-				break
-			}
-			self.next()
-		}
-	}
-	idx1 = self.expect(token.RIGHT_PARENTHESIS)
-	return
-}
-
-func (self *_parser) parseCallExpression(left ast.Expression) ast.Expression {
-	argumentList, idx0, idx1 := self.parseArgumentList()
-	exp := &ast.CallExpression{
-		Callee:           left,
-		LeftParenthesis:  idx0,
-		ArgumentList:     argumentList,
-		RightParenthesis: idx1,
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(exp, self.findComments(false), ast.TRAILING)
-	}
-	return exp
-}
-
-func (self *_parser) parseDotMember(left ast.Expression) ast.Expression {
-	period := self.expect(token.PERIOD)
-
-	literal := self.literal
-	idx := self.idx
-
-	if !matchIdentifier.MatchString(literal) {
-		self.expect(token.IDENTIFIER)
-		self.nextStatement()
-		return &ast.BadExpression{From: period, To: self.idx}
-	}
-
-	self.next()
-
-	return &ast.DotExpression{
-		Left: left,
-		Identifier: ast.Identifier{
-			Idx:  idx,
-			Name: literal,
-		},
-	}
-}
-
-func (self *_parser) parseBracketMember(left ast.Expression) ast.Expression {
-	idx0 := self.expect(token.LEFT_BRACKET)
-	member := self.parseExpression()
-	idx1 := self.expect(token.RIGHT_BRACKET)
-	return &ast.BracketExpression{
-		LeftBracket:  idx0,
-		Left:         left,
-		Member:       member,
-		RightBracket: idx1,
-	}
-}
-
-func (self *_parser) parseNewExpression() ast.Expression {
-	idx := self.expect(token.NEW)
-	callee := self.parseLeftHandSideExpression()
-	node := &ast.NewExpression{
-		New:    idx,
-		Callee: callee,
-	}
-	if self.token == token.LEFT_PARENTHESIS {
-		argumentList, idx0, idx1 := self.parseArgumentList()
-		node.ArgumentList = argumentList
-		node.LeftParenthesis = idx0
-		node.RightParenthesis = idx1
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, self.findComments(false), ast.TRAILING)
-	}
-
-	return node
-}
-
-func (self *_parser) parseLeftHandSideExpression() ast.Expression {
-
-	var left ast.Expression
-	if self.token == token.NEW {
-		left = self.parseNewExpression()
-	} else {
-		left = self.parsePrimaryExpression()
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(left, self.findComments(false), ast.TRAILING)
-	}
-
-	for {
-		if self.token == token.PERIOD {
-			left = self.parseDotMember(left)
-		} else if self.token == token.LEFT_BRACKET {
-			left = self.parseBracketMember(left)
-		} else {
-			break
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseLeftHandSideExpressionAllowCall() ast.Expression {
-
-	allowIn := self.scope.allowIn
-	self.scope.allowIn = true
-	defer func() {
-		self.scope.allowIn = allowIn
-	}()
-
-	var left ast.Expression
-	if self.token == token.NEW {
-		left = self.parseNewExpression()
-	} else {
-		left = self.parsePrimaryExpression()
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(left, self.findComments(false), ast.TRAILING)
-	}
-
-	for {
-		if self.token == token.PERIOD {
-			left = self.parseDotMember(left)
-		} else if self.token == token.LEFT_BRACKET {
-			left = self.parseBracketMember(left)
-		} else if self.token == token.LEFT_PARENTHESIS {
-			left = self.parseCallExpression(left)
-		} else {
-			break
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parsePostfixExpression() ast.Expression {
-	operand := self.parseLeftHandSideExpressionAllowCall()
-
-	switch self.token {
-	case token.INCREMENT, token.DECREMENT:
-		// Make sure there is no line terminator here
-		if self.implicitSemicolon {
-			break
-		}
-		tkn := self.token
-		idx := self.idx
-		self.next()
-		switch operand.(type) {
-		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
-		default:
-			self.error(idx, "Invalid left-hand side in assignment")
-			self.nextStatement()
-			return &ast.BadExpression{From: idx, To: self.idx}
-		}
-		exp := &ast.UnaryExpression{
-			Operator: tkn,
-			Idx:      idx,
-			Operand:  operand,
-			Postfix:  true,
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp, self.findComments(false), ast.TRAILING)
-		}
-
-		return exp
-	}
-
-	return operand
-}
-
-func (self *_parser) parseUnaryExpression() ast.Expression {
-
-	switch self.token {
-	case token.PLUS, token.MINUS, token.NOT, token.BITWISE_NOT:
-		fallthrough
-	case token.DELETE, token.VOID, token.TYPEOF:
-		tkn := self.token
-		idx := self.idx
-		self.next()
-
-		comments := self.findComments(false)
-
-		exp := &ast.UnaryExpression{
-			Operator: tkn,
-			Idx:      idx,
-			Operand:  self.parseUnaryExpression(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Operand, comments, ast.LEADING)
-		}
-		return exp
-	case token.INCREMENT, token.DECREMENT:
-		tkn := self.token
-		idx := self.idx
-		self.next()
-
-		comments := self.findComments(false)
-
-		operand := self.parseUnaryExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(operand, comments, ast.LEADING)
-		}
-		switch operand.(type) {
-		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
-		default:
-			self.error(idx, "Invalid left-hand side in assignment")
-			self.nextStatement()
-			return &ast.BadExpression{From: idx, To: self.idx}
-		}
-		return &ast.UnaryExpression{
-			Operator: tkn,
-			Idx:      idx,
-			Operand:  operand,
-		}
-	}
-
-	return self.parsePostfixExpression()
-}
-
-func (self *_parser) parseMultiplicativeExpression() ast.Expression {
-	next := self.parseUnaryExpression
-	left := next()
-
-	for self.token == token.MULTIPLY || self.token == token.SLASH ||
-		self.token == token.REMAINDER {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseAdditiveExpression() ast.Expression {
-	next := self.parseMultiplicativeExpression
-	left := next()
-
-	for self.token == token.PLUS || self.token == token.MINUS {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseShiftExpression() ast.Expression {
-	next := self.parseAdditiveExpression
-	left := next()
-
-	for self.token == token.SHIFT_LEFT || self.token == token.SHIFT_RIGHT ||
-		self.token == token.UNSIGNED_SHIFT_RIGHT {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseRelationalExpression() ast.Expression {
-	next := self.parseShiftExpression
-	left := next()
-
-	allowIn := self.scope.allowIn
-	self.scope.allowIn = true
-	defer func() {
-		self.scope.allowIn = allowIn
-	}()
-
-	switch self.token {
-	case token.LESS, token.LESS_OR_EQUAL, token.GREATER, token.GREATER_OR_EQUAL:
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		exp := &ast.BinaryExpression{
-			Operator:   tkn,
-			Left:       left,
-			Right:      self.parseRelationalExpression(),
-			Comparison: true,
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Right, comments, ast.LEADING)
-		}
-		return exp
-	case token.INSTANCEOF:
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		exp := &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    self.parseRelationalExpression(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Right, comments, ast.LEADING)
-		}
-		return exp
-	case token.IN:
-		if !allowIn {
-			return left
-		}
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		exp := &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    self.parseRelationalExpression(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Right, comments, ast.LEADING)
-		}
-		return exp
-	}
-
-	return left
-}
-
-func (self *_parser) parseEqualityExpression() ast.Expression {
-	next := self.parseRelationalExpression
-	left := next()
-
-	for self.token == token.EQUAL || self.token == token.NOT_EQUAL ||
-		self.token == token.STRICT_EQUAL || self.token == token.STRICT_NOT_EQUAL {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator:   tkn,
-			Left:       left,
-			Right:      next(),
-			Comparison: true,
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseBitwiseAndExpression() ast.Expression {
-	next := self.parseEqualityExpression
-	left := next()
-
-	for self.token == token.AND {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseBitwiseExclusiveOrExpression() ast.Expression {
-	next := self.parseBitwiseAndExpression
-	left := next()
-
-	for self.token == token.EXCLUSIVE_OR {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseBitwiseOrExpression() ast.Expression {
-	next := self.parseBitwiseExclusiveOrExpression
-	left := next()
-
-	for self.token == token.OR {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseLogicalAndExpression() ast.Expression {
-	next := self.parseBitwiseOrExpression
-	left := next()
-
-	for self.token == token.LOGICAL_AND {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseLogicalOrExpression() ast.Expression {
-	next := self.parseLogicalAndExpression
-	left := next()
-
-	for self.token == token.LOGICAL_OR {
-		tkn := self.token
-		self.next()
-
-		comments := self.findComments(false)
-
-		left = &ast.BinaryExpression{
-			Operator: tkn,
-			Left:     left,
-			Right:    next(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left.(*ast.BinaryExpression).Right, comments, ast.LEADING)
-		}
-	}
-
-	return left
-}
-
-func (self *_parser) parseConditionlExpression() ast.Expression {
-	left := self.parseLogicalOrExpression()
-
-	if self.token == token.QUESTION_MARK {
-		self.next()
-
-		// Comments before the consequence
-		comments1 := self.findComments(false)
-
-		consequent := self.parseAssignmentExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(consequent, comments1, ast.LEADING)
-		}
-
-		self.expect(token.COLON)
-
-		// Comments before the alternate
-		comments2 := self.findComments(false)
-		exp := &ast.ConditionalExpression{
-			Test:       left,
-			Consequent: consequent,
-			Alternate:  self.parseAssignmentExpression(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Alternate, comments2, ast.LEADING)
-		}
-		return exp
-	}
-
-	return left
-}
-
-func (self *_parser) parseAssignmentExpression() ast.Expression {
-	left := self.parseConditionlExpression()
-	var operator token.Token
-	switch self.token {
-	case token.ASSIGN:
-		operator = self.token
-	case token.ADD_ASSIGN:
-		operator = token.PLUS
-	case token.SUBTRACT_ASSIGN:
-		operator = token.MINUS
-	case token.MULTIPLY_ASSIGN:
-		operator = token.MULTIPLY
-	case token.QUOTIENT_ASSIGN:
-		operator = token.SLASH
-	case token.REMAINDER_ASSIGN:
-		operator = token.REMAINDER
-	case token.AND_ASSIGN:
-		operator = token.AND
-	case token.AND_NOT_ASSIGN:
-		operator = token.AND_NOT
-	case token.OR_ASSIGN:
-		operator = token.OR
-	case token.EXCLUSIVE_OR_ASSIGN:
-		operator = token.EXCLUSIVE_OR
-	case token.SHIFT_LEFT_ASSIGN:
-		operator = token.SHIFT_LEFT
-	case token.SHIFT_RIGHT_ASSIGN:
-		operator = token.SHIFT_RIGHT
-	case token.UNSIGNED_SHIFT_RIGHT_ASSIGN:
-		operator = token.UNSIGNED_SHIFT_RIGHT
-	}
-
-	if operator != 0 {
-		idx := self.idx
-		self.next()
-		switch left.(type) {
-		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
-		default:
-			self.error(left.Idx0(), "Invalid left-hand side in assignment")
-			self.nextStatement()
-			return &ast.BadExpression{From: idx, To: self.idx}
-		}
-
-		comments := self.findComments(false)
-
-		exp := &ast.AssignExpression{
-			Left:     left,
-			Operator: operator,
-			Right:    self.parseAssignmentExpression(),
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp.Right, comments, ast.LEADING)
-		}
-
-		return exp
-	}
-
-	return left
-}
-
-func (self *_parser) parseExpression() ast.Expression {
-
-	comments := self.findComments(false)
-	statementComments := self.fetchComments()
-
-	next := self.parseAssignmentExpression
-	left := next()
-
-	if self.token == token.COMMA {
-		sequence := []ast.Expression{left}
-		for {
-			if self.token != token.COMMA {
-				break
-			}
-			self.next()
-			sequence = append(sequence, next())
-		}
-		return &ast.SequenceExpression{
-			Sequence: sequence,
-		}
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(left, comments, ast.LEADING)
-		self.commentMap.AddComments(left, statementComments, ast.LEADING)
-	}
-
-	return left
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/lexer.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/lexer.go
deleted file mode 100644
index a510c76d2..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/lexer.go
+++ /dev/null
@@ -1,866 +0,0 @@
-package parser
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-type _chr struct {
-	value rune
-	width int
-}
-
-var matchIdentifier = regexp.MustCompile(`^[$_\p{L}][$_\p{L}\d}]*$`)
-
-func isDecimalDigit(chr rune) bool {
-	return '0' <= chr && chr <= '9'
-}
-
-func digitValue(chr rune) int {
-	switch {
-	case '0' <= chr && chr <= '9':
-		return int(chr - '0')
-	case 'a' <= chr && chr <= 'f':
-		return int(chr - 'a' + 10)
-	case 'A' <= chr && chr <= 'F':
-		return int(chr - 'A' + 10)
-	}
-	return 16 // Larger than any legal digit value
-}
-
-func isDigit(chr rune, base int) bool {
-	return digitValue(chr) < base
-}
-
-func isIdentifierStart(chr rune) bool {
-	return chr == '$' || chr == '_' || chr == '\\' ||
-		'a' <= chr && chr <= 'z' || 'A' <= chr && chr <= 'Z' ||
-		chr >= utf8.RuneSelf && unicode.IsLetter(chr)
-}
-
-func isIdentifierPart(chr rune) bool {
-	return chr == '$' || chr == '_' || chr == '\\' ||
-		'a' <= chr && chr <= 'z' || 'A' <= chr && chr <= 'Z' ||
-		'0' <= chr && chr <= '9' ||
-		chr >= utf8.RuneSelf && (unicode.IsLetter(chr) || unicode.IsDigit(chr))
-}
-
-func (self *_parser) scanIdentifier() (string, error) {
-	offset := self.chrOffset
-	parse := false
-	for isIdentifierPart(self.chr) {
-		if self.chr == '\\' {
-			distance := self.chrOffset - offset
-			self.read()
-			if self.chr != 'u' {
-				return "", fmt.Errorf("Invalid identifier escape character: %c (%s)", self.chr, string(self.chr))
-			}
-			parse = true
-			var value rune
-			for j := 0; j < 4; j++ {
-				self.read()
-				decimal, ok := hex2decimal(byte(self.chr))
-				if !ok {
-					return "", fmt.Errorf("Invalid identifier escape character: %c (%s)", self.chr, string(self.chr))
-				}
-				value = value<<4 | decimal
-			}
-			if value == '\\' {
-				return "", fmt.Errorf("Invalid identifier escape value: %c (%s)", value, string(value))
-			} else if distance == 0 {
-				if !isIdentifierStart(value) {
-					return "", fmt.Errorf("Invalid identifier escape value: %c (%s)", value, string(value))
-				}
-			} else if distance > 0 {
-				if !isIdentifierPart(value) {
-					return "", fmt.Errorf("Invalid identifier escape value: %c (%s)", value, string(value))
-				}
-			}
-		}
-		self.read()
-	}
-	literal := string(self.str[offset:self.chrOffset])
-	if parse {
-		return parseStringLiteral(literal)
-	}
-	return literal, nil
-}
-
-// 7.2
-func isLineWhiteSpace(chr rune) bool {
-	switch chr {
-	case '\u0009', '\u000b', '\u000c', '\u0020', '\u00a0', '\ufeff':
-		return true
-	case '\u000a', '\u000d', '\u2028', '\u2029':
-		return false
-	case '\u0085':
-		return false
-	}
-	return unicode.IsSpace(chr)
-}
-
-// 7.3
-func isLineTerminator(chr rune) bool {
-	switch chr {
-	case '\u000a', '\u000d', '\u2028', '\u2029':
-		return true
-	}
-	return false
-}
-
-func (self *_parser) scan() (tkn token.Token, literal string, idx file.Idx) {
-
-	self.implicitSemicolon = false
-	self.skippedLineBreak = false
-
-	for {
-		self.skipWhiteSpace()
-
-		idx = self.idxOf(self.chrOffset)
-		insertSemicolon := false
-
-		switch chr := self.chr; {
-		case isIdentifierStart(chr):
-			var err error
-			literal, err = self.scanIdentifier()
-			if err != nil {
-				tkn = token.ILLEGAL
-				break
-			}
-			if len(literal) > 1 {
-				// Keywords are longer than 1 character, avoid lookup otherwise
-				var strict bool
-				tkn, strict = token.IsKeyword(literal)
-
-				switch tkn {
-
-				case 0: // Not a keyword
-					if literal == "true" || literal == "false" {
-						self.insertSemicolon = true
-						tkn = token.BOOLEAN
-						return
-					} else if literal == "null" {
-						self.insertSemicolon = true
-						tkn = token.NULL
-						return
-					}
-
-				case token.KEYWORD:
-					tkn = token.KEYWORD
-					if strict {
-						// TODO If strict and in strict mode, then this is not a break
-						break
-					}
-					return
-
-				case
-					token.THIS,
-					token.BREAK,
-					token.THROW, // A newline after a throw is not allowed, but we need to detect it
-					token.RETURN,
-					token.CONTINUE,
-					token.DEBUGGER:
-					self.insertSemicolon = true
-					return
-
-				default:
-					return
-
-				}
-			}
-			self.insertSemicolon = true
-			tkn = token.IDENTIFIER
-			return
-		case '0' <= chr && chr <= '9':
-			self.insertSemicolon = true
-			tkn, literal = self.scanNumericLiteral(false)
-			return
-		default:
-			self.read()
-			switch chr {
-			case -1:
-				if self.insertSemicolon {
-					self.insertSemicolon = false
-					self.implicitSemicolon = true
-				}
-				tkn = token.EOF
-			case '\r', '\n', '\u2028', '\u2029':
-				self.insertSemicolon = false
-				self.implicitSemicolon = true
-				continue
-			case ':':
-				tkn = token.COLON
-			case '.':
-				if digitValue(self.chr) < 10 {
-					insertSemicolon = true
-					tkn, literal = self.scanNumericLiteral(true)
-				} else {
-					tkn = token.PERIOD
-				}
-			case ',':
-				tkn = token.COMMA
-			case ';':
-				tkn = token.SEMICOLON
-			case '(':
-				tkn = token.LEFT_PARENTHESIS
-			case ')':
-				tkn = token.RIGHT_PARENTHESIS
-				insertSemicolon = true
-			case '[':
-				tkn = token.LEFT_BRACKET
-			case ']':
-				tkn = token.RIGHT_BRACKET
-				insertSemicolon = true
-			case '{':
-				tkn = token.LEFT_BRACE
-			case '}':
-				tkn = token.RIGHT_BRACE
-				insertSemicolon = true
-			case '+':
-				tkn = self.switch3(token.PLUS, token.ADD_ASSIGN, '+', token.INCREMENT)
-				if tkn == token.INCREMENT {
-					insertSemicolon = true
-				}
-			case '-':
-				tkn = self.switch3(token.MINUS, token.SUBTRACT_ASSIGN, '-', token.DECREMENT)
-				if tkn == token.DECREMENT {
-					insertSemicolon = true
-				}
-			case '*':
-				tkn = self.switch2(token.MULTIPLY, token.MULTIPLY_ASSIGN)
-			case '/':
-				if self.chr == '/' {
-					if self.mode&StoreComments != 0 {
-						runes := self.readSingleLineComment()
-						literal = string(runes)
-						tkn = token.COMMENT
-						return
-					}
-					self.skipSingleLineComment()
-					continue
-				} else if self.chr == '*' {
-					if self.mode&StoreComments != 0 {
-						literal = string(self.readMultiLineComment())
-						tkn = token.COMMENT
-						return
-					}
-					self.skipMultiLineComment()
-					continue
-				} else {
-					// Could be division, could be RegExp literal
-					tkn = self.switch2(token.SLASH, token.QUOTIENT_ASSIGN)
-					insertSemicolon = true
-				}
-			case '%':
-				tkn = self.switch2(token.REMAINDER, token.REMAINDER_ASSIGN)
-			case '^':
-				tkn = self.switch2(token.EXCLUSIVE_OR, token.EXCLUSIVE_OR_ASSIGN)
-			case '<':
-				tkn = self.switch4(token.LESS, token.LESS_OR_EQUAL, '<', token.SHIFT_LEFT, token.SHIFT_LEFT_ASSIGN)
-			case '>':
-				tkn = self.switch6(token.GREATER, token.GREATER_OR_EQUAL, '>', token.SHIFT_RIGHT, token.SHIFT_RIGHT_ASSIGN, '>', token.UNSIGNED_SHIFT_RIGHT, token.UNSIGNED_SHIFT_RIGHT_ASSIGN)
-			case '=':
-				tkn = self.switch2(token.ASSIGN, token.EQUAL)
-				if tkn == token.EQUAL && self.chr == '=' {
-					self.read()
-					tkn = token.STRICT_EQUAL
-				}
-			case '!':
-				tkn = self.switch2(token.NOT, token.NOT_EQUAL)
-				if tkn == token.NOT_EQUAL && self.chr == '=' {
-					self.read()
-					tkn = token.STRICT_NOT_EQUAL
-				}
-			case '&':
-				if self.chr == '^' {
-					self.read()
-					tkn = self.switch2(token.AND_NOT, token.AND_NOT_ASSIGN)
-				} else {
-					tkn = self.switch3(token.AND, token.AND_ASSIGN, '&', token.LOGICAL_AND)
-				}
-			case '|':
-				tkn = self.switch3(token.OR, token.OR_ASSIGN, '|', token.LOGICAL_OR)
-			case '~':
-				tkn = token.BITWISE_NOT
-			case '?':
-				tkn = token.QUESTION_MARK
-			case '"', '\'':
-				insertSemicolon = true
-				tkn = token.STRING
-				var err error
-				literal, err = self.scanString(self.chrOffset - 1)
-				if err != nil {
-					tkn = token.ILLEGAL
-				}
-			default:
-				self.errorUnexpected(idx, chr)
-				tkn = token.ILLEGAL
-			}
-		}
-		self.insertSemicolon = insertSemicolon
-		return
-	}
-}
-
-func (self *_parser) switch2(tkn0, tkn1 token.Token) token.Token {
-	if self.chr == '=' {
-		self.read()
-		return tkn1
-	}
-	return tkn0
-}
-
-func (self *_parser) switch3(tkn0, tkn1 token.Token, chr2 rune, tkn2 token.Token) token.Token {
-	if self.chr == '=' {
-		self.read()
-		return tkn1
-	}
-	if self.chr == chr2 {
-		self.read()
-		return tkn2
-	}
-	return tkn0
-}
-
-func (self *_parser) switch4(tkn0, tkn1 token.Token, chr2 rune, tkn2, tkn3 token.Token) token.Token {
-	if self.chr == '=' {
-		self.read()
-		return tkn1
-	}
-	if self.chr == chr2 {
-		self.read()
-		if self.chr == '=' {
-			self.read()
-			return tkn3
-		}
-		return tkn2
-	}
-	return tkn0
-}
-
-func (self *_parser) switch6(tkn0, tkn1 token.Token, chr2 rune, tkn2, tkn3 token.Token, chr3 rune, tkn4, tkn5 token.Token) token.Token {
-	if self.chr == '=' {
-		self.read()
-		return tkn1
-	}
-	if self.chr == chr2 {
-		self.read()
-		if self.chr == '=' {
-			self.read()
-			return tkn3
-		}
-		if self.chr == chr3 {
-			self.read()
-			if self.chr == '=' {
-				self.read()
-				return tkn5
-			}
-			return tkn4
-		}
-		return tkn2
-	}
-	return tkn0
-}
-
-func (self *_parser) chrAt(index int) _chr {
-	value, width := utf8.DecodeRuneInString(self.str[index:])
-	return _chr{
-		value: value,
-		width: width,
-	}
-}
-
-func (self *_parser) _peek() rune {
-	if self.offset+1 < self.length {
-		return rune(self.str[self.offset+1])
-	}
-	return -1
-}
-
-func (self *_parser) read() {
-	if self.offset < self.length {
-		self.chrOffset = self.offset
-		chr, width := rune(self.str[self.offset]), 1
-		if chr >= utf8.RuneSelf { // !ASCII
-			chr, width = utf8.DecodeRuneInString(self.str[self.offset:])
-			if chr == utf8.RuneError && width == 1 {
-				self.error(self.chrOffset, "Invalid UTF-8 character")
-			}
-		}
-		self.offset += width
-		self.chr = chr
-	} else {
-		self.chrOffset = self.length
-		self.chr = -1 // EOF
-	}
-}
-
-// This is here since the functions are so similar
-func (self *_RegExp_parser) read() {
-	if self.offset < self.length {
-		self.chrOffset = self.offset
-		chr, width := rune(self.str[self.offset]), 1
-		if chr >= utf8.RuneSelf { // !ASCII
-			chr, width = utf8.DecodeRuneInString(self.str[self.offset:])
-			if chr == utf8.RuneError && width == 1 {
-				self.error(self.chrOffset, "Invalid UTF-8 character")
-			}
-		}
-		self.offset += width
-		self.chr = chr
-	} else {
-		self.chrOffset = self.length
-		self.chr = -1 // EOF
-	}
-}
-
-func (self *_parser) readSingleLineComment() (result []rune) {
-	for self.chr != -1 {
-		self.read()
-		if isLineTerminator(self.chr) {
-			return
-		}
-		result = append(result, self.chr)
-	}
-
-	// Get rid of the trailing -1
-	result = result[:len(result)-1]
-
-	return
-}
-
-func (self *_parser) readMultiLineComment() (result []rune) {
-	self.read()
-	for self.chr >= 0 {
-		chr := self.chr
-		self.read()
-		if chr == '*' && self.chr == '/' {
-			self.read()
-			return
-		}
-
-		result = append(result, chr)
-	}
-
-	self.errorUnexpected(0, self.chr)
-
-	return
-}
-
-func (self *_parser) skipSingleLineComment() {
-	for self.chr != -1 {
-		self.read()
-		if isLineTerminator(self.chr) {
-			return
-		}
-	}
-}
-
-func (self *_parser) skipMultiLineComment() {
-	self.read()
-	for self.chr >= 0 {
-		chr := self.chr
-		self.read()
-		if chr == '*' && self.chr == '/' {
-			self.read()
-			return
-		}
-	}
-
-	self.errorUnexpected(0, self.chr)
-}
-
-func (self *_parser) skipWhiteSpace() {
-	for {
-		switch self.chr {
-		case ' ', '\t', '\f', '\v', '\u00a0', '\ufeff':
-			self.read()
-			continue
-		case '\r':
-			if self._peek() == '\n' {
-				self.skippedLineBreak = true
-				self.read()
-			}
-			fallthrough
-		case '\u2028', '\u2029', '\n':
-			if self.insertSemicolon {
-				return
-			}
-			self.skippedLineBreak = true
-			self.read()
-			continue
-		}
-		if self.chr >= utf8.RuneSelf {
-			if unicode.IsSpace(self.chr) {
-				self.read()
-				continue
-			}
-		}
-		break
-	}
-}
-
-func (self *_parser) skipLineWhiteSpace() {
-	for isLineWhiteSpace(self.chr) {
-		self.read()
-	}
-}
-
-func (self *_parser) scanMantissa(base int) {
-	for digitValue(self.chr) < base {
-		self.read()
-	}
-}
-
-func (self *_parser) scanEscape(quote rune) {
-
-	var length, base uint32
-	switch self.chr {
-	//case '0', '1', '2', '3', '4', '5', '6', '7':
-	//    Octal:
-	//    length, base, limit = 3, 8, 255
-	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '"', '\'', '0':
-		self.read()
-		return
-	case '\r', '\n', '\u2028', '\u2029':
-		self.scanNewline()
-		return
-	case 'x':
-		self.read()
-		length, base = 2, 16
-	case 'u':
-		self.read()
-		length, base = 4, 16
-	default:
-		self.read() // Always make progress
-		return
-	}
-
-	var value uint32
-	for ; length > 0 && self.chr != quote && self.chr >= 0; length-- {
-		digit := uint32(digitValue(self.chr))
-		if digit >= base {
-			break
-		}
-		value = value*base + digit
-		self.read()
-	}
-}
-
-func (self *_parser) scanString(offset int) (string, error) {
-	// " ' /
-	quote := rune(self.str[offset])
-
-	for self.chr != quote {
-		chr := self.chr
-		if chr == '\n' || chr == '\r' || chr == '\u2028' || chr == '\u2029' || chr < 0 {
-			goto newline
-		}
-		self.read()
-		if chr == '\\' {
-			if quote == '/' {
-				if self.chr == '\n' || self.chr == '\r' || self.chr == '\u2028' || self.chr == '\u2029' || self.chr < 0 {
-					goto newline
-				}
-				self.read()
-			} else {
-				self.scanEscape(quote)
-			}
-		} else if chr == '[' && quote == '/' {
-			// Allow a slash (/) in a bracket character class ([...])
-			// TODO Fix this, this is hacky...
-			quote = -1
-		} else if chr == ']' && quote == -1 {
-			quote = '/'
-		}
-	}
-
-	// " ' /
-	self.read()
-
-	return string(self.str[offset:self.chrOffset]), nil
-
-newline:
-	self.scanNewline()
-	err := "String not terminated"
-	if quote == '/' {
-		err = "Invalid regular expression: missing /"
-		self.error(self.idxOf(offset), err)
-	}
-	return "", errors.New(err)
-}
-
-func (self *_parser) scanNewline() {
-	if self.chr == '\r' {
-		self.read()
-		if self.chr != '\n' {
-			return
-		}
-	}
-	self.read()
-}
-
-func hex2decimal(chr byte) (value rune, ok bool) {
-	{
-		chr := rune(chr)
-		switch {
-		case '0' <= chr && chr <= '9':
-			return chr - '0', true
-		case 'a' <= chr && chr <= 'f':
-			return chr - 'a' + 10, true
-		case 'A' <= chr && chr <= 'F':
-			return chr - 'A' + 10, true
-		}
-		return
-	}
-}
-
-func parseNumberLiteral(literal string) (value interface{}, err error) {
-	// TODO Is Uint okay? What about -MAX_UINT
-	value, err = strconv.ParseInt(literal, 0, 64)
-	if err == nil {
-		return
-	}
-
-	parseIntErr := err // Save this first error, just in case
-
-	value, err = strconv.ParseFloat(literal, 64)
-	if err == nil {
-		return
-	} else if err.(*strconv.NumError).Err == strconv.ErrRange {
-		// Infinity, etc.
-		return value, nil
-	}
-
-	err = parseIntErr
-
-	if err.(*strconv.NumError).Err == strconv.ErrRange {
-		if len(literal) > 2 && literal[0] == '0' && (literal[1] == 'X' || literal[1] == 'x') {
-			// Could just be a very large number (e.g. 0x8000000000000000)
-			var value float64
-			literal = literal[2:]
-			for _, chr := range literal {
-				digit := digitValue(chr)
-				if digit >= 16 {
-					goto error
-				}
-				value = value*16 + float64(digit)
-			}
-			return value, nil
-		}
-	}
-
-error:
-	return nil, errors.New("Illegal numeric literal")
-}
-
-func parseStringLiteral(literal string) (string, error) {
-	// Best case scenario...
-	if literal == "" {
-		return "", nil
-	}
-
-	// Slightly less-best case scenario...
-	if !strings.ContainsRune(literal, '\\') {
-		return literal, nil
-	}
-
-	str := literal
-	buffer := bytes.NewBuffer(make([]byte, 0, 3*len(literal)/2))
-
-	for len(str) > 0 {
-		switch chr := str[0]; {
-		// We do not explicitly handle the case of the quote
-		// value, which can be: " ' /
-		// This assumes we're already passed a partially well-formed literal
-		case chr >= utf8.RuneSelf:
-			chr, size := utf8.DecodeRuneInString(str)
-			buffer.WriteRune(chr)
-			str = str[size:]
-			continue
-		case chr != '\\':
-			buffer.WriteByte(chr)
-			str = str[1:]
-			continue
-		}
-
-		if len(str) <= 1 {
-			panic("len(str) <= 1")
-		}
-		chr := str[1]
-		var value rune
-		if chr >= utf8.RuneSelf {
-			str = str[1:]
-			var size int
-			value, size = utf8.DecodeRuneInString(str)
-			str = str[size:] // \ + <character>
-		} else {
-			str = str[2:] // \<character>
-			switch chr {
-			case 'b':
-				value = '\b'
-			case 'f':
-				value = '\f'
-			case 'n':
-				value = '\n'
-			case 'r':
-				value = '\r'
-			case 't':
-				value = '\t'
-			case 'v':
-				value = '\v'
-			case 'x', 'u':
-				size := 0
-				switch chr {
-				case 'x':
-					size = 2
-				case 'u':
-					size = 4
-				}
-				if len(str) < size {
-					return "", fmt.Errorf("invalid escape: \\%s: len(%q) != %d", string(chr), str, size)
-				}
-				for j := 0; j < size; j++ {
-					decimal, ok := hex2decimal(str[j])
-					if !ok {
-						return "", fmt.Errorf("invalid escape: \\%s: %q", string(chr), str[:size])
-					}
-					value = value<<4 | decimal
-				}
-				str = str[size:]
-				if chr == 'x' {
-					break
-				}
-				if value > utf8.MaxRune {
-					panic("value > utf8.MaxRune")
-				}
-			case '0':
-				if len(str) == 0 || '0' > str[0] || str[0] > '7' {
-					value = 0
-					break
-				}
-				fallthrough
-			case '1', '2', '3', '4', '5', '6', '7':
-				// TODO strict
-				value = rune(chr) - '0'
-				j := 0
-				for ; j < 2; j++ {
-					if len(str) < j+1 {
-						break
-					}
-					chr := str[j]
-					if '0' > chr || chr > '7' {
-						break
-					}
-					decimal := rune(str[j]) - '0'
-					value = (value << 3) | decimal
-				}
-				str = str[j:]
-			case '\\':
-				value = '\\'
-			case '\'', '"':
-				value = rune(chr)
-			case '\r':
-				if len(str) > 0 {
-					if str[0] == '\n' {
-						str = str[1:]
-					}
-				}
-				fallthrough
-			case '\n':
-				continue
-			default:
-				value = rune(chr)
-			}
-		}
-		buffer.WriteRune(value)
-	}
-
-	return buffer.String(), nil
-}
-
-func (self *_parser) scanNumericLiteral(decimalPoint bool) (token.Token, string) {
-
-	offset := self.chrOffset
-	tkn := token.NUMBER
-
-	if decimalPoint {
-		offset--
-		self.scanMantissa(10)
-		goto exponent
-	}
-
-	if self.chr == '0' {
-		offset := self.chrOffset
-		self.read()
-		if self.chr == 'x' || self.chr == 'X' {
-			// Hexadecimal
-			self.read()
-			if isDigit(self.chr, 16) {
-				self.read()
-			} else {
-				return token.ILLEGAL, self.str[offset:self.chrOffset]
-			}
-			self.scanMantissa(16)
-
-			if self.chrOffset-offset <= 2 {
-				// Only "0x" or "0X"
-				self.error(0, "Illegal hexadecimal number")
-			}
-
-			goto hexadecimal
-		} else if self.chr == '.' {
-			// Float
-			goto float
-		} else {
-			// Octal, Float
-			if self.chr == 'e' || self.chr == 'E' {
-				goto exponent
-			}
-			self.scanMantissa(8)
-			if self.chr == '8' || self.chr == '9' {
-				return token.ILLEGAL, self.str[offset:self.chrOffset]
-			}
-			goto octal
-		}
-	}
-
-	self.scanMantissa(10)
-
-float:
-	if self.chr == '.' {
-		self.read()
-		self.scanMantissa(10)
-	}
-
-exponent:
-	if self.chr == 'e' || self.chr == 'E' {
-		self.read()
-		if self.chr == '-' || self.chr == '+' {
-			self.read()
-		}
-		if isDecimalDigit(self.chr) {
-			self.read()
-			self.scanMantissa(10)
-		} else {
-			return token.ILLEGAL, self.str[offset:self.chrOffset]
-		}
-	}
-
-hexadecimal:
-octal:
-	if isIdentifierStart(self.chr) || isDecimalDigit(self.chr) {
-		return token.ILLEGAL, self.str[offset:self.chrOffset]
-	}
-
-	return tkn, self.str[offset:self.chrOffset]
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/parser.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/parser.go
deleted file mode 100644
index 18328edd6..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/parser.go
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
-Package parser implements a parser for JavaScript.
-
-    import (
-        "github.com/robertkrimen/otto/parser"
-    )
-
-Parse and return an AST
-
-    filename := "" // A filename is optional
-    src := `
-        // Sample xyzzy example
-        (function(){
-            if (3.14159 > 0) {
-                console.log("Hello, World.");
-                return;
-            }
-
-            var xyzzy = NaN;
-            console.log("Nothing happens.");
-            return xyzzy;
-        })();
-    `
-
-    // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-    program, err := parser.ParseFile(nil, filename, src, 0)
-
-Warning
-
-The parser and AST interfaces are still works-in-progress (particularly where
-node types are concerned) and may change in the future.
-
-*/
-package parser
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"io/ioutil"
-
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/file"
-	"github.com/robertkrimen/otto/token"
-)
-
-// A Mode value is a set of flags (or 0). They control optional parser functionality.
-type Mode uint
-
-const (
-	IgnoreRegExpErrors Mode = 1 << iota // Ignore RegExp compatibility errors (allow backtracking)
-	StoreComments                       // Store the comments from source to the comments map
-)
-
-type _parser struct {
-	str    string
-	length int
-	base   int
-
-	chr       rune // The current character
-	chrOffset int  // The offset of current character
-	offset    int  // The offset after current character (may be greater than 1)
-
-	idx     file.Idx    // The index of token
-	token   token.Token // The token
-	literal string      // The literal of the token, if any
-
-	scope             *_scope
-	insertSemicolon   bool // If we see a newline, then insert an implicit semicolon
-	implicitSemicolon bool // An implicit semicolon exists
-
-	errors ErrorList
-
-	recover struct {
-		// Scratch when trying to seek to the next statement, etc.
-		idx   file.Idx
-		count int
-	}
-
-	mode Mode
-
-	file *file.File
-
-	comments         []*ast.Comment
-	commentMap       *ast.CommentMap
-	skippedLineBreak bool
-}
-
-func _newParser(filename, src string, base int) *_parser {
-	return &_parser{
-		chr:              ' ', // This is set so we can start scanning by skipping whitespace
-		str:              src,
-		length:           len(src),
-		base:             base,
-		file:             file.NewFile(filename, src, base),
-		comments:         make([]*ast.Comment, 0),
-		commentMap:       &ast.CommentMap{},
-		skippedLineBreak: false,
-	}
-}
-
-func newParser(filename, src string) *_parser {
-	return _newParser(filename, src, 1)
-}
-
-func ReadSource(filename string, src interface{}) ([]byte, error) {
-	if src != nil {
-		switch src := src.(type) {
-		case string:
-			return []byte(src), nil
-		case []byte:
-			return src, nil
-		case *bytes.Buffer:
-			if src != nil {
-				return src.Bytes(), nil
-			}
-		case io.Reader:
-			var bfr bytes.Buffer
-			if _, err := io.Copy(&bfr, src); err != nil {
-				return nil, err
-			}
-			return bfr.Bytes(), nil
-		}
-		return nil, errors.New("invalid source")
-	}
-	return ioutil.ReadFile(filename)
-}
-
-// ParseFile parses the source code of a single JavaScript/ECMAScript source file and returns
-// the corresponding ast.Program node.
-//
-// If fileSet == nil, ParseFile parses source without a FileSet.
-// If fileSet != nil, ParseFile first adds filename and src to fileSet.
-//
-// The filename argument is optional and is used for labelling errors, etc.
-//
-// src may be a string, a byte slice, a bytes.Buffer, or an io.Reader, but it MUST always be in UTF-8.
-//
-//      // Parse some JavaScript, yielding a *ast.Program and/or an ErrorList
-//      program, err := parser.ParseFile(nil, "", `if (abc > 1) {}`, 0)
-//
-func ParseFile(fileSet *file.FileSet, filename string, src interface{}, mode Mode) (*ast.Program, error) {
-	str, err := ReadSource(filename, src)
-	if err != nil {
-		return nil, err
-	}
-	{
-		str := string(str)
-
-		base := 1
-		if fileSet != nil {
-			base = fileSet.AddFile(filename, str)
-		}
-
-		parser := _newParser(filename, str, base)
-		parser.mode = mode
-		return parser.parse()
-	}
-}
-
-// ParseFunction parses a given parameter list and body as a function and returns the
-// corresponding ast.FunctionLiteral node.
-//
-// The parameter list, if any, should be a comma-separated list of identifiers.
-//
-func ParseFunction(parameterList, body string) (*ast.FunctionLiteral, error) {
-
-	src := "(function(" + parameterList + ") {\n" + body + "\n})"
-
-	parser := _newParser("", src, 1)
-	program, err := parser.parse()
-	if err != nil {
-		return nil, err
-	}
-
-	return program.Body[0].(*ast.ExpressionStatement).Expression.(*ast.FunctionLiteral), nil
-}
-
-func (self *_parser) slice(idx0, idx1 file.Idx) string {
-	from := int(idx0) - self.base
-	to := int(idx1) - self.base
-	if from >= 0 && to <= len(self.str) {
-		return self.str[from:to]
-	}
-
-	return ""
-}
-
-func (self *_parser) parse() (*ast.Program, error) {
-	self.next()
-	program := self.parseProgram()
-	if false {
-		self.errors.Sort()
-	}
-
-	self.addCommentStatements(program, ast.FINAL)
-
-	return program, self.errors.Err()
-}
-
-func (self *_parser) next() {
-	self.token, self.literal, self.idx = self.scan()
-}
-
-func (self *_parser) optionalSemicolon() {
-	if self.token == token.SEMICOLON {
-		self.next()
-		return
-	}
-
-	if self.implicitSemicolon {
-		self.implicitSemicolon = false
-		return
-	}
-
-	if self.token != token.EOF && self.token != token.RIGHT_BRACE {
-		self.expect(token.SEMICOLON)
-	}
-}
-
-func (self *_parser) semicolon() {
-	if self.token != token.RIGHT_PARENTHESIS && self.token != token.RIGHT_BRACE {
-		if self.implicitSemicolon {
-			self.implicitSemicolon = false
-			return
-		}
-
-		self.expect(token.SEMICOLON)
-	}
-}
-
-func (self *_parser) idxOf(offset int) file.Idx {
-	return file.Idx(self.base + offset)
-}
-
-func (self *_parser) expect(value token.Token) file.Idx {
-	idx := self.idx
-	if self.token != value {
-		self.errorUnexpectedToken(self.token)
-	}
-	self.next()
-	return idx
-}
-
-func lineCount(str string) (int, int) {
-	line, last := 0, -1
-	pair := false
-	for index, chr := range str {
-		switch chr {
-		case '\r':
-			line += 1
-			last = index
-			pair = true
-			continue
-		case '\n':
-			if !pair {
-				line += 1
-			}
-			last = index
-		case '\u2028', '\u2029':
-			line += 1
-			last = index + 2
-		}
-		pair = false
-	}
-	return line, last
-}
-
-func (self *_parser) position(idx file.Idx) file.Position {
-	position := file.Position{}
-	offset := int(idx) - self.base
-	str := self.str[:offset]
-	position.Filename = self.file.Name()
-	line, last := lineCount(str)
-	position.Line = 1 + line
-	if last >= 0 {
-		position.Column = offset - last
-	} else {
-		position.Column = 1 + len(str)
-	}
-
-	return position
-}
-
-// findComments finds the following comments.
-// Comments on the same line will be grouped together and returned.
-// After the first line break, comments will be added as statement comments.
-func (self *_parser) findComments(ignoreLineBreak bool) []*ast.Comment {
-	if self.mode&StoreComments == 0 {
-		return nil
-	}
-	comments := make([]*ast.Comment, 0)
-
-	newline := false
-
-	for self.implicitSemicolon == false || ignoreLineBreak {
-		if self.token != token.COMMENT {
-			break
-		}
-
-		comment := &ast.Comment{
-			Begin:    self.idx,
-			Text:     self.literal,
-			Position: ast.TBD,
-		}
-
-		newline = self.skippedLineBreak || newline
-
-		if newline && !ignoreLineBreak {
-			self.comments = append(self.comments, comment)
-		} else {
-			comments = append(comments, comment)
-		}
-
-		self.next()
-	}
-
-	return comments
-}
-
-// addCommentStatements will add the previously parsed, not positioned comments to the provided node
-func (self *_parser) addCommentStatements(node ast.Node, position ast.CommentPosition) {
-	if len(self.comments) > 0 {
-		self.commentMap.AddComments(node, self.comments, position)
-
-		// Reset comments
-		self.comments = make([]*ast.Comment, 0)
-	}
-}
-
-// fetchComments fetches the current comments, resets the slice and returns the comments
-func (self *_parser) fetchComments() (comments []*ast.Comment) {
-	comments = self.comments
-	self.comments = nil
-
-	return comments
-}
-
-// consumeComments consumes the current comments and appends them to the provided node
-func (self *_parser) consumeComments(node ast.Node, position ast.CommentPosition) {
-	self.commentMap.AddComments(node, self.comments, position)
-	self.comments = nil
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/regexp.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/regexp.go
deleted file mode 100644
index f614dae74..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/regexp.go
+++ /dev/null
@@ -1,358 +0,0 @@
-package parser
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-)
-
-type _RegExp_parser struct {
-	str    string
-	length int
-
-	chr       rune // The current character
-	chrOffset int  // The offset of current character
-	offset    int  // The offset after current character (may be greater than 1)
-
-	errors  []error
-	invalid bool // The input is an invalid JavaScript RegExp
-
-	goRegexp *bytes.Buffer
-}
-
-// TransformRegExp transforms a JavaScript pattern into  a Go "regexp" pattern.
-//
-// re2 (Go) cannot do backtracking, so the presence of a lookahead (?=) (?!) or
-// backreference (\1, \2, ...) will cause an error.
-//
-// re2 (Go) has a different definition for \s: [\t\n\f\r ].
-// The JavaScript definition, on the other hand, also includes \v, Unicode "Separator, Space", etc.
-//
-// If the pattern is invalid (not valid even in JavaScript), then this function
-// returns the empty string and an error.
-//
-// If the pattern is valid, but incompatible (contains a lookahead or backreference),
-// then this function returns the transformation (a non-empty string) AND an error.
-func TransformRegExp(pattern string) (string, error) {
-
-	if pattern == "" {
-		return "", nil
-	}
-
-	// TODO If without \, if without (?=, (?!, then another shortcut
-
-	parser := _RegExp_parser{
-		str:      pattern,
-		length:   len(pattern),
-		goRegexp: bytes.NewBuffer(make([]byte, 0, 3*len(pattern)/2)),
-	}
-	parser.read() // Pull in the first character
-	parser.scan()
-	var err error
-	if len(parser.errors) > 0 {
-		err = parser.errors[0]
-	}
-	if parser.invalid {
-		return "", err
-	}
-
-	// Might not be re2 compatible, but is still a valid JavaScript RegExp
-	return parser.goRegexp.String(), err
-}
-
-func (self *_RegExp_parser) scan() {
-	for self.chr != -1 {
-		switch self.chr {
-		case '\\':
-			self.read()
-			self.scanEscape(false)
-		case '(':
-			self.pass()
-			self.scanGroup()
-		case '[':
-			self.pass()
-			self.scanBracket()
-		case ')':
-			self.error(-1, "Unmatched ')'")
-			self.invalid = true
-			self.pass()
-		default:
-			self.pass()
-		}
-	}
-}
-
-// (...)
-func (self *_RegExp_parser) scanGroup() {
-	str := self.str[self.chrOffset:]
-	if len(str) > 1 { // A possibility of (?= or (?!
-		if str[0] == '?' {
-			if str[1] == '=' || str[1] == '!' {
-				self.error(-1, "re2: Invalid (%s) <lookahead>", self.str[self.chrOffset:self.chrOffset+2])
-			}
-		}
-	}
-	for self.chr != -1 && self.chr != ')' {
-		switch self.chr {
-		case '\\':
-			self.read()
-			self.scanEscape(false)
-		case '(':
-			self.pass()
-			self.scanGroup()
-		case '[':
-			self.pass()
-			self.scanBracket()
-		default:
-			self.pass()
-			continue
-		}
-	}
-	if self.chr != ')' {
-		self.error(-1, "Unterminated group")
-		self.invalid = true
-		return
-	}
-	self.pass()
-}
-
-// [...]
-func (self *_RegExp_parser) scanBracket() {
-	for self.chr != -1 {
-		if self.chr == ']' {
-			break
-		} else if self.chr == '\\' {
-			self.read()
-			self.scanEscape(true)
-			continue
-		}
-		self.pass()
-	}
-	if self.chr != ']' {
-		self.error(-1, "Unterminated character class")
-		self.invalid = true
-		return
-	}
-	self.pass()
-}
-
-// \...
-func (self *_RegExp_parser) scanEscape(inClass bool) {
-	offset := self.chrOffset
-
-	var length, base uint32
-	switch self.chr {
-
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		var value int64
-		size := 0
-		for {
-			digit := int64(digitValue(self.chr))
-			if digit >= 8 {
-				// Not a valid digit
-				break
-			}
-			value = value*8 + digit
-			self.read()
-			size += 1
-		}
-		if size == 1 { // The number of characters read
-			_, err := self.goRegexp.Write([]byte{'\\', byte(value) + '0'})
-			if err != nil {
-				self.errors = append(self.errors, err)
-			}
-			if value != 0 {
-				// An invalid backreference
-				self.error(-1, "re2: Invalid \\%d <backreference>", value)
-			}
-			return
-		}
-		tmp := []byte{'\\', 'x', '0', 0}
-		if value >= 16 {
-			tmp = tmp[0:2]
-		} else {
-			tmp = tmp[0:3]
-		}
-		tmp = strconv.AppendInt(tmp, value, 16)
-		_, err := self.goRegexp.Write(tmp)
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-		return
-
-	case '8', '9':
-		size := 0
-		for {
-			digit := digitValue(self.chr)
-			if digit >= 10 {
-				// Not a valid digit
-				break
-			}
-			self.read()
-			size += 1
-		}
-		err := self.goRegexp.WriteByte('\\')
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-		_, err = self.goRegexp.WriteString(self.str[offset:self.chrOffset])
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-		self.error(-1, "re2: Invalid \\%s <backreference>", self.str[offset:self.chrOffset])
-		return
-
-	case 'x':
-		self.read()
-		length, base = 2, 16
-
-	case 'u':
-		self.read()
-		length, base = 4, 16
-
-	case 'b':
-		if inClass {
-			_, err := self.goRegexp.Write([]byte{'\\', 'x', '0', '8'})
-			if err != nil {
-				self.errors = append(self.errors, err)
-			}
-			self.read()
-			return
-		}
-		fallthrough
-
-	case 'B':
-		fallthrough
-
-	case 'd', 'D', 's', 'S', 'w', 'W':
-		// This is slightly broken, because ECMAScript
-		// includes \v in \s, \S, while re2 does not
-		fallthrough
-
-	case '\\':
-		fallthrough
-
-	case 'f', 'n', 'r', 't', 'v':
-		err := self.goRegexp.WriteByte('\\')
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-		self.pass()
-		return
-
-	case 'c':
-		self.read()
-		var value int64
-		if 'a' <= self.chr && self.chr <= 'z' {
-			value = int64(self.chr) - 'a' + 1
-		} else if 'A' <= self.chr && self.chr <= 'Z' {
-			value = int64(self.chr) - 'A' + 1
-		} else {
-			err := self.goRegexp.WriteByte('c')
-			if err != nil {
-				self.errors = append(self.errors, err)
-			}
-			return
-		}
-		tmp := []byte{'\\', 'x', '0', 0}
-		if value >= 16 {
-			tmp = tmp[0:2]
-		} else {
-			tmp = tmp[0:3]
-		}
-		tmp = strconv.AppendInt(tmp, value, 16)
-		_, err := self.goRegexp.Write(tmp)
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-		self.read()
-		return
-
-	default:
-		// $ is an identifier character, so we have to have
-		// a special case for it here
-		if self.chr == '$' || !isIdentifierPart(self.chr) {
-			// A non-identifier character needs escaping
-			err := self.goRegexp.WriteByte('\\')
-			if err != nil {
-				self.errors = append(self.errors, err)
-			}
-		} else {
-			// Unescape the character for re2
-		}
-		self.pass()
-		return
-	}
-
-	// Otherwise, we're a \u.... or \x...
-	valueOffset := self.chrOffset
-
-	var value uint32
-	{
-		length := length
-		for ; length > 0; length-- {
-			digit := uint32(digitValue(self.chr))
-			if digit >= base {
-				// Not a valid digit
-				goto skip
-			}
-			value = value*base + digit
-			self.read()
-		}
-	}
-
-	if length == 4 {
-		_, err := self.goRegexp.Write([]byte{
-			'\\',
-			'x',
-			'{',
-			self.str[valueOffset+0],
-			self.str[valueOffset+1],
-			self.str[valueOffset+2],
-			self.str[valueOffset+3],
-			'}',
-		})
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-	} else if length == 2 {
-		_, err := self.goRegexp.Write([]byte{
-			'\\',
-			'x',
-			self.str[valueOffset+0],
-			self.str[valueOffset+1],
-		})
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-	} else {
-		// Should never, ever get here...
-		self.error(-1, "re2: Illegal branch in scanEscape")
-		goto skip
-	}
-
-	return
-
-skip:
-	_, err := self.goRegexp.WriteString(self.str[offset:self.chrOffset])
-	if err != nil {
-		self.errors = append(self.errors, err)
-	}
-}
-
-func (self *_RegExp_parser) pass() {
-	if self.chr != -1 {
-		_, err := self.goRegexp.WriteRune(self.chr)
-		if err != nil {
-			self.errors = append(self.errors, err)
-		}
-	}
-	self.read()
-}
-
-// TODO Better error reporting, use the offset, etc.
-func (self *_RegExp_parser) error(offset int, msg string, msgValues ...interface{}) error {
-	err := fmt.Errorf(msg, msgValues...)
-	self.errors = append(self.errors, err)
-	return err
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/scope.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/scope.go
deleted file mode 100644
index e1dbdda13..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/scope.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package parser
-
-import (
-	"github.com/robertkrimen/otto/ast"
-)
-
-type _scope struct {
-	outer           *_scope
-	allowIn         bool
-	inIteration     bool
-	inSwitch        bool
-	inFunction      bool
-	declarationList []ast.Declaration
-
-	labels []string
-}
-
-func (self *_parser) openScope() {
-	self.scope = &_scope{
-		outer:   self.scope,
-		allowIn: true,
-	}
-}
-
-func (self *_parser) closeScope() {
-	self.scope = self.scope.outer
-}
-
-func (self *_scope) declare(declaration ast.Declaration) {
-	self.declarationList = append(self.declarationList, declaration)
-}
-
-func (self *_scope) hasLabel(name string) bool {
-	for _, label := range self.labels {
-		if label == name {
-			return true
-		}
-	}
-	if self.outer != nil && !self.inFunction {
-		// Crossing a function boundary to look for a label is verboten
-		return self.outer.hasLabel(name)
-	}
-	return false
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/statement.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/statement.go
deleted file mode 100644
index 987ac02c1..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/parser/statement.go
+++ /dev/null
@@ -1,943 +0,0 @@
-package parser
-
-import (
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/token"
-)
-
-func (self *_parser) parseBlockStatement() *ast.BlockStatement {
-	node := &ast.BlockStatement{}
-
-	// Find comments before the leading brace
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, self.findComments(false), ast.LEADING)
-	}
-
-	node.LeftBrace = self.expect(token.LEFT_BRACE)
-	node.List = self.parseStatementList()
-
-	self.consumeComments(node, ast.FINAL)
-
-	node.RightBrace = self.expect(token.RIGHT_BRACE)
-
-	// Find comments after the trailing brace
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, self.findComments(false), ast.TRAILING)
-	}
-
-	return node
-}
-
-func (self *_parser) parseEmptyStatement() ast.Statement {
-	idx := self.expect(token.SEMICOLON)
-	return &ast.EmptyStatement{Semicolon: idx}
-}
-
-func (self *_parser) parseStatementList() (list []ast.Statement) {
-	for self.token != token.RIGHT_BRACE && self.token != token.EOF {
-		if self.token == token.COMMENT {
-			self.parseCommentElement()
-			continue
-		}
-		statement := self.parseStatement()
-		list = append(list, statement)
-
-		self.addCommentStatements(statement, ast.LEADING)
-	}
-
-	return
-}
-
-func (self *_parser) parseStatement() ast.Statement {
-
-	if self.token == token.EOF {
-		self.errorUnexpectedToken(self.token)
-		return &ast.BadStatement{From: self.idx, To: self.idx + 1}
-	}
-
-	switch self.token {
-	case token.SEMICOLON:
-		return self.parseEmptyStatement()
-	case token.LEFT_BRACE:
-		return self.parseBlockStatement()
-	case token.IF:
-		return self.parseIfStatement()
-	case token.DO:
-		return self.parseDoWhileStatement()
-	case token.WHILE:
-		return self.parseWhileStatement()
-	case token.FOR:
-		return self.parseForOrForInStatement()
-	case token.BREAK:
-		return self.parseBreakStatement()
-	case token.CONTINUE:
-		return self.parseContinueStatement()
-	case token.DEBUGGER:
-		return self.parseDebuggerStatement()
-	case token.WITH:
-		return self.parseWithStatement()
-	case token.VAR:
-		return self.parseVariableStatement()
-	case token.FUNCTION:
-		self.parseFunction(true)
-		// FIXME
-		return &ast.EmptyStatement{}
-	case token.SWITCH:
-		return self.parseSwitchStatement()
-	case token.RETURN:
-		return self.parseReturnStatement()
-	case token.THROW:
-		return self.parseThrowStatement()
-	case token.TRY:
-		return self.parseTryStatement()
-	}
-
-	expression := self.parseExpression()
-
-	if identifier, isIdentifier := expression.(*ast.Identifier); isIdentifier && self.token == token.COLON {
-		// LabelledStatement
-		colon := self.idx
-		self.next() // :
-
-		comments := self.findComments(false)
-
-		label := identifier.Name
-		for _, value := range self.scope.labels {
-			if label == value {
-				self.error(identifier.Idx0(), "Label '%s' already exists", label)
-			}
-		}
-		self.scope.labels = append(self.scope.labels, label) // Push the label
-		statement := self.parseStatement()
-		self.scope.labels = self.scope.labels[:len(self.scope.labels)-1] // Pop the label
-		exp := &ast.LabelledStatement{
-			Label:     identifier,
-			Colon:     colon,
-			Statement: statement,
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(exp, comments, ast.TRAILING)
-		}
-
-		return exp
-	}
-
-	self.optionalSemicolon()
-
-	return &ast.ExpressionStatement{
-		Expression: expression,
-	}
-}
-
-func (self *_parser) parseTryStatement() ast.Statement {
-
-	node := &ast.TryStatement{
-		Try:  self.expect(token.TRY),
-		Body: self.parseBlockStatement(),
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Body, self.findComments(true), ast.TRAILING)
-	}
-
-	if self.token == token.CATCH {
-		catch := self.idx
-		self.next()
-		self.expect(token.LEFT_PARENTHESIS)
-		comments := self.findComments(true)
-		if self.token != token.IDENTIFIER {
-			self.expect(token.IDENTIFIER)
-			self.nextStatement()
-			return &ast.BadStatement{From: catch, To: self.idx}
-		} else {
-			identifier := self.parseIdentifier()
-
-			if self.mode&StoreComments != 0 {
-				self.commentMap.AddComments(identifier, comments, ast.LEADING)
-			}
-
-			self.expect(token.RIGHT_PARENTHESIS)
-			node.Catch = &ast.CatchStatement{
-				Catch:     catch,
-				Parameter: identifier,
-				Body:      self.parseBlockStatement(),
-			}
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node.Catch, self.findComments(true), ast.TRAILING)
-		}
-	}
-
-	if self.token == token.FINALLY {
-		self.next()
-
-		comments := self.findComments(true)
-
-		node.Finally = self.parseBlockStatement()
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node.Finally, comments, ast.LEADING)
-		}
-	}
-
-	if node.Catch == nil && node.Finally == nil {
-		self.error(node.Try, "Missing catch or finally after try")
-		return &ast.BadStatement{From: node.Try, To: node.Body.Idx1()}
-	}
-
-	return node
-}
-
-func (self *_parser) parseFunctionParameterList() *ast.ParameterList {
-	opening := self.expect(token.LEFT_PARENTHESIS)
-	var list []*ast.Identifier
-	for self.token != token.RIGHT_PARENTHESIS && self.token != token.EOF {
-		comments := self.findComments(true)
-		if self.token != token.IDENTIFIER {
-			self.expect(token.IDENTIFIER)
-		} else {
-			identifier := self.parseIdentifier()
-			if self.mode&StoreComments != 0 {
-				self.commentMap.AddComments(identifier, comments, ast.LEADING)
-			}
-			list = append(list, identifier)
-		}
-		if self.token != token.RIGHT_PARENTHESIS {
-			self.expect(token.COMMA)
-		}
-	}
-	closing := self.expect(token.RIGHT_PARENTHESIS)
-
-	return &ast.ParameterList{
-		Opening: opening,
-		List:    list,
-		Closing: closing,
-	}
-}
-
-func (self *_parser) parseParameterList() (list []string) {
-	for self.token != token.EOF {
-		if self.token != token.IDENTIFIER {
-			self.expect(token.IDENTIFIER)
-		}
-		list = append(list, self.literal)
-		self.next()
-		if self.token != token.EOF {
-			self.expect(token.COMMA)
-		}
-	}
-	return
-}
-
-func (self *_parser) parseFunction(declaration bool) *ast.FunctionLiteral {
-
-	node := &ast.FunctionLiteral{
-		Function: self.expect(token.FUNCTION),
-	}
-
-	var name *ast.Identifier
-	if self.token == token.IDENTIFIER {
-		name = self.parseIdentifier()
-		if declaration {
-			self.scope.declare(&ast.FunctionDeclaration{
-				Function: node,
-			})
-		}
-	} else if declaration {
-		// Use expect error handling
-		self.expect(token.IDENTIFIER)
-	}
-	node.Name = name
-	node.ParameterList = self.parseFunctionParameterList()
-	self.parseFunctionBlock(node)
-	node.Source = self.slice(node.Idx0(), node.Idx1())
-
-	return node
-}
-
-func (self *_parser) parseFunctionBlock(node *ast.FunctionLiteral) {
-	{
-		self.openScope()
-		inFunction := self.scope.inFunction
-		self.scope.inFunction = true
-		defer func() {
-			self.scope.inFunction = inFunction
-			self.closeScope()
-		}()
-		node.Body = self.parseBlockStatement()
-		node.DeclarationList = self.scope.declarationList
-	}
-}
-
-func (self *_parser) parseDebuggerStatement() ast.Statement {
-	idx := self.expect(token.DEBUGGER)
-
-	comments := self.findComments(true)
-
-	node := &ast.DebuggerStatement{
-		Debugger: idx,
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, comments, ast.TRAILING)
-	}
-
-	self.semicolon()
-
-	if !self.skippedLineBreak {
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node, self.findComments(false), ast.TRAILING)
-		}
-	}
-
-	return node
-}
-
-func (self *_parser) parseReturnStatement() ast.Statement {
-	idx := self.expect(token.RETURN)
-
-	if !self.scope.inFunction {
-		self.error(idx, "Illegal return statement")
-		self.nextStatement()
-		return &ast.BadStatement{From: idx, To: self.idx}
-	}
-
-	node := &ast.ReturnStatement{
-		Return: idx,
-	}
-
-	if !self.implicitSemicolon && self.token != token.SEMICOLON && self.token != token.RIGHT_BRACE && self.token != token.EOF {
-		node.Argument = self.parseExpression()
-	}
-
-	self.semicolon()
-
-	return node
-}
-
-func (self *_parser) parseThrowStatement() ast.Statement {
-	idx := self.expect(token.THROW)
-
-	if self.implicitSemicolon {
-		if self.chr == -1 { // Hackish
-			self.error(idx, "Unexpected end of input")
-		} else {
-			self.error(idx, "Illegal newline after throw")
-		}
-		self.nextStatement()
-		return &ast.BadStatement{From: idx, To: self.idx}
-	}
-
-	node := &ast.ThrowStatement{
-		Argument: self.parseExpression(),
-	}
-
-	self.semicolon()
-
-	return node
-}
-
-func (self *_parser) parseSwitchStatement() ast.Statement {
-	self.expect(token.SWITCH)
-	self.expect(token.LEFT_PARENTHESIS)
-	node := &ast.SwitchStatement{
-		Discriminant: self.parseExpression(),
-		Default:      -1,
-	}
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	self.expect(token.LEFT_BRACE)
-
-	inSwitch := self.scope.inSwitch
-	self.scope.inSwitch = true
-	defer func() {
-		self.scope.inSwitch = inSwitch
-	}()
-
-	for index := 0; self.token != token.EOF; index++ {
-		if self.token == token.RIGHT_BRACE {
-			self.next()
-			break
-		}
-
-		clause := self.parseCaseStatement()
-		if clause.Test == nil {
-			if node.Default != -1 {
-				self.error(clause.Case, "Already saw a default in switch")
-			}
-			node.Default = index
-		}
-		node.Body = append(node.Body, clause)
-	}
-
-	return node
-}
-
-func (self *_parser) parseWithStatement() ast.Statement {
-	self.expect(token.WITH)
-
-	// Find the comments after with
-	comments := self.findComments(true)
-
-	self.expect(token.LEFT_PARENTHESIS)
-
-	node := &ast.WithStatement{
-		Object: self.parseExpression(),
-	}
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	// Add the key comments
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, comments, ast.KEY)
-	}
-
-	// Find the leading comments for the body
-	comments = self.findComments(true)
-
-	node.Body = self.parseStatement()
-
-	// Add the body comments
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Body, comments, ast.LEADING)
-	}
-
-	// Move the trailing comments to the with statement
-	self.commentMap.MoveComments(node.Body, node, ast.TRAILING)
-
-	return node
-}
-
-func (self *_parser) parseCaseStatement() *ast.CaseStatement {
-
-	var comments []*ast.Comment
-
-	node := &ast.CaseStatement{
-		Case: self.idx,
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, self.findComments(true), ast.LEADING)
-	}
-
-	// Consume current comments
-	self.consumeComments(node, ast.LEADING)
-
-	if self.token == token.DEFAULT {
-		self.next()
-	} else {
-		self.expect(token.CASE)
-
-		comments = self.findComments(true)
-
-		node.Test = self.parseExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node.Test, comments, ast.LEADING)
-		}
-
-		comments = self.findComments(true)
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node.Test, comments, ast.TRAILING)
-		}
-	}
-
-	self.expect(token.COLON)
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Test, self.findComments(false), ast.TRAILING)
-	}
-
-	for {
-		if self.token == token.EOF ||
-			self.token == token.RIGHT_BRACE ||
-			self.token == token.CASE ||
-			self.token == token.DEFAULT {
-			break
-		}
-		consequent := self.parseStatement()
-		node.Consequent = append(node.Consequent, consequent)
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(consequent, self.findComments(false), ast.TRAILING)
-		}
-	}
-
-	return node
-}
-
-func (self *_parser) parseIterationStatement() ast.Statement {
-	inIteration := self.scope.inIteration
-	self.scope.inIteration = true
-	defer func() {
-		self.scope.inIteration = inIteration
-	}()
-	return self.parseStatement()
-}
-
-func (self *_parser) parseForIn(into ast.Expression) *ast.ForInStatement {
-
-	// Already have consumed "<into> in"
-
-	// Comments after the in, before the expression
-	comments := self.findComments(true)
-
-	source := self.parseExpression()
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(source, comments, ast.LEADING)
-	}
-
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	comments = self.findComments(true)
-	body := self.parseIterationStatement()
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(body, comments, ast.LEADING)
-	}
-
-	forin := &ast.ForInStatement{
-		Into:   into,
-		Source: source,
-		Body:   body,
-	}
-
-	self.commentMap.MoveComments(body, forin, ast.TRAILING)
-
-	return forin
-}
-
-func (self *_parser) parseFor(initializer ast.Expression) *ast.ForStatement {
-
-	// Already have consumed "<initializer> ;"
-
-	comments := self.findComments(true)
-
-	var test, update ast.Expression
-
-	if self.token != token.SEMICOLON {
-		test = self.parseExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(test, comments, ast.LEADING)
-		}
-	}
-	self.expect(token.SEMICOLON)
-
-	comments = self.findComments(true)
-
-	if self.token != token.RIGHT_PARENTHESIS {
-		update = self.parseExpression()
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(update, comments, ast.LEADING)
-		}
-	}
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	comments = self.findComments(true)
-
-	body := self.parseIterationStatement()
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(body, comments, ast.LEADING)
-	}
-
-	forstatement := &ast.ForStatement{
-		Initializer: initializer,
-		Test:        test,
-		Update:      update,
-		Body:        body,
-	}
-
-	self.commentMap.MoveComments(body, forstatement, ast.TRAILING)
-
-	return forstatement
-}
-
-func (self *_parser) parseForOrForInStatement() ast.Statement {
-	idx := self.expect(token.FOR)
-	self.expect(token.LEFT_PARENTHESIS)
-
-	comments := self.findComments(true)
-
-	var left []ast.Expression
-
-	forIn := false
-	if self.token != token.SEMICOLON {
-
-		allowIn := self.scope.allowIn
-		self.scope.allowIn = false
-		if self.token == token.VAR {
-			var_ := self.idx
-			self.next()
-			list := self.parseVariableDeclarationList(var_)
-			if len(list) == 1 && self.token == token.IN {
-				self.next() // in
-				forIn = true
-				left = []ast.Expression{list[0]} // There is only one declaration
-			} else {
-				left = list
-			}
-		} else {
-			left = append(left, self.parseExpression())
-			if self.token == token.IN {
-				self.next()
-				forIn = true
-			}
-		}
-		self.scope.allowIn = allowIn
-	}
-
-	if forIn {
-		switch left[0].(type) {
-		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression, *ast.VariableExpression:
-			// These are all acceptable
-		default:
-			self.error(idx, "Invalid left-hand side in for-in")
-			self.nextStatement()
-			return &ast.BadStatement{From: idx, To: self.idx}
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(left[0], comments, ast.LEADING)
-		}
-		return self.parseForIn(left[0])
-	}
-
-	self.expect(token.SEMICOLON)
-	initializer := &ast.SequenceExpression{Sequence: left}
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(initializer, comments, ast.LEADING)
-	}
-	return self.parseFor(initializer)
-}
-
-func (self *_parser) parseVariableStatement() *ast.VariableStatement {
-
-	idx := self.expect(token.VAR)
-
-	list := self.parseVariableDeclarationList(idx)
-
-	statement := &ast.VariableStatement{
-		Var:  idx,
-		List: list,
-	}
-
-	self.commentMap.MoveComments(statement.List[len(statement.List)-1], statement, ast.TRAILING)
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(statement, self.findComments(true), ast.TRAILING)
-	}
-
-	self.semicolon()
-
-	if self.skippedLineBreak {
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(statement, self.findComments(false), ast.TRAILING)
-		}
-	}
-
-	return statement
-}
-
-func (self *_parser) parseDoWhileStatement() ast.Statement {
-	inIteration := self.scope.inIteration
-	self.scope.inIteration = true
-	defer func() {
-		self.scope.inIteration = inIteration
-	}()
-
-	self.expect(token.DO)
-
-	comments := self.findComments(true)
-
-	node := &ast.DoWhileStatement{}
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, comments, ast.KEY)
-	}
-	if self.token == token.LEFT_BRACE {
-		node.Body = self.parseBlockStatement()
-	} else {
-		node.Body = self.parseStatement()
-	}
-
-	self.expect(token.WHILE)
-
-	comments = self.findComments(true)
-
-	self.expect(token.LEFT_PARENTHESIS)
-	node.Test = self.parseExpression()
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Test, comments, ast.LEADING)
-	}
-
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Test, self.findComments(false), ast.TRAILING)
-	}
-
-	return node
-}
-
-func (self *_parser) parseWhileStatement() ast.Statement {
-	self.expect(token.WHILE)
-
-	// Comments after while keyword
-	comments := self.findComments(true)
-
-	self.expect(token.LEFT_PARENTHESIS)
-	node := &ast.WhileStatement{
-		Test: self.parseExpression(),
-	}
-
-	// Add the while comments
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, comments, ast.KEY)
-	}
-
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	// Finding comments prior to the body
-	comments = self.findComments(true)
-
-	node.Body = self.parseIterationStatement()
-
-	// Adding the comments prior to the body
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Body, comments, ast.LEADING)
-	}
-
-	// Move the trailing comments to the while statement
-	self.commentMap.MoveComments(node.Body, node, ast.TRAILING)
-
-	return node
-}
-
-func (self *_parser) parseIfStatement() ast.Statement {
-	self.expect(token.IF)
-
-	comments := self.findComments(true)
-
-	self.expect(token.LEFT_PARENTHESIS)
-	node := &ast.IfStatement{
-		Test: self.parseExpression(),
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node, comments, ast.KEY)
-	}
-
-	self.expect(token.RIGHT_PARENTHESIS)
-
-	comments = self.findComments(true)
-
-	if self.token == token.LEFT_BRACE {
-		node.Consequent = self.parseBlockStatement()
-	} else {
-		node.Consequent = self.parseStatement()
-	}
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(node.Consequent, comments, ast.LEADING)
-		self.commentMap.AddComments(node.Consequent, self.findComments(true), ast.TRAILING)
-	}
-
-	if self.token == token.ELSE {
-		self.next()
-		comments = self.findComments(true)
-
-		node.Alternate = self.parseStatement()
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(node.Alternate, comments, ast.LEADING)
-			self.commentMap.AddComments(node.Alternate, self.findComments(false), ast.TRAILING)
-		}
-	}
-
-	return node
-}
-
-func (self *_parser) parseSourceElement() ast.Statement {
-
-	statementComment := self.fetchComments()
-
-	statement := self.parseStatement()
-
-	if self.mode&StoreComments != 0 {
-		self.commentMap.AddComments(statement, statementComment, ast.LEADING)
-	}
-
-	return statement
-}
-
-func (self *_parser) parseCommentElement() {
-	literal := self.literal
-	idx := self.expect(token.COMMENT)
-	self.comments = append(self.comments, &ast.Comment{
-		Begin:    idx,
-		Text:     literal,
-		Position: ast.LEADING,
-	})
-}
-
-func (self *_parser) parseSourceElements() []ast.Statement {
-	body := []ast.Statement(nil)
-
-	for {
-		if self.token != token.STRING {
-			break
-		}
-
-		if self.token == token.COMMENT {
-			self.parseCommentElement()
-			continue
-		}
-
-		body = append(body, self.parseSourceElement())
-	}
-
-	for self.token != token.EOF {
-		if self.token == token.COMMENT {
-			self.parseCommentElement()
-			continue
-		}
-		body = append(body, self.parseSourceElement())
-	}
-
-	return body
-}
-
-func (self *_parser) parseProgram() *ast.Program {
-	self.openScope()
-	defer self.closeScope()
-	return &ast.Program{
-		Body:            self.parseSourceElements(),
-		DeclarationList: self.scope.declarationList,
-		File:            self.file,
-	}
-}
-
-func (self *_parser) parseBreakStatement() ast.Statement {
-	idx := self.expect(token.BREAK)
-
-	breakComments := self.findComments(true)
-
-	semicolon := self.implicitSemicolon
-	if self.token == token.SEMICOLON {
-		semicolon = true
-		self.next()
-	}
-
-	if semicolon || self.token == token.RIGHT_BRACE {
-		self.implicitSemicolon = false
-		if !self.scope.inIteration && !self.scope.inSwitch {
-			goto illegal
-		}
-		breakStatement := &ast.BranchStatement{
-			Idx:   idx,
-			Token: token.BREAK,
-		}
-
-		if self.mode&StoreComments != 0 {
-			self.commentMap.AddComments(breakStatement, breakComments, ast.TRAILING)
-		}
-
-		return breakStatement
-	}
-
-	if self.token == token.IDENTIFIER {
-		identifier := self.parseIdentifier()
-		if !self.scope.hasLabel(identifier.Name) {
-			self.error(idx, "Undefined label '%s'", identifier.Name)
-			return &ast.BadStatement{From: idx, To: identifier.Idx1()}
-		}
-		self.semicolon()
-		return &ast.BranchStatement{
-			Idx:   idx,
-			Token: token.BREAK,
-			Label: identifier,
-		}
-	}
-
-	self.expect(token.IDENTIFIER)
-
-illegal:
-	self.error(idx, "Illegal break statement")
-	self.nextStatement()
-	return &ast.BadStatement{From: idx, To: self.idx}
-}
-
-func (self *_parser) parseContinueStatement() ast.Statement {
-	idx := self.expect(token.CONTINUE)
-	semicolon := self.implicitSemicolon
-	if self.token == token.SEMICOLON {
-		semicolon = true
-		self.next()
-	}
-
-	if semicolon || self.token == token.RIGHT_BRACE {
-		self.implicitSemicolon = false
-		if !self.scope.inIteration {
-			goto illegal
-		}
-		return &ast.BranchStatement{
-			Idx:   idx,
-			Token: token.CONTINUE,
-		}
-	}
-
-	if self.token == token.IDENTIFIER {
-		identifier := self.parseIdentifier()
-		if !self.scope.hasLabel(identifier.Name) {
-			self.error(idx, "Undefined label '%s'", identifier.Name)
-			return &ast.BadStatement{From: idx, To: identifier.Idx1()}
-		}
-		if !self.scope.inIteration {
-			goto illegal
-		}
-		self.semicolon()
-		return &ast.BranchStatement{
-			Idx:   idx,
-			Token: token.CONTINUE,
-			Label: identifier,
-		}
-	}
-
-	self.expect(token.IDENTIFIER)
-
-illegal:
-	self.error(idx, "Illegal continue statement")
-	self.nextStatement()
-	return &ast.BadStatement{From: idx, To: self.idx}
-}
-
-// Find the next statement after an error (recover)
-func (self *_parser) nextStatement() {
-	for {
-		switch self.token {
-		case token.BREAK, token.CONTINUE,
-			token.FOR, token.IF, token.RETURN, token.SWITCH,
-			token.VAR, token.DO, token.TRY, token.WITH,
-			token.WHILE, token.THROW, token.CATCH, token.FINALLY:
-			// Return only if parser made some progress since last
-			// sync or if it has not reached 10 next calls without
-			// progress. Otherwise consume at least one token to
-			// avoid an endless parser loop
-			if self.idx == self.recover.idx && self.recover.count < 10 {
-				self.recover.count++
-				return
-			}
-			if self.idx > self.recover.idx {
-				self.recover.idx = self.idx
-				self.recover.count = 0
-				return
-			}
-			// Reaching here indicates a parser bug, likely an
-			// incorrect token list in this function, but it only
-			// leads to skipping of possibly correct code if a
-			// previous error is present, and thus is preferred
-			// over a non-terminating parse.
-		case token.EOF:
-			return
-		}
-		self.next()
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/property.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/property.go
deleted file mode 100644
index 5445eccde..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/property.go
+++ /dev/null
@@ -1,220 +0,0 @@
-package otto
-
-// property
-
-type _propertyMode int
-
-const (
-	modeWriteMask     _propertyMode = 0700
-	modeEnumerateMask               = 0070
-	modeConfigureMask               = 0007
-	modeOnMask                      = 0111
-	modeOffMask                     = 0000
-	modeSetMask                     = 0222 // If value is 2, then mode is neither "On" nor "Off"
-)
-
-type _propertyGetSet [2]*_object
-
-var _nilGetSetObject _object = _object{}
-
-type _property struct {
-	value interface{}
-	mode  _propertyMode
-}
-
-func (self _property) writable() bool {
-	return self.mode&modeWriteMask == modeWriteMask&modeOnMask
-}
-
-func (self *_property) writeOn() {
-	self.mode = (self.mode & ^modeWriteMask) | (modeWriteMask & modeOnMask)
-}
-
-func (self *_property) writeOff() {
-	self.mode &= ^modeWriteMask
-}
-
-func (self *_property) writeClear() {
-	self.mode = (self.mode & ^modeWriteMask) | (modeWriteMask & modeSetMask)
-}
-
-func (self _property) writeSet() bool {
-	return 0 == self.mode&modeWriteMask&modeSetMask
-}
-
-func (self _property) enumerable() bool {
-	return self.mode&modeEnumerateMask == modeEnumerateMask&modeOnMask
-}
-
-func (self *_property) enumerateOn() {
-	self.mode = (self.mode & ^modeEnumerateMask) | (modeEnumerateMask & modeOnMask)
-}
-
-func (self *_property) enumerateOff() {
-	self.mode &= ^modeEnumerateMask
-}
-
-func (self _property) enumerateSet() bool {
-	return 0 == self.mode&modeEnumerateMask&modeSetMask
-}
-
-func (self _property) configurable() bool {
-	return self.mode&modeConfigureMask == modeConfigureMask&modeOnMask
-}
-
-func (self *_property) configureOn() {
-	self.mode = (self.mode & ^modeConfigureMask) | (modeConfigureMask & modeOnMask)
-}
-
-func (self *_property) configureOff() {
-	self.mode &= ^modeConfigureMask
-}
-
-func (self _property) configureSet() bool {
-	return 0 == self.mode&modeConfigureMask&modeSetMask
-}
-
-func (self _property) copy() *_property {
-	property := self
-	return &property
-}
-
-func (self _property) get(this *_object) Value {
-	switch value := self.value.(type) {
-	case Value:
-		return value
-	case _propertyGetSet:
-		if value[0] != nil {
-			return value[0].call(toValue(this), nil, false, nativeFrame)
-		}
-	}
-	return Value{}
-}
-
-func (self _property) isAccessorDescriptor() bool {
-	setGet, test := self.value.(_propertyGetSet)
-	return test && (setGet[0] != nil || setGet[1] != nil)
-}
-
-func (self _property) isDataDescriptor() bool {
-	if self.writeSet() { // Either "On" or "Off"
-		return true
-	}
-	value, valid := self.value.(Value)
-	return valid && !value.isEmpty()
-}
-
-func (self _property) isGenericDescriptor() bool {
-	return !(self.isDataDescriptor() || self.isAccessorDescriptor())
-}
-
-func (self _property) isEmpty() bool {
-	return self.mode == 0222 && self.isGenericDescriptor()
-}
-
-// _enumerableValue, _enumerableTrue, _enumerableFalse?
-// .enumerableValue() .enumerableExists()
-
-func toPropertyDescriptor(rt *_runtime, value Value) (descriptor _property) {
-	objectDescriptor := value._object()
-	if objectDescriptor == nil {
-		panic(rt.panicTypeError())
-	}
-
-	{
-		descriptor.mode = modeSetMask // Initially nothing is set
-		if objectDescriptor.hasProperty("enumerable") {
-			if objectDescriptor.get("enumerable").bool() {
-				descriptor.enumerateOn()
-			} else {
-				descriptor.enumerateOff()
-			}
-		}
-
-		if objectDescriptor.hasProperty("configurable") {
-			if objectDescriptor.get("configurable").bool() {
-				descriptor.configureOn()
-			} else {
-				descriptor.configureOff()
-			}
-		}
-
-		if objectDescriptor.hasProperty("writable") {
-			if objectDescriptor.get("writable").bool() {
-				descriptor.writeOn()
-			} else {
-				descriptor.writeOff()
-			}
-		}
-	}
-
-	var getter, setter *_object
-	getterSetter := false
-
-	if objectDescriptor.hasProperty("get") {
-		value := objectDescriptor.get("get")
-		if value.IsDefined() {
-			if !value.isCallable() {
-				panic(rt.panicTypeError())
-			}
-			getter = value._object()
-			getterSetter = true
-		} else {
-			getter = &_nilGetSetObject
-			getterSetter = true
-		}
-	}
-
-	if objectDescriptor.hasProperty("set") {
-		value := objectDescriptor.get("set")
-		if value.IsDefined() {
-			if !value.isCallable() {
-				panic(rt.panicTypeError())
-			}
-			setter = value._object()
-			getterSetter = true
-		} else {
-			setter = &_nilGetSetObject
-			getterSetter = true
-		}
-	}
-
-	if getterSetter {
-		if descriptor.writeSet() {
-			panic(rt.panicTypeError())
-		}
-		descriptor.value = _propertyGetSet{getter, setter}
-	}
-
-	if objectDescriptor.hasProperty("value") {
-		if getterSetter {
-			panic(rt.panicTypeError())
-		}
-		descriptor.value = objectDescriptor.get("value")
-	}
-
-	return
-}
-
-func (self *_runtime) fromPropertyDescriptor(descriptor _property) *_object {
-	object := self.newObject()
-	if descriptor.isDataDescriptor() {
-		object.defineProperty("value", descriptor.value.(Value), 0111, false)
-		object.defineProperty("writable", toValue_bool(descriptor.writable()), 0111, false)
-	} else if descriptor.isAccessorDescriptor() {
-		getSet := descriptor.value.(_propertyGetSet)
-		get := Value{}
-		if getSet[0] != nil {
-			get = toValue_object(getSet[0])
-		}
-		set := Value{}
-		if getSet[1] != nil {
-			set = toValue_object(getSet[1])
-		}
-		object.defineProperty("get", get, 0111, false)
-		object.defineProperty("set", set, 0111, false)
-	}
-	object.defineProperty("enumerable", toValue_bool(descriptor.enumerable()), 0111, false)
-	object.defineProperty("configurable", toValue_bool(descriptor.configurable()), 0111, false)
-	return object
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/README.markdown
deleted file mode 100644
index ba2d38909..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/README.markdown
+++ /dev/null
@@ -1,51 +0,0 @@
-# registry
---
-    import "github.com/robertkrimen/otto/registry"
-
-Package registry is an expirmental package to facillitate altering the otto
-runtime via import.
-
-This interface can change at any time.
-
-## Usage
-
-#### func  Apply
-
-```go
-func Apply(callback func(Entry))
-```
-
-#### type Entry
-
-```go
-type Entry struct {
-}
-```
-
-
-#### func  Register
-
-```go
-func Register(source func() string) *Entry
-```
-
-#### func (*Entry) Disable
-
-```go
-func (self *Entry) Disable()
-```
-
-#### func (*Entry) Enable
-
-```go
-func (self *Entry) Enable()
-```
-
-#### func (Entry) Source
-
-```go
-func (self Entry) Source() string
-```
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/registry.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/registry.go
deleted file mode 100644
index 966638ac4..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/registry/registry.go
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-Package registry is an expirmental package to facillitate altering the otto runtime via import.
-
-This interface can change at any time.
-*/
-package registry
-
-var registry []*Entry = make([]*Entry, 0)
-
-type Entry struct {
-	active bool
-	source func() string
-}
-
-func newEntry(source func() string) *Entry {
-	return &Entry{
-		active: true,
-		source: source,
-	}
-}
-
-func (self *Entry) Enable() {
-	self.active = true
-}
-
-func (self *Entry) Disable() {
-	self.active = false
-}
-
-func (self Entry) Source() string {
-	return self.source()
-}
-
-func Apply(callback func(Entry)) {
-	for _, entry := range registry {
-		if !entry.active {
-			continue
-		}
-		callback(*entry)
-	}
-}
-
-func Register(source func() string) *Entry {
-	entry := newEntry(source)
-	registry = append(registry, entry)
-	return entry
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/repl/repl.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/repl/repl.go
deleted file mode 100644
index 0d70cc051..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/repl/repl.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Package repl implements a REPL (read-eval-print loop) for otto.
-package repl
-
-import (
-	"fmt"
-	"io"
-	"strings"
-	"sync/atomic"
-
-	"github.com/robertkrimen/otto"
-	"gopkg.in/readline.v1"
-)
-
-var counter uint32
-
-// DebuggerHandler implements otto's debugger handler signature, providing a
-// simple drop-in debugger implementation.
-func DebuggerHandler(vm *otto.Otto) {
-	i := atomic.AddUint32(&counter, 1)
-
-	// purposefully ignoring the error here - we can't do anything useful with
-	// it except panicking, and that'd be pretty rude. it'd be easy enough for a
-	// consumer to define an equivalent function that _does_ panic if desired.
-	_ = RunWithPrompt(vm, fmt.Sprintf("DEBUGGER[%d]>", i))
-}
-
-// Run creates a REPL with the default prompt and no prelude.
-func Run(vm *otto.Otto) error {
-	return RunWithPromptAndPrelude(vm, "", "")
-}
-
-// RunWithPrompt runs a REPL with the given prompt and no prelude.
-func RunWithPrompt(vm *otto.Otto, prompt string) error {
-	return RunWithPromptAndPrelude(vm, prompt, "")
-}
-
-// RunWithPrelude runs a REPL with the default prompt and the given prelude.
-func RunWithPrelude(vm *otto.Otto, prelude string) error {
-	return RunWithPromptAndPrelude(vm, "", prelude)
-}
-
-// RunWithPromptAndPrelude runs a REPL with the given prompt and prelude.
-func RunWithPromptAndPrelude(vm *otto.Otto, prompt, prelude string) error {
-	if prompt == "" {
-		prompt = ">"
-	}
-
-	prompt = strings.Trim(prompt, " ")
-	prompt += " "
-
-	rl, err := readline.New(prompt)
-	if err != nil {
-		return err
-	}
-
-	if prelude != "" {
-		if _, err := io.Copy(rl.Stderr(), strings.NewReader(prelude+"\n")); err != nil {
-			return err
-		}
-
-		rl.Refresh()
-	}
-
-	var d []string
-
-	for {
-		l, err := rl.Readline()
-		if err != nil {
-			if err == readline.ErrInterrupt {
-				if d != nil {
-					d = nil
-
-					rl.SetPrompt(prompt)
-					rl.Refresh()
-
-					continue
-				}
-
-				break
-			}
-
-			return err
-		}
-
-		if l == "" {
-			continue
-		}
-
-		d = append(d, l)
-
-		s, err := vm.Compile("repl", strings.Join(d, "\n"))
-		if err != nil {
-			rl.SetPrompt(strings.Repeat(" ", len(prompt)))
-		} else {
-			rl.SetPrompt(prompt)
-
-			d = nil
-
-			v, err := vm.Eval(s)
-			if err != nil {
-				if oerr, ok := err.(*otto.Error); ok {
-					io.Copy(rl.Stdout(), strings.NewReader(oerr.String()))
-				} else {
-					io.Copy(rl.Stdout(), strings.NewReader(err.Error()))
-				}
-			} else {
-				rl.Stdout().Write([]byte(v.String() + "\n"))
-			}
-		}
-
-		rl.Refresh()
-	}
-
-	return rl.Close()
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/result.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/result.go
deleted file mode 100644
index 63642e7d0..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/result.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package otto
-
-import ()
-
-type _resultKind int
-
-const (
-	resultNormal _resultKind = iota
-	resultReturn
-	resultBreak
-	resultContinue
-)
-
-type _result struct {
-	kind   _resultKind
-	value  Value
-	target string
-}
-
-func newReturnResult(value Value) _result {
-	return _result{resultReturn, value, ""}
-}
-
-func newContinueResult(target string) _result {
-	return _result{resultContinue, emptyValue, target}
-}
-
-func newBreakResult(target string) _result {
-	return _result{resultBreak, emptyValue, target}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go
deleted file mode 100644
index a998f7acc..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go
+++ /dev/null
@@ -1,527 +0,0 @@
-package otto
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-	"sync"
-
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/parser"
-)
-
-type _global struct {
-	Object         *_object // Object( ... ), new Object( ... ) - 1 (length)
-	Function       *_object // Function( ... ), new Function( ... ) - 1
-	Array          *_object // Array( ... ), new Array( ... ) - 1
-	String         *_object // String( ... ), new String( ... ) - 1
-	Boolean        *_object // Boolean( ... ), new Boolean( ... ) - 1
-	Number         *_object // Number( ... ), new Number( ... ) - 1
-	Math           *_object
-	Date           *_object // Date( ... ), new Date( ... ) - 7
-	RegExp         *_object // RegExp( ... ), new RegExp( ... ) - 2
-	Error          *_object // Error( ... ), new Error( ... ) - 1
-	EvalError      *_object
-	TypeError      *_object
-	RangeError     *_object
-	ReferenceError *_object
-	SyntaxError    *_object
-	URIError       *_object
-	JSON           *_object
-
-	ObjectPrototype         *_object // Object.prototype
-	FunctionPrototype       *_object // Function.prototype
-	ArrayPrototype          *_object // Array.prototype
-	StringPrototype         *_object // String.prototype
-	BooleanPrototype        *_object // Boolean.prototype
-	NumberPrototype         *_object // Number.prototype
-	DatePrototype           *_object // Date.prototype
-	RegExpPrototype         *_object // RegExp.prototype
-	ErrorPrototype          *_object // Error.prototype
-	EvalErrorPrototype      *_object
-	TypeErrorPrototype      *_object
-	RangeErrorPrototype     *_object
-	ReferenceErrorPrototype *_object
-	SyntaxErrorPrototype    *_object
-	URIErrorPrototype       *_object
-}
-
-type _runtime struct {
-	global       _global
-	globalObject *_object
-	globalStash  *_objectStash
-	scope        *_scope
-	otto         *Otto
-	eval         *_object // The builtin eval, for determine indirect versus direct invocation
-	debugger     func(*Otto)
-	random       func() float64
-
-	labels []string // FIXME
-	lck    sync.Mutex
-}
-
-func (self *_runtime) enterScope(scope *_scope) {
-	scope.outer = self.scope
-	self.scope = scope
-}
-
-func (self *_runtime) leaveScope() {
-	self.scope = self.scope.outer
-}
-
-// FIXME This is used in two places (cloning)
-func (self *_runtime) enterGlobalScope() {
-	self.enterScope(newScope(self.globalStash, self.globalStash, self.globalObject))
-}
-
-func (self *_runtime) enterFunctionScope(outer _stash, this Value) *_fnStash {
-	if outer == nil {
-		outer = self.globalStash
-	}
-	stash := self.newFunctionStash(outer)
-	var thisObject *_object
-	switch this.kind {
-	case valueUndefined, valueNull:
-		thisObject = self.globalObject
-	default:
-		thisObject = self.toObject(this)
-	}
-	self.enterScope(newScope(stash, stash, thisObject))
-	return stash
-}
-
-func (self *_runtime) putValue(reference _reference, value Value) {
-	name := reference.putValue(value)
-	if name != "" {
-		// Why? -- If reference.base == nil
-		// strict = false
-		self.globalObject.defineProperty(name, value, 0111, false)
-	}
-}
-
-func (self *_runtime) tryCatchEvaluate(inner func() Value) (tryValue Value, exception bool) {
-	// resultValue = The value of the block (e.g. the last statement)
-	// throw = Something was thrown
-	// throwValue = The value of what was thrown
-	// other = Something that changes flow (return, break, continue) that is not a throw
-	// Otherwise, some sort of unknown panic happened, we'll just propagate it
-	defer func() {
-		if caught := recover(); caught != nil {
-			if exception, ok := caught.(*_exception); ok {
-				caught = exception.eject()
-			}
-			switch caught := caught.(type) {
-			case _error:
-				exception = true
-				tryValue = toValue_object(self.newError(caught.name, caught.messageValue()))
-			case Value:
-				exception = true
-				tryValue = caught
-			default:
-				panic(caught)
-			}
-		}
-	}()
-
-	tryValue = inner()
-	return
-}
-
-// toObject
-
-func (self *_runtime) toObject(value Value) *_object {
-	switch value.kind {
-	case valueEmpty, valueUndefined, valueNull:
-		panic(self.panicTypeError())
-	case valueBoolean:
-		return self.newBoolean(value)
-	case valueString:
-		return self.newString(value)
-	case valueNumber:
-		return self.newNumber(value)
-	case valueObject:
-		return value._object()
-	}
-	panic(self.panicTypeError())
-}
-
-func (self *_runtime) objectCoerce(value Value) (*_object, error) {
-	switch value.kind {
-	case valueUndefined:
-		return nil, errors.New("undefined")
-	case valueNull:
-		return nil, errors.New("null")
-	case valueBoolean:
-		return self.newBoolean(value), nil
-	case valueString:
-		return self.newString(value), nil
-	case valueNumber:
-		return self.newNumber(value), nil
-	case valueObject:
-		return value._object(), nil
-	}
-	panic(self.panicTypeError())
-}
-
-func checkObjectCoercible(rt *_runtime, value Value) {
-	isObject, mustCoerce := testObjectCoercible(value)
-	if !isObject && !mustCoerce {
-		panic(rt.panicTypeError())
-	}
-}
-
-// testObjectCoercible
-
-func testObjectCoercible(value Value) (isObject bool, mustCoerce bool) {
-	switch value.kind {
-	case valueReference, valueEmpty, valueNull, valueUndefined:
-		return false, false
-	case valueNumber, valueString, valueBoolean:
-		isObject = false
-		mustCoerce = true
-	case valueObject:
-		isObject = true
-		mustCoerce = false
-	}
-	return
-}
-
-func (self *_runtime) safeToValue(value interface{}) (Value, error) {
-	result := Value{}
-	err := catchPanic(func() {
-		result = self.toValue(value)
-	})
-	return result, err
-}
-
-// convertNumeric converts numeric parameter val from js to that of type t if it is safe to do so, otherwise it panics.
-// This allows literals (int64), bitwise values (int32) and the general form (float64) of javascript numerics to be passed as parameters to go functions easily.
-func convertNumeric(val reflect.Value, t reflect.Type) reflect.Value {
-	if val.Kind() == t.Kind() {
-		return val
-	}
-
-	if val.Kind() == reflect.Interface {
-		val = reflect.ValueOf(val.Interface())
-	}
-
-	switch val.Kind() {
-	case reflect.Float32, reflect.Float64:
-		f64 := val.Float()
-		switch t.Kind() {
-		case reflect.Float64:
-			return reflect.ValueOf(f64)
-		case reflect.Float32:
-			if reflect.Zero(t).OverflowFloat(f64) {
-				panic("converting float64 to float32 would overflow")
-			}
-
-			return val.Convert(t)
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			i64 := int64(f64)
-			if float64(i64) != f64 {
-				panic(fmt.Sprintf("converting %v to %v would cause loss of precision", val.Type(), t))
-			}
-
-			// The float represents an integer
-			val = reflect.ValueOf(i64)
-		default:
-			panic(fmt.Sprintf("cannot convert %v to %v", val.Type(), t))
-		}
-	}
-
-	switch val.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		i64 := val.Int()
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			if reflect.Zero(t).OverflowInt(i64) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			if i64 < 0 {
-				panic(fmt.Sprintf("converting %v to %v would underflow", val.Type(), t))
-			}
-			if reflect.Zero(t).OverflowUint(uint64(i64)) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		}
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		u64 := val.Uint()
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			if u64 > math.MaxInt64 || reflect.Zero(t).OverflowInt(int64(u64)) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			if reflect.Zero(t).OverflowUint(u64) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		}
-	}
-
-	panic(fmt.Sprintf("unsupported type %v for numeric conversion", val.Type()))
-}
-
-// callParamConvert converts request val to type t if possible.
-// If the conversion fails due to overflow or type miss-match then it panics.
-// If no conversion is known then the original value is returned.
-func callParamConvert(val reflect.Value, t reflect.Type) reflect.Value {
-	if val.Kind() == reflect.Interface {
-		val = reflect.ValueOf(val.Interface())
-	}
-
-	switch t.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-		if val.Kind() == t.Kind() {
-			// Types already match
-			return val
-		}
-		return convertNumeric(val, t)
-	case reflect.Slice:
-		if val.Kind() != reflect.Slice {
-			// Conversion from none slice type to slice not possible
-			panic(fmt.Sprintf("cannot use %v as type %v", val, t))
-		}
-	default:
-		// No supported conversion
-		return val
-	}
-
-	elemType := t.Elem()
-	switch elemType.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.Slice:
-		// Attempt to convert to slice of the type t
-		s := reflect.MakeSlice(reflect.SliceOf(elemType), val.Len(), val.Len())
-		for i := 0; i < val.Len(); i++ {
-			s.Index(i).Set(callParamConvert(val.Index(i), elemType))
-		}
-
-		return s
-	}
-
-	// Not a slice type we can convert
-	return val
-}
-
-// callSliceRequired returns true if CallSlice is required instead of Call.
-func callSliceRequired(param reflect.Type, val reflect.Value) bool {
-	vt := val.Type()
-	for param.Kind() == reflect.Slice {
-		if val.Kind() == reflect.Interface {
-			val = reflect.ValueOf(val.Interface())
-			vt = val.Type()
-		}
-
-		if vt.Kind() != reflect.Slice {
-			return false
-		}
-
-		vt = vt.Elem()
-		if val.Kind() != reflect.Invalid {
-			if val.Len() > 0 {
-				val = val.Index(0)
-			} else {
-				val = reflect.Value{}
-			}
-		}
-		param = param.Elem()
-	}
-
-	return true
-}
-
-func (self *_runtime) toValue(value interface{}) Value {
-	switch value := value.(type) {
-	case Value:
-		return value
-	case func(FunctionCall) Value:
-		return toValue_object(self.newNativeFunction("", value))
-	case _nativeFunction:
-		return toValue_object(self.newNativeFunction("", value))
-	case Object, *Object, _object, *_object:
-		// Nothing happens.
-		// FIXME We should really figure out what can come here.
-		// This catch-all is ugly.
-	default:
-		{
-			value := reflect.ValueOf(value)
-			switch value.Kind() {
-			case reflect.Ptr:
-				switch reflect.Indirect(value).Kind() {
-				case reflect.Struct:
-					return toValue_object(self.newGoStructObject(value))
-				case reflect.Array:
-					return toValue_object(self.newGoArray(value))
-				}
-			case reflect.Func:
-				// TODO Maybe cache this?
-				return toValue_object(self.newNativeFunction("", func(call FunctionCall) Value {
-					argsCount := len(call.ArgumentList)
-					in := make([]reflect.Value, argsCount)
-					t := value.Type()
-					callSlice := false
-					paramsCount := t.NumIn()
-					lastParam := paramsCount - 1
-					lastArg := argsCount - 1
-					isVariadic := t.IsVariadic()
-					for i, value := range call.ArgumentList {
-						var paramType reflect.Type
-						if isVariadic && i == lastArg && argsCount == paramsCount {
-							// Variadic functions last parameter and parameter numbers match incoming args
-							paramType = t.In(lastArg)
-							val := reflect.ValueOf(value.export())
-							callSlice = callSliceRequired(paramType, val)
-							if callSlice {
-								in[i] = callParamConvert(reflect.ValueOf(value.export()), paramType)
-								continue
-							}
-						}
-
-						if i >= lastParam {
-							if isVariadic {
-								paramType = t.In(lastParam).Elem()
-							} else {
-								paramType = t.In(lastParam)
-							}
-						} else {
-							paramType = t.In(i)
-						}
-						in[i] = callParamConvert(reflect.ValueOf(value.export()), paramType)
-					}
-
-					var out []reflect.Value
-					if callSlice {
-						out = value.CallSlice(in)
-					} else {
-						out = value.Call(in)
-					}
-
-					l := len(out)
-					switch l {
-					case 0:
-						return Value{}
-					case 1:
-						return self.toValue(out[0].Interface())
-					}
-
-					// Return an array of the values to emulate multi value return.
-					// In the future this can be used along side destructuring assignment.
-					s := make([]interface{}, l)
-					for i, v := range out {
-						s[i] = self.toValue(v.Interface())
-					}
-					return self.toValue(s)
-				}))
-			case reflect.Struct:
-				return toValue_object(self.newGoStructObject(value))
-			case reflect.Map:
-				return toValue_object(self.newGoMapObject(value))
-			case reflect.Slice:
-				return toValue_object(self.newGoSlice(value))
-			case reflect.Array:
-				return toValue_object(self.newGoArray(value))
-			}
-		}
-	}
-	return toValue(value)
-}
-
-func (runtime *_runtime) newGoSlice(value reflect.Value) *_object {
-	self := runtime.newGoSliceObject(value)
-	self.prototype = runtime.global.ArrayPrototype
-	return self
-}
-
-func (runtime *_runtime) newGoArray(value reflect.Value) *_object {
-	self := runtime.newGoArrayObject(value)
-	self.prototype = runtime.global.ArrayPrototype
-	return self
-}
-
-func (runtime *_runtime) parse(filename string, src interface{}) (*ast.Program, error) {
-	return parser.ParseFile(nil, filename, src, 0)
-}
-
-func (runtime *_runtime) cmpl_parse(filename string, src interface{}) (*_nodeProgram, error) {
-	program, err := parser.ParseFile(nil, filename, src, 0)
-	if err != nil {
-		return nil, err
-	}
-	return cmpl_parse(program), nil
-}
-
-func (self *_runtime) parseSource(src interface{}) (*_nodeProgram, *ast.Program, error) {
-	switch src := src.(type) {
-	case *ast.Program:
-		return nil, src, nil
-	case *Script:
-		return src.program, nil, nil
-	}
-	program, err := self.parse("", src)
-	return nil, program, err
-}
-
-func (self *_runtime) cmpl_runOrEval(src interface{}, eval bool) (Value, error) {
-	result := Value{}
-	cmpl_program, program, err := self.parseSource(src)
-	if err != nil {
-		return result, err
-	}
-	if cmpl_program == nil {
-		cmpl_program = cmpl_parse(program)
-	}
-	err = catchPanic(func() {
-		result = self.cmpl_evaluate_nodeProgram(cmpl_program, eval)
-	})
-	switch result.kind {
-	case valueEmpty:
-		result = Value{}
-	case valueReference:
-		result = result.resolve()
-	}
-	return result, err
-}
-
-func (self *_runtime) cmpl_run(src interface{}) (Value, error) {
-	return self.cmpl_runOrEval(src, false)
-}
-
-func (self *_runtime) cmpl_eval(src interface{}) (Value, error) {
-	return self.cmpl_runOrEval(src, true)
-}
-
-func (self *_runtime) parseThrow(err error) {
-	if err == nil {
-		return
-	}
-	switch err := err.(type) {
-	case parser.ErrorList:
-		{
-			err := err[0]
-			if err.Message == "Invalid left-hand side in assignment" {
-				panic(self.panicReferenceError(err.Message))
-			}
-			panic(self.panicSyntaxError(err.Message))
-		}
-	}
-	panic(self.panicSyntaxError(err.Error()))
-}
-
-func (self *_runtime) parseOrThrow(source string) *ast.Program {
-	program, err := self.parse("", source)
-	self.parseThrow(err) // Will panic/throw appropriately
-	return program
-}
-
-func (self *_runtime) cmpl_parseOrThrow(source string) *_nodeProgram {
-	program, err := self.cmpl_parse("", source)
-	self.parseThrow(err) // Will panic/throw appropriately
-	return program
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/scope.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/scope.go
deleted file mode 100644
index b80808434..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/scope.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package otto
-
-// _scope:
-// entryFile
-// entryIdx
-// top?
-// outer => nil
-
-// _stash:
-// lexical
-// variable
-//
-// _thisStash (ObjectEnvironment)
-// _fnStash
-// _dclStash
-
-// An ECMA-262 ExecutionContext
-type _scope struct {
-	lexical  _stash
-	variable _stash
-	this     *_object
-	eval     bool // Replace this with kind?
-	outer    *_scope
-
-	frame _frame
-}
-
-func newScope(lexical _stash, variable _stash, this *_object) *_scope {
-	return &_scope{
-		lexical:  lexical,
-		variable: variable,
-		this:     this,
-	}
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/script.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/script.go
deleted file mode 100644
index ed8aebbf4..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/script.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package otto
-
-import (
-	"bytes"
-	"encoding/gob"
-	"errors"
-
-	"github.com/robertkrimen/otto/parser"
-)
-
-var ErrVersion = errors.New("version mismatch")
-
-var scriptVersion = "2014-04-13/1"
-
-// Script is a handle for some (reusable) JavaScript.
-// Passing a Script value to a run method will evaluate the JavaScript.
-//
-type Script struct {
-	version  string
-	program  *_nodeProgram
-	filename string
-	src      string
-}
-
-// Compile will parse the given source and return a Script value or nil and
-// an error if there was a problem during compilation.
-//
-//      script, err := vm.Compile("", `var abc; if (!abc) abc = 0; abc += 2; abc;`)
-//      vm.Run(script)
-//
-func (self *Otto) Compile(filename string, src interface{}) (*Script, error) {
-	{
-		src, err := parser.ReadSource(filename, src)
-		if err != nil {
-			return nil, err
-		}
-
-		program, err := self.runtime.parse(filename, src)
-		if err != nil {
-			return nil, err
-		}
-
-		cmpl_program := cmpl_parse(program)
-
-		script := &Script{
-			version:  scriptVersion,
-			program:  cmpl_program,
-			filename: filename,
-			src:      string(src),
-		}
-
-		return script, nil
-	}
-}
-
-func (self *Script) String() string {
-	return "// " + self.filename + "\n" + self.src
-}
-
-// MarshalBinary will marshal a script into a binary form. A marshalled script
-// that is later unmarshalled can be executed on the same version of the otto runtime.
-//
-// The binary format can change at any time and should be considered unspecified and opaque.
-//
-func (self *Script) marshalBinary() ([]byte, error) {
-	var bfr bytes.Buffer
-	encoder := gob.NewEncoder(&bfr)
-	err := encoder.Encode(self.version)
-	if err != nil {
-		return nil, err
-	}
-	err = encoder.Encode(self.program)
-	if err != nil {
-		return nil, err
-	}
-	err = encoder.Encode(self.filename)
-	if err != nil {
-		return nil, err
-	}
-	err = encoder.Encode(self.src)
-	if err != nil {
-		return nil, err
-	}
-	return bfr.Bytes(), nil
-}
-
-// UnmarshalBinary will vivify a marshalled script into something usable. If the script was
-// originally marshalled on a different version of the otto runtime, then this method
-// will return an error.
-//
-// The binary format can change at any time and should be considered unspecified and opaque.
-//
-func (self *Script) unmarshalBinary(data []byte) error {
-	decoder := gob.NewDecoder(bytes.NewReader(data))
-	err := decoder.Decode(&self.version)
-	if err != nil {
-		goto error
-	}
-	if self.version != scriptVersion {
-		err = ErrVersion
-		goto error
-	}
-	err = decoder.Decode(&self.program)
-	if err != nil {
-		goto error
-	}
-	err = decoder.Decode(&self.filename)
-	if err != nil {
-		goto error
-	}
-	err = decoder.Decode(&self.src)
-	if err != nil {
-		goto error
-	}
-	return nil
-error:
-	self.version = ""
-	self.program = nil
-	self.filename = ""
-	self.src = ""
-	return err
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/stash.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/stash.go
deleted file mode 100644
index 0d3ffa511..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/stash.go
+++ /dev/null
@@ -1,296 +0,0 @@
-package otto
-
-import (
-	"fmt"
-)
-
-// ======
-// _stash
-// ======
-
-type _stash interface {
-	hasBinding(string) bool            //
-	createBinding(string, bool, Value) // CreateMutableBinding
-	setBinding(string, Value, bool)    // SetMutableBinding
-	getBinding(string, bool) Value     // GetBindingValue
-	deleteBinding(string) bool         //
-	setValue(string, Value, bool)      // createBinding + setBinding
-
-	outer() _stash
-	runtime() *_runtime
-
-	newReference(string, bool, _at) _reference
-
-	clone(clone *_clone) _stash
-}
-
-// ==========
-// _objectStash
-// ==========
-
-type _objectStash struct {
-	_runtime *_runtime
-	_outer   _stash
-	object   *_object
-}
-
-func (self *_objectStash) runtime() *_runtime {
-	return self._runtime
-}
-
-func (runtime *_runtime) newObjectStash(object *_object, outer _stash) *_objectStash {
-	if object == nil {
-		object = runtime.newBaseObject()
-		object.class = "environment"
-	}
-	return &_objectStash{
-		_runtime: runtime,
-		_outer:   outer,
-		object:   object,
-	}
-}
-
-func (in *_objectStash) clone(clone *_clone) _stash {
-	out, exists := clone.objectStash(in)
-	if exists {
-		return out
-	}
-	*out = _objectStash{
-		clone.runtime,
-		clone.stash(in._outer),
-		clone.object(in.object),
-	}
-	return out
-}
-
-func (self *_objectStash) hasBinding(name string) bool {
-	return self.object.hasProperty(name)
-}
-
-func (self *_objectStash) createBinding(name string, deletable bool, value Value) {
-	if self.object.hasProperty(name) {
-		panic(hereBeDragons())
-	}
-	mode := _propertyMode(0111)
-	if !deletable {
-		mode = _propertyMode(0110)
-	}
-	// TODO False?
-	self.object.defineProperty(name, value, mode, false)
-}
-
-func (self *_objectStash) setBinding(name string, value Value, strict bool) {
-	self.object.put(name, value, strict)
-}
-
-func (self *_objectStash) setValue(name string, value Value, throw bool) {
-	if !self.hasBinding(name) {
-		self.createBinding(name, true, value) // Configurable by default
-	} else {
-		self.setBinding(name, value, throw)
-	}
-}
-
-func (self *_objectStash) getBinding(name string, throw bool) Value {
-	if self.object.hasProperty(name) {
-		return self.object.get(name)
-	}
-	if throw { // strict?
-		panic(self._runtime.panicReferenceError("Not Defined", name))
-	}
-	return Value{}
-}
-
-func (self *_objectStash) deleteBinding(name string) bool {
-	return self.object.delete(name, false)
-}
-
-func (self *_objectStash) outer() _stash {
-	return self._outer
-}
-
-func (self *_objectStash) newReference(name string, strict bool, at _at) _reference {
-	return newPropertyReference(self._runtime, self.object, name, strict, at)
-}
-
-// =========
-// _dclStash
-// =========
-
-type _dclStash struct {
-	_runtime *_runtime
-	_outer   _stash
-	property map[string]_dclProperty
-}
-
-type _dclProperty struct {
-	value     Value
-	mutable   bool
-	deletable bool
-	readable  bool
-}
-
-func (runtime *_runtime) newDeclarationStash(outer _stash) *_dclStash {
-	return &_dclStash{
-		_runtime: runtime,
-		_outer:   outer,
-		property: map[string]_dclProperty{},
-	}
-}
-
-func (in *_dclStash) clone(clone *_clone) _stash {
-	out, exists := clone.dclStash(in)
-	if exists {
-		return out
-	}
-	property := make(map[string]_dclProperty, len(in.property))
-	for index, value := range in.property {
-		property[index] = clone.dclProperty(value)
-	}
-	*out = _dclStash{
-		clone.runtime,
-		clone.stash(in._outer),
-		property,
-	}
-	return out
-}
-
-func (self *_dclStash) hasBinding(name string) bool {
-	_, exists := self.property[name]
-	return exists
-}
-
-func (self *_dclStash) runtime() *_runtime {
-	return self._runtime
-}
-
-func (self *_dclStash) createBinding(name string, deletable bool, value Value) {
-	_, exists := self.property[name]
-	if exists {
-		panic(fmt.Errorf("createBinding: %s: already exists", name))
-	}
-	self.property[name] = _dclProperty{
-		value:     value,
-		mutable:   true,
-		deletable: deletable,
-		readable:  false,
-	}
-}
-
-func (self *_dclStash) setBinding(name string, value Value, strict bool) {
-	property, exists := self.property[name]
-	if !exists {
-		panic(fmt.Errorf("setBinding: %s: missing", name))
-	}
-	if property.mutable {
-		property.value = value
-		self.property[name] = property
-	} else {
-		self._runtime.typeErrorResult(strict)
-	}
-}
-
-func (self *_dclStash) setValue(name string, value Value, throw bool) {
-	if !self.hasBinding(name) {
-		self.createBinding(name, false, value) // NOT deletable by default
-	} else {
-		self.setBinding(name, value, throw)
-	}
-}
-
-// FIXME This is called a __lot__
-func (self *_dclStash) getBinding(name string, throw bool) Value {
-	property, exists := self.property[name]
-	if !exists {
-		panic(fmt.Errorf("getBinding: %s: missing", name))
-	}
-	if !property.mutable && !property.readable {
-		if throw { // strict?
-			panic(self._runtime.panicTypeError())
-		}
-		return Value{}
-	}
-	return property.value
-}
-
-func (self *_dclStash) deleteBinding(name string) bool {
-	property, exists := self.property[name]
-	if !exists {
-		return true
-	}
-	if !property.deletable {
-		return false
-	}
-	delete(self.property, name)
-	return true
-}
-
-func (self *_dclStash) outer() _stash {
-	return self._outer
-}
-
-func (self *_dclStash) newReference(name string, strict bool, _ _at) _reference {
-	return &_stashReference{
-		name: name,
-		base: self,
-	}
-}
-
-// ========
-// _fnStash
-// ========
-
-type _fnStash struct {
-	_dclStash
-	arguments           *_object
-	indexOfArgumentName map[string]string
-}
-
-func (runtime *_runtime) newFunctionStash(outer _stash) *_fnStash {
-	return &_fnStash{
-		_dclStash: _dclStash{
-			_runtime: runtime,
-			_outer:   outer,
-			property: map[string]_dclProperty{},
-		},
-	}
-}
-
-func (in *_fnStash) clone(clone *_clone) _stash {
-	out, exists := clone.fnStash(in)
-	if exists {
-		return out
-	}
-	dclStash := in._dclStash.clone(clone).(*_dclStash)
-	index := make(map[string]string, len(in.indexOfArgumentName))
-	for name, value := range in.indexOfArgumentName {
-		index[name] = value
-	}
-	*out = _fnStash{
-		_dclStash:           *dclStash,
-		arguments:           clone.object(in.arguments),
-		indexOfArgumentName: index,
-	}
-	return out
-}
-
-func getStashProperties(stash _stash) (keys []string) {
-	switch vars := stash.(type) {
-	case *_dclStash:
-		for k := range vars.property {
-			keys = append(keys, k)
-		}
-	case *_fnStash:
-		for k := range vars.property {
-			keys = append(keys, k)
-		}
-	case *_objectStash:
-		for k := range vars.object.property {
-			keys = append(keys, k)
-		}
-	default:
-		panic("unknown stash type")
-	}
-
-	return
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go
deleted file mode 100644
index a25ca8b9c..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go
+++ /dev/null
@@ -1,669 +0,0 @@
-// This file was AUTOMATICALLY GENERATED by terst-import (smuggol) from github.com/robertkrimen/terst
-
-/*
-Package terst is a terse (terst = test + terse), easy-to-use testing library for Go.
-
-terst is compatible with (and works via) the standard testing package: http://golang.org/pkg/testing
-
-    var is = terst.Is
-
-    func Test(t *testing.T) {
-        terst.Terst(t, func() {
-            is("abc", "abc")
-
-            is(1, ">", 0)
-
-            var abc []int
-            is(abc, nil)
-        }
-    }
-
-Do not import terst directly, instead use `terst-import` to copy it into your testing environment:
-
-https://github.com/robertkrimen/terst/tree/master/terst-import
-
-    $ go get github.com/robertkrimen/terst/terst-import
-
-    $ terst-import
-
-*/
-package terst
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"math/big"
-	"reflect"
-	"regexp"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// Is compares two values (got & expect) and returns true if the comparison is true,
-// false otherwise. In addition, if the comparison is false, Is will report the error
-// in a manner similar to testing.T.Error(...). Is also takes an optional argument,
-// a comparator, that changes how the comparison is made.  The following
-// comparators are available:
-//
-//      ==      # got == expect (default)
-//      !=      # got != expect
-//
-//      >       # got > expect (float32, uint, uint16, int, int64, ...)
-//      >=      # got >= expect
-//      <       # got < expect
-//      <=      # got <= expect
-//
-//      =~      # regexp.MustCompile(expect).Match{String}(got)
-//      !~      # !regexp.MustCompile(expect).Match{String}(got)
-//
-// Basic usage with the default comparator (==):
-//
-//      Is(<got>, <expect>)
-//
-// Specifying a different comparator:
-//
-//      Is(<got>, <comparator>, <expect>)
-//
-// A simple comparison:
-//
-//      Is(2 + 2, 4)
-//
-// A bit trickier:
-//
-//      Is(1, ">", 0)
-//      Is(2 + 2, "!=", 5)
-//      Is("Nothing happens.", "=~", `ing(\s+)happens\.$`)
-//
-// Is should only be called under a Terst(t, ...) call. For a standalone version,
-// use IsErr. If no scope is found and the comparison is false, then Is will panic the error.
-//
-func Is(arguments ...interface{}) bool {
-	err := IsErr(arguments...)
-	if err != nil {
-		call := Caller()
-		if call == nil {
-			panic(err)
-		}
-		call.Error(err)
-		return false
-	}
-	return true
-}
-
-type (
-	// ErrFail indicates a comparison failure (e.g. 0 > 1).
-	ErrFail error
-
-	// ErrInvalid indicates an invalid comparison (e.g. bool == string).
-	ErrInvalid error
-)
-
-var errInvalid = errors.New("invalid")
-
-var registry = struct {
-	table map[uintptr]*_scope
-	lock  sync.RWMutex
-}{
-	table: map[uintptr]*_scope{},
-}
-
-func registerScope(pc uintptr, scope *_scope) {
-	registry.lock.Lock()
-	defer registry.lock.Unlock()
-	registry.table[pc] = scope
-}
-
-func scope() *_scope {
-	scope, _ := findScope()
-	return scope
-}
-
-func floatCompare(a float64, b float64) int {
-	if a > b {
-		return 1
-	} else if a < b {
-		return -1
-	}
-	// NaN == NaN
-	return 0
-}
-
-func bigIntCompare(a *big.Int, b *big.Int) int {
-	return a.Cmp(b)
-}
-
-func bigInt(value int64) *big.Int {
-	return big.NewInt(value)
-}
-
-func bigUint(value uint64) *big.Int {
-	return big.NewInt(0).SetUint64(value)
-}
-
-type _toString interface {
-	String() string
-}
-
-func toString(value interface{}) (string, error) {
-	switch value := value.(type) {
-	case string:
-		return value, nil
-	case _toString:
-		return value.String(), nil
-	case error:
-		return value.Error(), nil
-	}
-	return "", errInvalid
-}
-
-func matchString(got string, expect *regexp.Regexp) (int, error) {
-	if expect.MatchString(got) {
-		return 0, nil
-	}
-	return -1, nil
-}
-
-func match(got []byte, expect *regexp.Regexp) (int, error) {
-	if expect.Match(got) {
-		return 0, nil
-	}
-	return -1, nil
-}
-
-func compareMatch(got, expect interface{}) (int, error) {
-	switch got := got.(type) {
-	case []byte:
-		switch expect := expect.(type) {
-		case string:
-			matcher, err := regexp.Compile(expect)
-			if err != nil {
-				return 0, err
-			}
-			return match(got, matcher)
-		case *regexp.Regexp:
-			return match(got, expect)
-		}
-	default:
-		if got, err := toString(got); err == nil {
-			switch expect := expect.(type) {
-			case string:
-				matcher, err := regexp.Compile(expect)
-				if err != nil {
-					return 0, err
-				}
-				return matchString(got, matcher)
-			case *regexp.Regexp:
-				return matchString(got, expect)
-			}
-		} else {
-			return 0, err
-		}
-	}
-	return 0, errInvalid
-}
-
-func floatPromote(value reflect.Value) (float64, error) {
-	kind := value.Kind()
-	if reflect.Int <= kind && kind <= reflect.Int64 {
-		return float64(value.Int()), nil
-	}
-	if reflect.Uint <= kind && kind <= reflect.Uint64 {
-		return float64(value.Uint()), nil
-	}
-	if reflect.Float32 <= kind && kind <= reflect.Float64 {
-		return value.Float(), nil
-	}
-	return 0, errInvalid
-}
-
-func bigIntPromote(value reflect.Value) (*big.Int, error) {
-	kind := value.Kind()
-	if reflect.Int <= kind && kind <= reflect.Int64 {
-		return bigInt(value.Int()), nil
-	}
-	if reflect.Uint <= kind && kind <= reflect.Uint64 {
-		return bigUint(value.Uint()), nil
-	}
-	return nil, errInvalid
-}
-
-func compareOther(got, expect interface{}) (int, error) {
-	{
-		switch expect.(type) {
-		case float32, float64:
-			return compareNumber(got, expect)
-		case uint, uint8, uint16, uint32, uint64:
-			return compareNumber(got, expect)
-		case int, int8, int16, int32, int64:
-			return compareNumber(got, expect)
-		case string:
-			var err error
-			got, err = toString(got)
-			if err != nil {
-				return 0, err
-			}
-		case nil:
-			got := reflect.ValueOf(got)
-			switch got.Kind() {
-			case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface:
-				if got.IsNil() {
-					return 0, nil
-				}
-				return -1, nil
-			case reflect.Invalid: // reflect.Invalid: var abc interface{} = nil
-				return 0, nil
-			}
-			return 0, errInvalid
-		}
-	}
-
-	if reflect.ValueOf(got).Type() != reflect.ValueOf(expect).Type() {
-		return 0, errInvalid
-	}
-
-	if reflect.DeepEqual(got, expect) {
-		return 0, nil
-	}
-	return -1, nil
-}
-
-func compareNumber(got, expect interface{}) (int, error) {
-	{
-		got := reflect.ValueOf(got)
-		k0 := got.Kind()
-		expect := reflect.ValueOf(expect)
-		k1 := expect.Kind()
-		if reflect.Float32 <= k0 && k0 <= reflect.Float64 ||
-			reflect.Float32 <= k1 && k1 <= reflect.Float64 {
-			got, err := floatPromote(got)
-			if err != nil {
-				return 0, err
-			}
-			expect, err := floatPromote(expect)
-			if err != nil {
-				return 0, err
-			}
-			return floatCompare(got, expect), nil
-		} else {
-			got, err := bigIntPromote(got)
-			if err != nil {
-				return 0, err
-			}
-			expect, err := bigIntPromote(expect)
-			if err != nil {
-				return 0, err
-			}
-			return got.Cmp(expect), nil
-		}
-	}
-
-	return 0, errInvalid
-}
-
-// IsErr compares two values (got & expect) and returns nil if the comparison is true, an ErrFail if
-// the comparison is false, or an ErrInvalid if the comparison is invalid. IsErr also
-// takes an optional argument, a comparator, that changes how the comparison is made.
-//
-// Is & IsErr are similar but different:
-//
-//      Is(...)     // Should only be called within a Terst(...) call
-//      IsErr(...)  // A standalone comparator, the same as Is, just without the automatic reporting
-//
-func IsErr(arguments ...interface{}) error {
-	var got, expect interface{}
-	comparator := "=="
-	switch len(arguments) {
-	case 0, 1:
-		return fmt.Errorf("invalid number of arguments to IsErr: %d", len(arguments))
-	case 2:
-		got, expect = arguments[0], arguments[1]
-	default:
-		if value, ok := arguments[1].(string); ok {
-			comparator = value
-		} else {
-			return fmt.Errorf("invalid comparator: %v", arguments[1])
-		}
-		got, expect = arguments[0], arguments[2]
-	}
-
-	var result int
-	var err error
-
-	switch comparator {
-	case "<", "<=", ">", ">=":
-		result, err = compareNumber(got, expect)
-	case "=~", "!~":
-		result, err = compareMatch(got, expect)
-	case "==", "!=":
-		result, err = compareOther(got, expect)
-	default:
-		return fmt.Errorf("invalid comparator: %s", comparator)
-	}
-
-	if err == errInvalid {
-		return ErrInvalid(fmt.Errorf(
-			"\nINVALID (%s):\n        got: %v (%T)\n   expected: %v (%T)",
-			comparator,
-			got, got,
-			expect, expect,
-		))
-	} else if err != nil {
-		return err
-	}
-
-	equality, pass := false, false
-
-	switch comparator {
-	case "==", "=~":
-		equality = true
-		pass = result == 0
-	case "!=", "!~":
-		equality = true
-		pass = result != 0
-	case "<":
-		pass = result < 0
-	case "<=":
-		pass = result <= 0
-	case ">":
-		pass = result > 0
-	case ">=":
-		pass = result >= 0
-	}
-
-	if !pass {
-		if equality {
-			if comparator[1] == '~' {
-				if value, ok := got.([]byte); ok {
-					return ErrFail(fmt.Errorf(
-						"\nFAIL (%s)\n     got: %s %v%s\nexpected: %v%s",
-						comparator,
-						value, got, typeKindString(got),
-						expect, typeKindString(expect),
-					))
-				}
-			}
-			return ErrFail(fmt.Errorf(
-				"\nFAIL (%s)\n     got: %v%s\nexpected: %v%s",
-				comparator,
-				got, typeKindString(got),
-				expect, typeKindString(expect),
-			))
-		}
-		return ErrFail(fmt.Errorf(
-			"\nFAIL (%s)\n     got: %v%s\nexpected: %s %v%s",
-			comparator,
-			got, typeKindString(got),
-			comparator, expect, typeKindString(expect),
-		))
-	}
-
-	return nil
-}
-
-func typeKindString(value interface{}) string {
-	reflectValue := reflect.ValueOf(value)
-	kind := reflectValue.Kind().String()
-	result := fmt.Sprintf("%T", value)
-	if kind == result {
-		if kind == "string" {
-			return ""
-		}
-		return fmt.Sprintf(" (%T)", value)
-	}
-	return fmt.Sprintf(" (%T=%s)", value, kind)
-}
-
-func (scope *_scope) reset() {
-	scope.name = ""
-	scope.output = scope.output[:]
-	scope.start = time.Time{}
-	scope.duration = 0
-}
-
-// Terst creates a testing scope, where Is can be called and errors will be reported
-// according to the top-level location of the comparison, and not where the Is call
-// actually takes place. For example:
-//
-//      func test(value int) {
-//          Is(value, 5) // <--- This failure is reported below.
-//      }
-//
-//      Terst(t, func(){
-//
-//          Is(2, ">", 3) // <--- An error is reported here.
-//
-//          test(5) // <--- An error is reported here.
-//
-//      })
-//
-func Terst(t *testing.T, arguments ...func()) {
-	scope := &_scope{
-		t: t,
-	}
-
-	pc, _, _, ok := runtime.Caller(1) // TODO Associate with the Test... func
-	if !ok {
-		panic("Here be dragons.")
-	}
-
-	_, scope.testFunc = findTestFunc()
-
-	registerScope(pc, scope)
-
-	for _, fn := range arguments {
-		func() {
-			scope.reset()
-			name := scope.testFunc.Name()
-			index := strings.LastIndex(scope.testFunc.Name(), ".")
-			if index >= 0 {
-				name = name[index+1:] + "(Terst)"
-			} else {
-				name = "(Terst)"
-			}
-			name = "(Terst)"
-			scope.name = name
-			scope.start = time.Now()
-			defer func() {
-				scope.duration = time.Now().Sub(scope.start)
-				if err := recover(); err != nil {
-					scope.t.Fail()
-					scope.report()
-					panic(err)
-				}
-				scope.report()
-			}()
-			fn()
-		}()
-	}
-}
-
-// From "testing"
-func (scope *_scope) report() {
-	format := "~~~ %s: (Terst)\n%s"
-	if scope.t.Failed() {
-		fmt.Printf(format, "FAIL", scope.output)
-	} else if testing.Verbose() && len(scope.output) > 0 {
-		fmt.Printf(format, "PASS", scope.output)
-	}
-}
-
-func (scope *_scope) log(call _entry, str string) {
-	scope.mu.Lock()
-	defer scope.mu.Unlock()
-	scope.output = append(scope.output, decorate(call, str)...)
-}
-
-// decorate prefixes the string with the file and line of the call site
-// and inserts the final newline if needed and indentation tabs for formascing.
-func decorate(call _entry, s string) string {
-
-	file, line := call.File, call.Line
-	if call.PC > 0 {
-		// Truncate file name at last file name separator.
-		if index := strings.LastIndex(file, "/"); index >= 0 {
-			file = file[index+1:]
-		} else if index = strings.LastIndex(file, "\\"); index >= 0 {
-			file = file[index+1:]
-		}
-	} else {
-		file = "???"
-		line = 1
-	}
-	buf := new(bytes.Buffer)
-	// Every line is indented at least one tab.
-	buf.WriteByte('\t')
-	fmt.Fprintf(buf, "%s:%d: ", file, line)
-	lines := strings.Split(s, "\n")
-	if l := len(lines); l > 1 && lines[l-1] == "" {
-		lines = lines[:l-1]
-	}
-	for i, line := range lines {
-		if i > 0 {
-			// Second and subsequent lines are indented an extra tab.
-			buf.WriteString("\n\t\t")
-		}
-		buf.WriteString(line)
-	}
-	buf.WriteByte('\n')
-	return buf.String()
-}
-
-func findScope() (*_scope, _entry) {
-	registry.lock.RLock()
-	defer registry.lock.RUnlock()
-	table := registry.table
-	depth := 2 // Starting depth
-	call := _entry{}
-	for {
-		pc, _, _, ok := runtime.Caller(depth)
-		if !ok {
-			break
-		}
-		if scope, exists := table[pc]; exists {
-			pc, file, line, _ := runtime.Caller(depth - 3) // Terst(...) + func(){}() + fn() => ???()
-			call.PC = pc
-			call.File = file
-			call.Line = line
-			return scope, call
-		}
-		depth++
-	}
-	return nil, _entry{}
-}
-
-// Call is a reference to a line immediately under a Terst testing scope.
-type Call struct {
-	scope *_scope
-	entry _entry
-}
-
-// Caller will search the stack, looking for a Terst testing scope. If a scope
-// is found, then Caller returns a Call for logging errors, accessing testing.T, etc.
-// If no scope is found, Caller returns nil.
-func Caller() *Call {
-	scope, entry := findScope()
-	if scope == nil {
-		return nil
-	}
-	return &Call{
-		scope: scope,
-		entry: entry,
-	}
-}
-
-// TestFunc returns the *runtime.Func entry for the top-level Test...(t testing.T)
-// function.
-func (cl *Call) TestFunc() *runtime.Func {
-	return cl.scope.testFunc
-}
-
-// T returns the original testing.T passed to Terst(...)
-func (cl *Call) T() *testing.T {
-	return cl.scope.t
-}
-
-// Log is the terst version of `testing.T.Log`
-func (cl *Call) Log(arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
-}
-
-// Logf is the terst version of `testing.T.Logf`
-func (cl *Call) Logf(format string, arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
-}
-
-// Error is the terst version of `testing.T.Error`
-func (cl *Call) Error(arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
-	cl.scope.t.Fail()
-}
-
-// Errorf is the terst version of `testing.T.Errorf`
-func (cl *Call) Errorf(format string, arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
-	cl.scope.t.Fail()
-}
-
-// Skip is the terst version of `testing.T.Skip`
-func (cl *Call) Skip(arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
-	cl.scope.t.SkipNow()
-}
-
-// Skipf is the terst version of `testing.T.Skipf`
-func (cl *Call) Skipf(format string, arguments ...interface{}) {
-	cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
-	cl.scope.t.SkipNow()
-}
-
-type _scope struct {
-	t        *testing.T
-	testFunc *runtime.Func
-	name     string
-	mu       sync.RWMutex
-	output   []byte
-	start    time.Time
-	duration time.Duration
-}
-
-type _entry struct {
-	PC   uintptr
-	File string
-	Line int
-	Func *runtime.Func
-}
-
-func _findFunc(match string) (_entry, *runtime.Func) {
-	depth := 2 // Starting depth
-	for {
-		pc, file, line, ok := runtime.Caller(depth)
-		if !ok {
-			break
-		}
-		fn := runtime.FuncForPC(pc)
-		name := fn.Name()
-		if index := strings.LastIndex(name, match); index >= 0 {
-			// Assume we have an instance of TestXyzzy in a _test file
-			return _entry{
-				PC:   pc,
-				File: file,
-				Line: line,
-				Func: fn,
-			}, fn
-		}
-		depth++
-	}
-	return _entry{}, nil
-}
-
-func findTestFunc() (_entry, *runtime.Func) {
-	return _findFunc(".Test")
-}
-
-func findTerstFunc() (_entry, *runtime.Func) {
-	return _findFunc(".Terst")
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/test/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/test/Makefile
deleted file mode 100644
index ac76fdeac..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/test/Makefile
+++ /dev/null
@@ -1,26 +0,0 @@
-.PHONY: test fetch clean build err report
-
-TESTER := tester
-
-test: $(TESTER)
-	for test in test-*.js; do ./$^ -test=true $$test 1>/dev/null || exit 1; done
-	@echo PASS
-
-report: $(TESTER)
-	./$^ -report | grep -v "MT READY"
-
-fetch: $(TESTER)
-	./$^ fetch
-
-build:
-	go build -a -o $(TESTER)
-
-$(TESTER): tester.go
-	$(MAKE) build
-
-clean:
-	rm -f test-*.js
-	rm -f $(TESTER)
-
-err: $(TESTER)
-	for test in test-*.js; do ./$^ $$test; done 2>$@
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/test/tester.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/test/tester.go
deleted file mode 100644
index ea694fd8d..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/test/tester.go
+++ /dev/null
@@ -1,196 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"regexp"
-	"strings"
-	"sync"
-	"text/tabwriter"
-
-	"github.com/robertkrimen/otto"
-	"github.com/robertkrimen/otto/parser"
-)
-
-var flag_test *bool = flag.Bool("test", false, "")
-var flag_report *bool = flag.Bool("report", false, "")
-
-var match_ReferenceError_not_defined = regexp.MustCompile(`^ReferenceError: \S+ is not defined$`)
-var match_lookahead = regexp.MustCompile(`Invalid regular expression: re2: Invalid \(\?[=!]\) <lookahead>`)
-var match_backreference = regexp.MustCompile(`Invalid regular expression: re2: Invalid \\\d <backreference>`)
-var match_TypeError_undefined = regexp.MustCompile(`^TypeError: Cannot access member '[^']+' of undefined$`)
-
-var target = map[string]string{
-	"test-angular-bindonce.js": "fail",  // (anonymous): Line 1:944 Unexpected token ( (and 40 more errors)
-	"test-jsforce.js":          "fail",  // (anonymous): Line 9:28329 RuneError (and 5 more errors)
-	"test-chaplin.js":          "parse", // Error: Chaplin requires Common.js or AMD modules
-	"test-dropbox.js.js":       "parse", // Error: dropbox.js loaded in an unsupported JavaScript environment.
-	"test-epitome.js":          "parse", // TypeError: undefined is not a function
-	"test-portal.js":           "parse", // TypeError
-	"test-reactive-coffee.js":  "parse", // Dependencies are not met for reactive: _ and $ not found
-	"test-scriptaculous.js":    "parse", // script.aculo.us requires the Prototype JavaScript framework >= 1.6.0.3
-	"test-waypoints.js":        "parse", // TypeError: undefined is not a function
-	"test-webuploader.js":      "parse", // Error: `jQuery` is undefined
-	"test-xuijs.js":            "parse", // TypeError: undefined is not a function
-}
-
-// http://cdnjs.com/
-// http://api.cdnjs.com/libraries
-
-func fetch(name, location string) error {
-	response, err := http.Get(location)
-	if err != nil {
-		return err
-	}
-	defer response.Body.Close()
-	body, err := ioutil.ReadAll(response.Body)
-	if err != nil {
-		return err
-	}
-
-	if !strings.HasSuffix(location, ".js") {
-		return nil
-	}
-
-	filename := "test-" + name + ".js"
-	fmt.Println(filename, len(body))
-	return ioutil.WriteFile(filename, body, 0644)
-}
-
-func test(filename string) error {
-	script, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return err
-	}
-
-	if !*flag_report {
-		fmt.Fprintln(os.Stdout, filename, len(script))
-	}
-
-	parse := false
-	option := target[filename]
-
-	if option != "parse" {
-		vm := otto.New()
-		_, err = vm.Run(string(script))
-		if err != nil {
-			value := err.Error()
-			switch {
-			case match_ReferenceError_not_defined.MatchString(value):
-			case match_TypeError_undefined.MatchString(value):
-			case match_lookahead.MatchString(value):
-			case match_backreference.MatchString(value):
-			default:
-				return err
-			}
-			parse = true
-		}
-	}
-
-	if parse {
-		_, err = parser.ParseFile(nil, filename, string(script), parser.IgnoreRegExpErrors)
-		if err != nil {
-			return err
-		}
-		target[filename] = "parse"
-	}
-
-	return nil
-}
-
-func main() {
-	flag.Parse()
-
-	filename := ""
-
-	err := func() error {
-
-		if flag.Arg(0) == "fetch" {
-			response, err := http.Get("http://api.cdnjs.com/libraries")
-			if err != nil {
-				return err
-			}
-			defer response.Body.Close()
-			body, err := ioutil.ReadAll(response.Body)
-			if err != nil {
-				return err
-			}
-
-			var tmp map[string]interface{}
-
-			err = json.Unmarshal(body, &tmp)
-			if err != nil {
-				return err
-			}
-
-			var wg sync.WaitGroup
-
-			for _, value := range tmp["results"].([]interface{}) {
-				wg.Add(1)
-				library := value.(map[string]interface{})
-				go func() {
-					defer wg.Done()
-					fetch(library["name"].(string), library["latest"].(string))
-				}()
-			}
-
-			wg.Wait()
-
-			return nil
-		}
-
-		if *flag_report {
-			files, err := ioutil.ReadDir(".")
-			if err != nil {
-				return err
-			}
-			writer := tabwriter.NewWriter(os.Stdout, 0, 8, 0, '\t', 0)
-			fmt.Fprintln(writer, "", "\t| Status")
-			fmt.Fprintln(writer, "---", "\t| ---")
-			for _, file := range files {
-				filename := file.Name()
-				if !strings.HasPrefix(filename, "test-") {
-					continue
-				}
-				err := test(filename)
-				option := target[filename]
-				name := strings.TrimPrefix(strings.TrimSuffix(filename, ".js"), "test-")
-				if err == nil {
-					switch option {
-					case "":
-						fmt.Fprintln(writer, name, "\t| pass")
-					case "parse":
-						fmt.Fprintln(writer, name, "\t| pass (parse)")
-					case "re2":
-						continue
-						fmt.Fprintln(writer, name, "\t| unknown (re2)")
-					}
-				} else {
-					fmt.Fprintln(writer, name, "\t| fail")
-				}
-			}
-			writer.Flush()
-			return nil
-		}
-
-		filename = flag.Arg(0)
-		return test(filename)
-
-	}()
-	if err != nil {
-		if filename != "" {
-			if *flag_test && target[filename] == "fail" {
-				goto exit
-			}
-			fmt.Fprintf(os.Stderr, "%s: %s\n", filename, err.Error())
-		} else {
-			fmt.Fprintln(os.Stderr, err)
-		}
-		os.Exit(64)
-	}
-exit:
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/token/Makefile
deleted file mode 100644
index 1e85c7348..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-token_const.go: tokenfmt
-	./$^ | gofmt > $@
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/token/README.markdown
deleted file mode 100644
index ff3b16104..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/README.markdown
+++ /dev/null
@@ -1,171 +0,0 @@
-# token
---
-    import "github.com/robertkrimen/otto/token"
-
-Package token defines constants representing the lexical tokens of JavaScript
-(ECMA5).
-
-## Usage
-
-```go
-const (
-	ILLEGAL
-	EOF
-	COMMENT
-	KEYWORD
-
-	STRING
-	BOOLEAN
-	NULL
-	NUMBER
-	IDENTIFIER
-
-	PLUS      // +
-	MINUS     // -
-	MULTIPLY  // *
-	SLASH     // /
-	REMAINDER // %
-
-	AND                  // &
-	OR                   // |
-	EXCLUSIVE_OR         // ^
-	SHIFT_LEFT           // <<
-	SHIFT_RIGHT          // >>
-	UNSIGNED_SHIFT_RIGHT // >>>
-	AND_NOT              // &^
-
-	ADD_ASSIGN       // +=
-	SUBTRACT_ASSIGN  // -=
-	MULTIPLY_ASSIGN  // *=
-	QUOTIENT_ASSIGN  // /=
-	REMAINDER_ASSIGN // %=
-
-	AND_ASSIGN                  // &=
-	OR_ASSIGN                   // |=
-	EXCLUSIVE_OR_ASSIGN         // ^=
-	SHIFT_LEFT_ASSIGN           // <<=
-	SHIFT_RIGHT_ASSIGN          // >>=
-	UNSIGNED_SHIFT_RIGHT_ASSIGN // >>>=
-	AND_NOT_ASSIGN              // &^=
-
-	LOGICAL_AND // &&
-	LOGICAL_OR  // ||
-	INCREMENT   // ++
-	DECREMENT   // --
-
-	EQUAL        // ==
-	STRICT_EQUAL // ===
-	LESS         // <
-	GREATER      // >
-	ASSIGN       // =
-	NOT          // !
-
-	BITWISE_NOT // ~
-
-	NOT_EQUAL        // !=
-	STRICT_NOT_EQUAL // !==
-	LESS_OR_EQUAL    // <=
-	GREATER_OR_EQUAL // >=
-
-	LEFT_PARENTHESIS // (
-	LEFT_BRACKET     // [
-	LEFT_BRACE       // {
-	COMMA            // ,
-	PERIOD           // .
-
-	RIGHT_PARENTHESIS // )
-	RIGHT_BRACKET     // ]
-	RIGHT_BRACE       // }
-	SEMICOLON         // ;
-	COLON             // :
-	QUESTION_MARK     // ?
-
-	IF
-	IN
-	DO
-
-	VAR
-	FOR
-	NEW
-	TRY
-
-	THIS
-	ELSE
-	CASE
-	VOID
-	WITH
-
-	WHILE
-	BREAK
-	CATCH
-	THROW
-
-	RETURN
-	TYPEOF
-	DELETE
-	SWITCH
-
-	DEFAULT
-	FINALLY
-
-	FUNCTION
-	CONTINUE
-	DEBUGGER
-
-	INSTANCEOF
-)
-```
-
-#### type Token
-
-```go
-type Token int
-```
-
-Token is the set of lexical tokens in JavaScript (ECMA5).
-
-#### func  IsKeyword
-
-```go
-func IsKeyword(literal string) (Token, bool)
-```
-IsKeyword returns the keyword token if literal is a keyword, a KEYWORD token if
-the literal is a future keyword (const, let, class, super, ...), or 0 if the
-literal is not a keyword.
-
-If the literal is a keyword, IsKeyword returns a second value indicating if the
-literal is considered a future keyword in strict-mode only.
-
-7.6.1.2 Future Reserved Words:
-
-    const
-    class
-    enum
-    export
-    extends
-    import
-    super
-
-7.6.1.2 Future Reserved Words (strict):
-
-    implements
-    interface
-    let
-    package
-    private
-    protected
-    public
-    static
-
-#### func (Token) String
-
-```go
-func (tkn Token) String() string
-```
-String returns the string corresponding to the token. For operators, delimiters,
-and keywords the string is the actual token string (e.g., for the token PLUS,
-the String() is "+"). For all other tokens the string corresponds to the token
-name (e.g. for the token IDENTIFIER, the string is "IDENTIFIER").
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token.go
deleted file mode 100644
index 0e941ac96..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Package token defines constants representing the lexical tokens of JavaScript (ECMA5).
-package token
-
-import (
-	"strconv"
-)
-
-// Token is the set of lexical tokens in JavaScript (ECMA5).
-type Token int
-
-// String returns the string corresponding to the token.
-// For operators, delimiters, and keywords the string is the actual
-// token string (e.g., for the token PLUS, the String() is
-// "+"). For all other tokens the string corresponds to the token
-// name (e.g. for the token IDENTIFIER, the string is "IDENTIFIER").
-//
-func (tkn Token) String() string {
-	if 0 == tkn {
-		return "UNKNOWN"
-	}
-	if tkn < Token(len(token2string)) {
-		return token2string[tkn]
-	}
-	return "token(" + strconv.Itoa(int(tkn)) + ")"
-}
-
-// This is not used for anything
-func (tkn Token) precedence(in bool) int {
-
-	switch tkn {
-	case LOGICAL_OR:
-		return 1
-
-	case LOGICAL_AND:
-		return 2
-
-	case OR, OR_ASSIGN:
-		return 3
-
-	case EXCLUSIVE_OR:
-		return 4
-
-	case AND, AND_ASSIGN, AND_NOT, AND_NOT_ASSIGN:
-		return 5
-
-	case EQUAL,
-		NOT_EQUAL,
-		STRICT_EQUAL,
-		STRICT_NOT_EQUAL:
-		return 6
-
-	case LESS, GREATER, LESS_OR_EQUAL, GREATER_OR_EQUAL, INSTANCEOF:
-		return 7
-
-	case IN:
-		if in {
-			return 7
-		}
-		return 0
-
-	case SHIFT_LEFT, SHIFT_RIGHT, UNSIGNED_SHIFT_RIGHT:
-		fallthrough
-	case SHIFT_LEFT_ASSIGN, SHIFT_RIGHT_ASSIGN, UNSIGNED_SHIFT_RIGHT_ASSIGN:
-		return 8
-
-	case PLUS, MINUS, ADD_ASSIGN, SUBTRACT_ASSIGN:
-		return 9
-
-	case MULTIPLY, SLASH, REMAINDER, MULTIPLY_ASSIGN, QUOTIENT_ASSIGN, REMAINDER_ASSIGN:
-		return 11
-	}
-	return 0
-}
-
-type _keyword struct {
-	token         Token
-	futureKeyword bool
-	strict        bool
-}
-
-// IsKeyword returns the keyword token if literal is a keyword, a KEYWORD token
-// if the literal is a future keyword (const, let, class, super, ...), or 0 if the literal is not a keyword.
-//
-// If the literal is a keyword, IsKeyword returns a second value indicating if the literal
-// is considered a future keyword in strict-mode only.
-//
-// 7.6.1.2 Future Reserved Words:
-//
-//       const
-//       class
-//       enum
-//       export
-//       extends
-//       import
-//       super
-//
-// 7.6.1.2 Future Reserved Words (strict):
-//
-//       implements
-//       interface
-//       let
-//       package
-//       private
-//       protected
-//       public
-//       static
-//
-func IsKeyword(literal string) (Token, bool) {
-	if keyword, exists := keywordTable[literal]; exists {
-		if keyword.futureKeyword {
-			return KEYWORD, keyword.strict
-		}
-		return keyword.token, false
-	}
-	return 0, false
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token_const.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token_const.go
deleted file mode 100644
index b1d83c6de..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/token_const.go
+++ /dev/null
@@ -1,349 +0,0 @@
-package token
-
-const (
-	_ Token = iota
-
-	ILLEGAL
-	EOF
-	COMMENT
-	KEYWORD
-
-	STRING
-	BOOLEAN
-	NULL
-	NUMBER
-	IDENTIFIER
-
-	PLUS      // +
-	MINUS     // -
-	MULTIPLY  // *
-	SLASH     // /
-	REMAINDER // %
-
-	AND                  // &
-	OR                   // |
-	EXCLUSIVE_OR         // ^
-	SHIFT_LEFT           // <<
-	SHIFT_RIGHT          // >>
-	UNSIGNED_SHIFT_RIGHT // >>>
-	AND_NOT              // &^
-
-	ADD_ASSIGN       // +=
-	SUBTRACT_ASSIGN  // -=
-	MULTIPLY_ASSIGN  // *=
-	QUOTIENT_ASSIGN  // /=
-	REMAINDER_ASSIGN // %=
-
-	AND_ASSIGN                  // &=
-	OR_ASSIGN                   // |=
-	EXCLUSIVE_OR_ASSIGN         // ^=
-	SHIFT_LEFT_ASSIGN           // <<=
-	SHIFT_RIGHT_ASSIGN          // >>=
-	UNSIGNED_SHIFT_RIGHT_ASSIGN // >>>=
-	AND_NOT_ASSIGN              // &^=
-
-	LOGICAL_AND // &&
-	LOGICAL_OR  // ||
-	INCREMENT   // ++
-	DECREMENT   // --
-
-	EQUAL        // ==
-	STRICT_EQUAL // ===
-	LESS         // <
-	GREATER      // >
-	ASSIGN       // =
-	NOT          // !
-
-	BITWISE_NOT // ~
-
-	NOT_EQUAL        // !=
-	STRICT_NOT_EQUAL // !==
-	LESS_OR_EQUAL    // <=
-	GREATER_OR_EQUAL // >=
-
-	LEFT_PARENTHESIS // (
-	LEFT_BRACKET     // [
-	LEFT_BRACE       // {
-	COMMA            // ,
-	PERIOD           // .
-
-	RIGHT_PARENTHESIS // )
-	RIGHT_BRACKET     // ]
-	RIGHT_BRACE       // }
-	SEMICOLON         // ;
-	COLON             // :
-	QUESTION_MARK     // ?
-
-	firstKeyword
-	IF
-	IN
-	DO
-
-	VAR
-	FOR
-	NEW
-	TRY
-
-	THIS
-	ELSE
-	CASE
-	VOID
-	WITH
-
-	WHILE
-	BREAK
-	CATCH
-	THROW
-
-	RETURN
-	TYPEOF
-	DELETE
-	SWITCH
-
-	DEFAULT
-	FINALLY
-
-	FUNCTION
-	CONTINUE
-	DEBUGGER
-
-	INSTANCEOF
-	lastKeyword
-)
-
-var token2string = [...]string{
-	ILLEGAL:                     "ILLEGAL",
-	EOF:                         "EOF",
-	COMMENT:                     "COMMENT",
-	KEYWORD:                     "KEYWORD",
-	STRING:                      "STRING",
-	BOOLEAN:                     "BOOLEAN",
-	NULL:                        "NULL",
-	NUMBER:                      "NUMBER",
-	IDENTIFIER:                  "IDENTIFIER",
-	PLUS:                        "+",
-	MINUS:                       "-",
-	MULTIPLY:                    "*",
-	SLASH:                       "/",
-	REMAINDER:                   "%",
-	AND:                         "&",
-	OR:                          "|",
-	EXCLUSIVE_OR:                "^",
-	SHIFT_LEFT:                  "<<",
-	SHIFT_RIGHT:                 ">>",
-	UNSIGNED_SHIFT_RIGHT:        ">>>",
-	AND_NOT:                     "&^",
-	ADD_ASSIGN:                  "+=",
-	SUBTRACT_ASSIGN:             "-=",
-	MULTIPLY_ASSIGN:             "*=",
-	QUOTIENT_ASSIGN:             "/=",
-	REMAINDER_ASSIGN:            "%=",
-	AND_ASSIGN:                  "&=",
-	OR_ASSIGN:                   "|=",
-	EXCLUSIVE_OR_ASSIGN:         "^=",
-	SHIFT_LEFT_ASSIGN:           "<<=",
-	SHIFT_RIGHT_ASSIGN:          ">>=",
-	UNSIGNED_SHIFT_RIGHT_ASSIGN: ">>>=",
-	AND_NOT_ASSIGN:              "&^=",
-	LOGICAL_AND:                 "&&",
-	LOGICAL_OR:                  "||",
-	INCREMENT:                   "++",
-	DECREMENT:                   "--",
-	EQUAL:                       "==",
-	STRICT_EQUAL:                "===",
-	LESS:                        "<",
-	GREATER:                     ">",
-	ASSIGN:                      "=",
-	NOT:                         "!",
-	BITWISE_NOT:                 "~",
-	NOT_EQUAL:                   "!=",
-	STRICT_NOT_EQUAL:            "!==",
-	LESS_OR_EQUAL:               "<=",
-	GREATER_OR_EQUAL:            ">=",
-	LEFT_PARENTHESIS:            "(",
-	LEFT_BRACKET:                "[",
-	LEFT_BRACE:                  "{",
-	COMMA:                       ",",
-	PERIOD:                      ".",
-	RIGHT_PARENTHESIS:           ")",
-	RIGHT_BRACKET:               "]",
-	RIGHT_BRACE:                 "}",
-	SEMICOLON:                   ";",
-	COLON:                       ":",
-	QUESTION_MARK:               "?",
-	IF:                          "if",
-	IN:                          "in",
-	DO:                          "do",
-	VAR:                         "var",
-	FOR:                         "for",
-	NEW:                         "new",
-	TRY:                         "try",
-	THIS:                        "this",
-	ELSE:                        "else",
-	CASE:                        "case",
-	VOID:                        "void",
-	WITH:                        "with",
-	WHILE:                       "while",
-	BREAK:                       "break",
-	CATCH:                       "catch",
-	THROW:                       "throw",
-	RETURN:                      "return",
-	TYPEOF:                      "typeof",
-	DELETE:                      "delete",
-	SWITCH:                      "switch",
-	DEFAULT:                     "default",
-	FINALLY:                     "finally",
-	FUNCTION:                    "function",
-	CONTINUE:                    "continue",
-	DEBUGGER:                    "debugger",
-	INSTANCEOF:                  "instanceof",
-}
-
-var keywordTable = map[string]_keyword{
-	"if": _keyword{
-		token: IF,
-	},
-	"in": _keyword{
-		token: IN,
-	},
-	"do": _keyword{
-		token: DO,
-	},
-	"var": _keyword{
-		token: VAR,
-	},
-	"for": _keyword{
-		token: FOR,
-	},
-	"new": _keyword{
-		token: NEW,
-	},
-	"try": _keyword{
-		token: TRY,
-	},
-	"this": _keyword{
-		token: THIS,
-	},
-	"else": _keyword{
-		token: ELSE,
-	},
-	"case": _keyword{
-		token: CASE,
-	},
-	"void": _keyword{
-		token: VOID,
-	},
-	"with": _keyword{
-		token: WITH,
-	},
-	"while": _keyword{
-		token: WHILE,
-	},
-	"break": _keyword{
-		token: BREAK,
-	},
-	"catch": _keyword{
-		token: CATCH,
-	},
-	"throw": _keyword{
-		token: THROW,
-	},
-	"return": _keyword{
-		token: RETURN,
-	},
-	"typeof": _keyword{
-		token: TYPEOF,
-	},
-	"delete": _keyword{
-		token: DELETE,
-	},
-	"switch": _keyword{
-		token: SWITCH,
-	},
-	"default": _keyword{
-		token: DEFAULT,
-	},
-	"finally": _keyword{
-		token: FINALLY,
-	},
-	"function": _keyword{
-		token: FUNCTION,
-	},
-	"continue": _keyword{
-		token: CONTINUE,
-	},
-	"debugger": _keyword{
-		token: DEBUGGER,
-	},
-	"instanceof": _keyword{
-		token: INSTANCEOF,
-	},
-	"const": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"class": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"enum": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"export": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"extends": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"import": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"super": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-	},
-	"implements": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"interface": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"let": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"package": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"private": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"protected": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"public": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-	"static": _keyword{
-		token:         KEYWORD,
-		futureKeyword: true,
-		strict:        true,
-	},
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/tokenfmt b/Godeps/_workspace/src/github.com/robertkrimen/otto/token/tokenfmt
deleted file mode 100644
index 63dd5d9e6..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/token/tokenfmt
+++ /dev/null
@@ -1,222 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-
-my (%token, @order, @keywords);
-
-{
-    my $keywords;
-    my @const;
-    push @const, <<_END_;
-package token
-
-const(
-    _ Token = iota
-_END_
-
-    for (split m/\n/, <<_END_) {
-ILLEGAL
-EOF
-COMMENT
-KEYWORD
-
-STRING
-BOOLEAN
-NULL
-NUMBER
-IDENTIFIER
-
-PLUS                            +
-MINUS                           -
-MULTIPLY                        *
-SLASH                           /
-REMAINDER                       %
-
-AND                             &
-OR                              |
-EXCLUSIVE_OR                    ^
-SHIFT_LEFT                      <<
-SHIFT_RIGHT                     >>
-UNSIGNED_SHIFT_RIGHT            >>>
-AND_NOT                         &^
-
-ADD_ASSIGN                     +=
-SUBTRACT_ASSIGN                -=
-MULTIPLY_ASSIGN                *=
-QUOTIENT_ASSIGN                /=
-REMAINDER_ASSIGN               %=
-
-AND_ASSIGN                     &=
-OR_ASSIGN                      |=
-EXCLUSIVE_OR_ASSIGN            ^=
-SHIFT_LEFT_ASSIGN              <<=
-SHIFT_RIGHT_ASSIGN             >>=
-UNSIGNED_SHIFT_RIGHT_ASSIGN    >>>=
-AND_NOT_ASSIGN                 &^=
-
-LOGICAL_AND                    &&
-LOGICAL_OR                     ||
-INCREMENT                      ++
-DECREMENT                      --
-
-EQUAL                          ==
-STRICT_EQUAL                   ===
-LESS                           <
-GREATER                        >
-ASSIGN                         =
-NOT                            !
-
-BITWISE_NOT                    ~
-
-NOT_EQUAL                      !=
-STRICT_NOT_EQUAL               !==
-LESS_OR_EQUAL                  <=
-GREATER_OR_EQUAL               <=
-
-LEFT_PARENTHESIS               (
-LEFT_BRACKET                   [
-LEFT_BRACE                     {
-COMMA                          ,
-PERIOD                         .
-
-RIGHT_PARENTHESIS              )
-RIGHT_BRACKET                  ]
-RIGHT_BRACE                    }
-SEMICOLON                      ;
-COLON                          :
-QUESTION_MARK                  ?
-
-firstKeyword
-IF
-IN
-DO
-
-VAR
-FOR
-NEW
-TRY
-
-THIS
-ELSE
-CASE
-VOID
-WITH
-
-WHILE
-BREAK
-CATCH
-THROW
-
-RETURN
-TYPEOF
-DELETE
-SWITCH
-
-DEFAULT
-FINALLY
-
-FUNCTION
-CONTINUE
-DEBUGGER
-
-INSTANCEOF
-lastKeyword
-_END_
-        chomp;
-
-        next if m/^\s*#/;
-
-        my ($name, $symbol) = m/(\w+)\s*(\S+)?/;
-
-        if (defined $symbol) {
-            push @order, $name;
-            push @const, "$name // $symbol";
-            $token{$name} = $symbol;
-        } elsif (defined $name) {
-            $keywords ||= $name eq 'firstKeyword';
-
-            push @const, $name;
-            #$const[-1] .= " Token = iota" if 2 == @const;
-            if ($name =~ m/^([A-Z]+)/) {
-                push @keywords, $name if $keywords;
-                push @order, $name;
-                if ($token{SEMICOLON}) {
-                    $token{$name} = lc $1;
-                } else {
-                    $token{$name} = $name;
-                }
-            }
-        } else {
-            push @const, "";
-        }
-
-    }
-    push @const, ")";
-    print join "\n", @const, "";
-}
-
-{
-    print <<_END_;
-
-var token2string = [...]string{
-_END_
-    for my $name (@order) {
-        print "$name: \"$token{$name}\",\n";
-    }
-    print <<_END_;
-}
-_END_
-
-    print <<_END_;
-
-var keywordTable = map[string]_keyword{
-_END_
-    for my $name (@keywords) {
-        print <<_END_
-			"@{[ lc $name ]}": _keyword{
-				token: $name,
-			},
-_END_
-    }
-
-    for my $name (qw/
-        const
-        class
-        enum
-        export
-        extends
-        import
-        super
-        /) {
-        print <<_END_
-			"$name": _keyword{
-				token: KEYWORD,
-                futureKeyword: true,
-			},
-_END_
-    }
-
-    for my $name (qw/
-        implements
-        interface
-        let
-        package
-        private
-        protected
-        public
-        static
-        /) {
-        print <<_END_
-			"$name": _keyword{
-				token: KEYWORD,
-                futureKeyword: true,
-                strict: true,
-			},
-_END_
-    }
-
-    print <<_END_;
-}
-_END_
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_arguments.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_arguments.go
deleted file mode 100644
index 841d75855..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_arguments.go
+++ /dev/null
@@ -1,106 +0,0 @@
-package otto
-
-import (
-	"strconv"
-)
-
-func (runtime *_runtime) newArgumentsObject(indexOfParameterName []string, stash _stash, length int) *_object {
-	self := runtime.newClassObject("Arguments")
-
-	for index, _ := range indexOfParameterName {
-		name := strconv.FormatInt(int64(index), 10)
-		objectDefineOwnProperty(self, name, _property{Value{}, 0111}, false)
-	}
-
-	self.objectClass = _classArguments
-	self.value = _argumentsObject{
-		indexOfParameterName: indexOfParameterName,
-		stash:                stash,
-	}
-
-	self.prototype = runtime.global.ObjectPrototype
-
-	self.defineProperty("length", toValue_int(length), 0101, false)
-
-	return self
-}
-
-type _argumentsObject struct {
-	indexOfParameterName []string
-	// function(abc, def, ghi)
-	// indexOfParameterName[0] = "abc"
-	// indexOfParameterName[1] = "def"
-	// indexOfParameterName[2] = "ghi"
-	// ...
-	stash _stash
-}
-
-func (in _argumentsObject) clone(clone *_clone) _argumentsObject {
-	indexOfParameterName := make([]string, len(in.indexOfParameterName))
-	copy(indexOfParameterName, in.indexOfParameterName)
-	return _argumentsObject{
-		indexOfParameterName,
-		clone.stash(in.stash),
-	}
-}
-
-func (self _argumentsObject) get(name string) (Value, bool) {
-	index := stringToArrayIndex(name)
-	if index >= 0 && index < int64(len(self.indexOfParameterName)) {
-		name := self.indexOfParameterName[index]
-		if name == "" {
-			return Value{}, false
-		}
-		return self.stash.getBinding(name, false), true
-	}
-	return Value{}, false
-}
-
-func (self _argumentsObject) put(name string, value Value) {
-	index := stringToArrayIndex(name)
-	name = self.indexOfParameterName[index]
-	self.stash.setBinding(name, value, false)
-}
-
-func (self _argumentsObject) delete(name string) {
-	index := stringToArrayIndex(name)
-	self.indexOfParameterName[index] = ""
-}
-
-func argumentsGet(self *_object, name string) Value {
-	if value, exists := self.value.(_argumentsObject).get(name); exists {
-		return value
-	}
-	return objectGet(self, name)
-}
-
-func argumentsGetOwnProperty(self *_object, name string) *_property {
-	property := objectGetOwnProperty(self, name)
-	if value, exists := self.value.(_argumentsObject).get(name); exists {
-		property.value = value
-	}
-	return property
-}
-
-func argumentsDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	if _, exists := self.value.(_argumentsObject).get(name); exists {
-		if !objectDefineOwnProperty(self, name, descriptor, false) {
-			return self.runtime.typeErrorResult(throw)
-		}
-		if value, valid := descriptor.value.(Value); valid {
-			self.value.(_argumentsObject).put(name, value)
-		}
-		return true
-	}
-	return objectDefineOwnProperty(self, name, descriptor, throw)
-}
-
-func argumentsDelete(self *_object, name string, throw bool) bool {
-	if !objectDelete(self, name, throw) {
-		return false
-	}
-	if _, exists := self.value.(_argumentsObject).get(name); exists {
-		self.value.(_argumentsObject).delete(name)
-	}
-	return true
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_array.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_array.go
deleted file mode 100644
index 236376a8e..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_array.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package otto
-
-import (
-	"strconv"
-)
-
-func (runtime *_runtime) newArrayObject(length uint32) *_object {
-	self := runtime.newObject()
-	self.class = "Array"
-	self.defineProperty("length", toValue_uint32(length), 0100, false)
-	self.objectClass = _classArray
-	return self
-}
-
-func isArray(object *_object) bool {
-	return object != nil && (object.class == "Array" || object.class == "GoArray")
-}
-
-func objectLength(object *_object) uint32 {
-	if object == nil {
-		return 0
-	}
-	switch object.class {
-	case "Array":
-		return object.get("length").value.(uint32)
-	case "String":
-		return uint32(object.get("length").value.(int))
-	case "GoArray":
-		return uint32(object.get("length").value.(int))
-	}
-	return 0
-}
-
-func arrayUint32(rt *_runtime, value Value) uint32 {
-	nm := value.number()
-	if nm.kind != numberInteger || !isUint32(nm.int64) {
-		// FIXME
-		panic(rt.panicRangeError())
-	}
-	return uint32(nm.int64)
-}
-
-func arrayDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	lengthProperty := self.getOwnProperty("length")
-	lengthValue, valid := lengthProperty.value.(Value)
-	if !valid {
-		panic("Array.length != Value{}")
-	}
-	length := lengthValue.value.(uint32)
-	if name == "length" {
-		if descriptor.value == nil {
-			return objectDefineOwnProperty(self, name, descriptor, throw)
-		}
-		newLengthValue, isValue := descriptor.value.(Value)
-		if !isValue {
-			panic(self.runtime.panicTypeError())
-		}
-		newLength := arrayUint32(self.runtime, newLengthValue)
-		descriptor.value = toValue_uint32(newLength)
-		if newLength > length {
-			return objectDefineOwnProperty(self, name, descriptor, throw)
-		}
-		if !lengthProperty.writable() {
-			goto Reject
-		}
-		newWritable := true
-		if descriptor.mode&0700 == 0 {
-			// If writable is off
-			newWritable = false
-			descriptor.mode |= 0100
-		}
-		if !objectDefineOwnProperty(self, name, descriptor, throw) {
-			return false
-		}
-		for newLength < length {
-			length -= 1
-			if !self.delete(strconv.FormatInt(int64(length), 10), false) {
-				descriptor.value = toValue_uint32(length + 1)
-				if !newWritable {
-					descriptor.mode &= 0077
-				}
-				objectDefineOwnProperty(self, name, descriptor, false)
-				goto Reject
-			}
-		}
-		if !newWritable {
-			descriptor.mode &= 0077
-			objectDefineOwnProperty(self, name, descriptor, false)
-		}
-	} else if index := stringToArrayIndex(name); index >= 0 {
-		if index >= int64(length) && !lengthProperty.writable() {
-			goto Reject
-		}
-		if !objectDefineOwnProperty(self, strconv.FormatInt(index, 10), descriptor, false) {
-			goto Reject
-		}
-		if index >= int64(length) {
-			lengthProperty.value = toValue_uint32(uint32(index + 1))
-			objectDefineOwnProperty(self, "length", *lengthProperty, false)
-			return true
-		}
-	}
-	return objectDefineOwnProperty(self, name, descriptor, throw)
-Reject:
-	if throw {
-		panic(self.runtime.panicTypeError())
-	}
-	return false
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_boolean.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_boolean.go
deleted file mode 100644
index afc45c69b..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_boolean.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package otto
-
-import (
-	"strconv"
-)
-
-func (runtime *_runtime) newBooleanObject(value Value) *_object {
-	return runtime.newPrimitiveObject("Boolean", toValue_bool(value.bool()))
-}
-
-func booleanToString(value bool) string {
-	return strconv.FormatBool(value)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_date.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_date.go
deleted file mode 100644
index 7079e649c..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_date.go
+++ /dev/null
@@ -1,299 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"regexp"
-	Time "time"
-)
-
-type _dateObject struct {
-	time  Time.Time // Time from the "time" package, a cached version of time
-	epoch int64
-	value Value
-	isNaN bool
-}
-
-var (
-	invalidDateObject = _dateObject{
-		time:  Time.Time{},
-		epoch: -1,
-		value: NaNValue(),
-		isNaN: true,
-	}
-)
-
-type _ecmaTime struct {
-	year        int
-	month       int
-	day         int
-	hour        int
-	minute      int
-	second      int
-	millisecond int
-	location    *Time.Location // Basically, either local or UTC
-}
-
-func ecmaTime(goTime Time.Time) _ecmaTime {
-	return _ecmaTime{
-		goTime.Year(),
-		dateFromGoMonth(goTime.Month()),
-		goTime.Day(),
-		goTime.Hour(),
-		goTime.Minute(),
-		goTime.Second(),
-		goTime.Nanosecond() / (100 * 100 * 100),
-		goTime.Location(),
-	}
-}
-
-func (self *_ecmaTime) goTime() Time.Time {
-	return Time.Date(
-		self.year,
-		dateToGoMonth(self.month),
-		self.day,
-		self.hour,
-		self.minute,
-		self.second,
-		self.millisecond*(100*100*100),
-		self.location,
-	)
-}
-
-func (self *_dateObject) Time() Time.Time {
-	return self.time
-}
-
-func (self *_dateObject) Epoch() int64 {
-	return self.epoch
-}
-
-func (self *_dateObject) Value() Value {
-	return self.value
-}
-
-// FIXME A date should only be in the range of -100,000,000 to +100,000,000 (1970): 15.9.1.1
-func (self *_dateObject) SetNaN() {
-	self.time = Time.Time{}
-	self.epoch = -1
-	self.value = NaNValue()
-	self.isNaN = true
-}
-
-func (self *_dateObject) SetTime(time Time.Time) {
-	self.Set(timeToEpoch(time))
-}
-
-func epoch2dateObject(epoch float64) _dateObject {
-	date := _dateObject{}
-	date.Set(epoch)
-	return date
-}
-
-func (self *_dateObject) Set(epoch float64) {
-	// epoch
-	self.epoch = epochToInteger(epoch)
-
-	// time
-	time, err := epochToTime(epoch)
-	self.time = time // Is either a valid time, or the zero-value for time.Time
-
-	// value & isNaN
-	if err != nil {
-		self.isNaN = true
-		self.epoch = -1
-		self.value = NaNValue()
-	} else {
-		self.value = toValue_int64(self.epoch)
-	}
-}
-
-func epochToInteger(value float64) int64 {
-	if value > 0 {
-		return int64(math.Floor(value))
-	}
-	return int64(math.Ceil(value))
-}
-
-func epochToTime(value float64) (time Time.Time, err error) {
-	epochWithMilli := value
-	if math.IsNaN(epochWithMilli) || math.IsInf(epochWithMilli, 0) {
-		err = fmt.Errorf("Invalid time %v", value)
-		return
-	}
-
-	epoch := int64(epochWithMilli / 1000)
-	milli := int64(epochWithMilli) % 1000
-
-	time = Time.Unix(int64(epoch), milli*1000000).UTC()
-	return
-}
-
-func timeToEpoch(time Time.Time) float64 {
-	return float64(time.UnixNano() / (1000 * 1000))
-}
-
-func (runtime *_runtime) newDateObject(epoch float64) *_object {
-	self := runtime.newObject()
-	self.class = "Date"
-
-	// FIXME This is ugly...
-	date := _dateObject{}
-	date.Set(epoch)
-	self.value = date
-	return self
-}
-
-func (self *_object) dateValue() _dateObject {
-	value, _ := self.value.(_dateObject)
-	return value
-}
-
-func dateObjectOf(rt *_runtime, _dateObject *_object) _dateObject {
-	if _dateObject == nil || _dateObject.class != "Date" {
-		panic(rt.panicTypeError())
-	}
-	return _dateObject.dateValue()
-}
-
-// JavaScript is 0-based, Go is 1-based (15.9.1.4)
-func dateToGoMonth(month int) Time.Month {
-	return Time.Month(month + 1)
-}
-
-func dateFromGoMonth(month Time.Month) int {
-	return int(month) - 1
-}
-
-// Both JavaScript & Go are 0-based (Sunday == 0)
-func dateToGoDay(day int) Time.Weekday {
-	return Time.Weekday(day)
-}
-
-func dateFromGoDay(day Time.Weekday) int {
-	return int(day)
-}
-
-func newDateTime(argumentList []Value, location *Time.Location) (epoch float64) {
-
-	pick := func(index int, default_ float64) (float64, bool) {
-		if index >= len(argumentList) {
-			return default_, false
-		}
-		value := argumentList[index].float64()
-		if math.IsNaN(value) || math.IsInf(value, 0) {
-			return 0, true
-		}
-		return value, false
-	}
-
-	if len(argumentList) >= 2 { // 2-argument, 3-argument, ...
-		var year, month, day, hour, minute, second, millisecond float64
-		var invalid bool
-		if year, invalid = pick(0, 1900.0); invalid {
-			goto INVALID
-		}
-		if month, invalid = pick(1, 0.0); invalid {
-			goto INVALID
-		}
-		if day, invalid = pick(2, 1.0); invalid {
-			goto INVALID
-		}
-		if hour, invalid = pick(3, 0.0); invalid {
-			goto INVALID
-		}
-		if minute, invalid = pick(4, 0.0); invalid {
-			goto INVALID
-		}
-		if second, invalid = pick(5, 0.0); invalid {
-			goto INVALID
-		}
-		if millisecond, invalid = pick(6, 0.0); invalid {
-			goto INVALID
-		}
-
-		if year >= 0 && year <= 99 {
-			year += 1900
-		}
-
-		time := Time.Date(int(year), dateToGoMonth(int(month)), int(day), int(hour), int(minute), int(second), int(millisecond)*1000*1000, location)
-		return timeToEpoch(time)
-
-	} else if len(argumentList) == 0 { // 0-argument
-		time := Time.Now().UTC()
-		return timeToEpoch(time)
-	} else { // 1-argument
-		value := valueOfArrayIndex(argumentList, 0)
-		value = toPrimitive(value)
-		if value.IsString() {
-			return dateParse(value.string())
-		}
-
-		return value.float64()
-	}
-
-INVALID:
-	epoch = math.NaN()
-	return
-}
-
-var (
-	dateLayoutList = []string{
-		"2006",
-		"2006-01",
-		"2006-01-02",
-
-		"2006T15:04",
-		"2006-01T15:04",
-		"2006-01-02T15:04",
-
-		"2006T15:04:05",
-		"2006-01T15:04:05",
-		"2006-01-02T15:04:05",
-
-		"2006T15:04:05.000",
-		"2006-01T15:04:05.000",
-		"2006-01-02T15:04:05.000",
-
-		"2006T15:04-0700",
-		"2006-01T15:04-0700",
-		"2006-01-02T15:04-0700",
-
-		"2006T15:04:05-0700",
-		"2006-01T15:04:05-0700",
-		"2006-01-02T15:04:05-0700",
-
-		"2006T15:04:05.000-0700",
-		"2006-01T15:04:05.000-0700",
-		"2006-01-02T15:04:05.000-0700",
-
-		Time.RFC1123,
-	}
-	matchDateTimeZone = regexp.MustCompile(`^(.*)(?:(Z)|([\+\-]\d{2}):(\d{2}))$`)
-)
-
-func dateParse(date string) (epoch float64) {
-	// YYYY-MM-DDTHH:mm:ss.sssZ
-	var time Time.Time
-	var err error
-	{
-		date := date
-		if match := matchDateTimeZone.FindStringSubmatch(date); match != nil {
-			if match[2] == "Z" {
-				date = match[1] + "+0000"
-			} else {
-				date = match[1] + match[3] + match[4]
-			}
-		}
-		for _, layout := range dateLayoutList {
-			time, err = Time.Parse(layout, date)
-			if err == nil {
-				break
-			}
-		}
-	}
-	if err != nil {
-		return math.NaN()
-	}
-	return float64(time.UnixNano()) / (1000 * 1000) // UnixMilli()
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_error.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_error.go
deleted file mode 100644
index c469f5fcb..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_error.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package otto
-
-func (rt *_runtime) newErrorObject(name string, message Value) *_object {
-	self := rt.newClassObject("Error")
-	if message.IsDefined() {
-		msg := message.string()
-		self.defineProperty("message", toValue_string(msg), 0111, false)
-		self.value = newError(rt, name, msg)
-	} else {
-		self.value = newError(rt, name)
-	}
-	return self
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_function.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_function.go
deleted file mode 100644
index 8581afd39..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_function.go
+++ /dev/null
@@ -1,271 +0,0 @@
-package otto
-
-// _constructFunction
-type _constructFunction func(*_object, []Value) Value
-
-// 13.2.2 [[Construct]]
-func defaultConstruct(fn *_object, argumentList []Value) Value {
-	object := fn.runtime.newObject()
-	object.class = "Object"
-
-	prototype := fn.get("prototype")
-	if prototype.kind != valueObject {
-		prototype = toValue_object(fn.runtime.global.ObjectPrototype)
-	}
-	object.prototype = prototype._object()
-
-	this := toValue_object(object)
-	value := fn.call(this, argumentList, false, nativeFrame)
-	if value.kind == valueObject {
-		return value
-	}
-	return this
-}
-
-// _nativeFunction
-type _nativeFunction func(FunctionCall) Value
-
-// ===================== //
-// _nativeFunctionObject //
-// ===================== //
-
-type _nativeFunctionObject struct {
-	name      string
-	call      _nativeFunction    // [[Call]]
-	construct _constructFunction // [[Construct]]
-}
-
-func (runtime *_runtime) newNativeFunctionObject(name string, native _nativeFunction, length int) *_object {
-	self := runtime.newClassObject("Function")
-	self.value = _nativeFunctionObject{
-		call:      native,
-		construct: defaultConstruct,
-	}
-	self.defineProperty("length", toValue_int(length), 0000, false)
-	return self
-}
-
-// =================== //
-// _bindFunctionObject //
-// =================== //
-
-type _bindFunctionObject struct {
-	target       *_object
-	this         Value
-	argumentList []Value
-}
-
-func (runtime *_runtime) newBoundFunctionObject(target *_object, this Value, argumentList []Value) *_object {
-	self := runtime.newClassObject("Function")
-	self.value = _bindFunctionObject{
-		target:       target,
-		this:         this,
-		argumentList: argumentList,
-	}
-	length := int(toInt32(target.get("length")))
-	length -= len(argumentList)
-	if length < 0 {
-		length = 0
-	}
-	self.defineProperty("length", toValue_int(length), 0000, false)
-	self.defineProperty("caller", Value{}, 0000, false)    // TODO Should throw a TypeError
-	self.defineProperty("arguments", Value{}, 0000, false) // TODO Should throw a TypeError
-	return self
-}
-
-// [[Construct]]
-func (fn _bindFunctionObject) construct(argumentList []Value) Value {
-	object := fn.target
-	switch value := object.value.(type) {
-	case _nativeFunctionObject:
-		return value.construct(object, fn.argumentList)
-	case _nodeFunctionObject:
-		argumentList = append(fn.argumentList, argumentList...)
-		return object.construct(argumentList)
-	}
-	panic(fn.target.runtime.panicTypeError())
-}
-
-// =================== //
-// _nodeFunctionObject //
-// =================== //
-
-type _nodeFunctionObject struct {
-	node  *_nodeFunctionLiteral
-	stash _stash
-}
-
-func (runtime *_runtime) newNodeFunctionObject(node *_nodeFunctionLiteral, stash _stash) *_object {
-	self := runtime.newClassObject("Function")
-	self.value = _nodeFunctionObject{
-		node:  node,
-		stash: stash,
-	}
-	self.defineProperty("length", toValue_int(len(node.parameterList)), 0000, false)
-	return self
-}
-
-// ======= //
-// _object //
-// ======= //
-
-func (self *_object) isCall() bool {
-	switch fn := self.value.(type) {
-	case _nativeFunctionObject:
-		return fn.call != nil
-	case _bindFunctionObject:
-		return true
-	case _nodeFunctionObject:
-		return true
-	}
-	return false
-}
-
-func (self *_object) call(this Value, argumentList []Value, eval bool, frame _frame) Value {
-	switch fn := self.value.(type) {
-
-	case _nativeFunctionObject:
-		// TODO Enter a scope, name from the native object...
-		// Since eval is a native function, we only have to check for it here
-		if eval {
-			eval = self == self.runtime.eval // If eval is true, then it IS a direct eval
-		}
-		return fn.call(FunctionCall{
-			runtime: self.runtime,
-			eval:    eval,
-
-			This:         this,
-			ArgumentList: argumentList,
-			Otto:         self.runtime.otto,
-		})
-
-	case _bindFunctionObject:
-		// TODO Passthrough site, do not enter a scope
-		argumentList = append(fn.argumentList, argumentList...)
-		return fn.target.call(fn.this, argumentList, false, frame)
-
-	case _nodeFunctionObject:
-		rt := self.runtime
-		stash := rt.enterFunctionScope(fn.stash, this)
-		rt.scope.frame = _frame{
-			callee: fn.node.name,
-			file: fn.node.file,
-		}
-		defer func() {
-			rt.leaveScope()
-		}()
-		callValue := rt.cmpl_call_nodeFunction(self, stash, fn.node, this, argumentList)
-		if value, valid := callValue.value.(_result); valid {
-			return value.value
-		}
-		return callValue
-	}
-
-	panic(self.runtime.panicTypeError("%v is not a function", toValue_object(self)))
-}
-
-func (self *_object) construct(argumentList []Value) Value {
-	switch fn := self.value.(type) {
-
-	case _nativeFunctionObject:
-		if fn.call == nil {
-			panic(self.runtime.panicTypeError("%v is not a function", toValue_object(self)))
-		}
-		if fn.construct == nil {
-			panic(self.runtime.panicTypeError("%v is not a constructor", toValue_object(self)))
-		}
-		return fn.construct(self, argumentList)
-
-	case _bindFunctionObject:
-		return fn.construct(argumentList)
-
-	case _nodeFunctionObject:
-		return defaultConstruct(self, argumentList)
-	}
-
-	panic(self.runtime.panicTypeError("%v is not a function", toValue_object(self)))
-}
-
-// 15.3.5.3
-func (self *_object) hasInstance(of Value) bool {
-	if !self.isCall() {
-		// We should not have a hasInstance method
-		panic(self.runtime.panicTypeError())
-	}
-	if !of.IsObject() {
-		return false
-	}
-	prototype := self.get("prototype")
-	if !prototype.IsObject() {
-		panic(self.runtime.panicTypeError())
-	}
-	prototypeObject := prototype._object()
-
-	value := of._object().prototype
-	for value != nil {
-		if value == prototypeObject {
-			return true
-		}
-		value = value.prototype
-	}
-	return false
-}
-
-// ============ //
-// FunctionCall //
-// ============ //
-
-// FunctionCall is an encapsulation of a JavaScript function call.
-type FunctionCall struct {
-	runtime     *_runtime
-	_thisObject *_object
-	eval        bool // This call is a direct call to eval
-
-	This         Value
-	ArgumentList []Value
-	Otto         *Otto
-}
-
-// Argument will return the value of the argument at the given index.
-//
-// If no such argument exists, undefined is returned.
-func (self FunctionCall) Argument(index int) Value {
-	return valueOfArrayIndex(self.ArgumentList, index)
-}
-
-func (self FunctionCall) getArgument(index int) (Value, bool) {
-	return getValueOfArrayIndex(self.ArgumentList, index)
-}
-
-func (self FunctionCall) slice(index int) []Value {
-	if index < len(self.ArgumentList) {
-		return self.ArgumentList[index:]
-	}
-	return []Value{}
-}
-
-func (self *FunctionCall) thisObject() *_object {
-	if self._thisObject == nil {
-		this := self.This.resolve() // FIXME Is this right?
-		self._thisObject = self.runtime.toObject(this)
-	}
-	return self._thisObject
-}
-
-func (self *FunctionCall) thisClassObject(class string) *_object {
-	thisObject := self.thisObject()
-	if thisObject.class != class {
-		panic(self.runtime.panicTypeError())
-	}
-	return self._thisObject
-}
-
-func (self FunctionCall) toObject(value Value) *_object {
-	return self.runtime.toObject(value)
-}
-
-// CallerLocation will return file location information (file:line:pos) where this function is being called.
-func (self FunctionCall) CallerLocation() string {
-	// see error.go for location()
-	return self.runtime.scope.frame.location()
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_array.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_array.go
deleted file mode 100644
index 13a0b10f2..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_array.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package otto
-
-import (
-	"reflect"
-	"strconv"
-)
-
-func (runtime *_runtime) newGoArrayObject(value reflect.Value) *_object {
-	self := runtime.newObject()
-	self.class = "GoArray"
-	self.objectClass = _classGoArray
-	self.value = _newGoArrayObject(value)
-	return self
-}
-
-type _goArrayObject struct {
-	value        reflect.Value
-	writable     bool
-	propertyMode _propertyMode
-}
-
-func _newGoArrayObject(value reflect.Value) *_goArrayObject {
-	writable := value.Kind() == reflect.Ptr // The Array is addressable (like a Slice)
-	mode := _propertyMode(0010)
-	if writable {
-		mode = 0110
-	}
-	self := &_goArrayObject{
-		value:        value,
-		writable:     writable,
-		propertyMode: mode,
-	}
-	return self
-}
-
-func (self _goArrayObject) getValue(index int64) (reflect.Value, bool) {
-	value := reflect.Indirect(self.value)
-	if index < int64(value.Len()) {
-		return value.Index(int(index)), true
-	}
-	return reflect.Value{}, false
-}
-
-func (self _goArrayObject) setValue(index int64, value Value) bool {
-	indexValue, exists := self.getValue(index)
-	if !exists {
-		return false
-	}
-	reflectValue, err := value.toReflectValue(reflect.Indirect(self.value).Type().Elem().Kind())
-	if err != nil {
-		panic(err)
-	}
-	indexValue.Set(reflectValue)
-	return true
-}
-
-func goArrayGetOwnProperty(self *_object, name string) *_property {
-	// length
-	if name == "length" {
-		return &_property{
-			value: toValue(reflect.Indirect(self.value.(*_goArrayObject).value).Len()),
-			mode:  0,
-		}
-	}
-
-	// .0, .1, .2, ...
-	index := stringToArrayIndex(name)
-	if index >= 0 {
-		object := self.value.(*_goArrayObject)
-		value := Value{}
-		reflectValue, exists := object.getValue(index)
-		if exists {
-			value = self.runtime.toValue(reflectValue.Interface())
-		}
-		return &_property{
-			value: value,
-			mode:  object.propertyMode,
-		}
-	}
-
-	return objectGetOwnProperty(self, name)
-}
-
-func goArrayEnumerate(self *_object, all bool, each func(string) bool) {
-	object := self.value.(*_goArrayObject)
-	// .0, .1, .2, ...
-
-	for index, length := 0, object.value.Len(); index < length; index++ {
-		name := strconv.FormatInt(int64(index), 10)
-		if !each(name) {
-			return
-		}
-	}
-
-	objectEnumerate(self, all, each)
-}
-
-func goArrayDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	if name == "length" {
-		return self.runtime.typeErrorResult(throw)
-	} else if index := stringToArrayIndex(name); index >= 0 {
-		object := self.value.(*_goArrayObject)
-		if object.writable {
-			if self.value.(*_goArrayObject).setValue(index, descriptor.value.(Value)) {
-				return true
-			}
-		}
-		return self.runtime.typeErrorResult(throw)
-	}
-	return objectDefineOwnProperty(self, name, descriptor, throw)
-}
-
-func goArrayDelete(self *_object, name string, throw bool) bool {
-	// length
-	if name == "length" {
-		return self.runtime.typeErrorResult(throw)
-	}
-
-	// .0, .1, .2, ...
-	index := stringToArrayIndex(name)
-	if index >= 0 {
-		object := self.value.(*_goArrayObject)
-		if object.writable {
-			indexValue, exists := object.getValue(index)
-			if exists {
-				indexValue.Set(reflect.Zero(reflect.Indirect(object.value).Type().Elem()))
-				return true
-			}
-		}
-		return self.runtime.typeErrorResult(throw)
-	}
-
-	return self.delete(name, throw)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_map.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_map.go
deleted file mode 100644
index 3e204a028..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_map.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package otto
-
-import (
-	"reflect"
-)
-
-func (runtime *_runtime) newGoMapObject(value reflect.Value) *_object {
-	self := runtime.newObject()
-	self.class = "Object" // TODO Should this be something else?
-	self.objectClass = _classGoMap
-	self.value = _newGoMapObject(value)
-	return self
-}
-
-type _goMapObject struct {
-	value     reflect.Value
-	keyKind   reflect.Kind
-	valueKind reflect.Kind
-}
-
-func _newGoMapObject(value reflect.Value) *_goMapObject {
-	if value.Kind() != reflect.Map {
-		dbgf("%/panic//%@: %v != reflect.Map", value.Kind())
-	}
-	self := &_goMapObject{
-		value:     value,
-		keyKind:   value.Type().Key().Kind(),
-		valueKind: value.Type().Elem().Kind(),
-	}
-	return self
-}
-
-func (self _goMapObject) toKey(name string) reflect.Value {
-	reflectValue, err := stringToReflectValue(name, self.keyKind)
-	if err != nil {
-		panic(err)
-	}
-	return reflectValue
-}
-
-func (self _goMapObject) toValue(value Value) reflect.Value {
-	reflectValue, err := value.toReflectValue(self.valueKind)
-	if err != nil {
-		panic(err)
-	}
-	return reflectValue
-}
-
-func goMapGetOwnProperty(self *_object, name string) *_property {
-	object := self.value.(*_goMapObject)
-	value := object.value.MapIndex(object.toKey(name))
-	if value.IsValid() {
-		return &_property{self.runtime.toValue(value.Interface()), 0111}
-	}
-
-	return nil
-}
-
-func goMapEnumerate(self *_object, all bool, each func(string) bool) {
-	object := self.value.(*_goMapObject)
-	keys := object.value.MapKeys()
-	for _, key := range keys {
-		if !each(toValue(key).String()) {
-			return
-		}
-	}
-}
-
-func goMapDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	object := self.value.(*_goMapObject)
-	// TODO ...or 0222
-	if descriptor.mode != 0111 {
-		return self.runtime.typeErrorResult(throw)
-	}
-	if !descriptor.isDataDescriptor() {
-		return self.runtime.typeErrorResult(throw)
-	}
-	object.value.SetMapIndex(object.toKey(name), object.toValue(descriptor.value.(Value)))
-	return true
-}
-
-func goMapDelete(self *_object, name string, throw bool) bool {
-	object := self.value.(*_goMapObject)
-	object.value.SetMapIndex(object.toKey(name), reflect.Value{})
-	// FIXME
-	return true
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_slice.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_slice.go
deleted file mode 100644
index 7143531a8..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_slice.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package otto
-
-import (
-	"reflect"
-	"strconv"
-)
-
-func (runtime *_runtime) newGoSliceObject(value reflect.Value) *_object {
-	self := runtime.newObject()
-	self.class = "GoArray" // TODO GoSlice?
-	self.objectClass = _classGoSlice
-	self.value = _newGoSliceObject(value)
-	return self
-}
-
-type _goSliceObject struct {
-	value reflect.Value
-}
-
-func _newGoSliceObject(value reflect.Value) *_goSliceObject {
-	self := &_goSliceObject{
-		value: value,
-	}
-	return self
-}
-
-func (self _goSliceObject) getValue(index int64) (reflect.Value, bool) {
-	if index < int64(self.value.Len()) {
-		return self.value.Index(int(index)), true
-	}
-	return reflect.Value{}, false
-}
-
-func (self _goSliceObject) setValue(index int64, value Value) bool {
-	indexValue, exists := self.getValue(index)
-	if !exists {
-		return false
-	}
-	reflectValue, err := value.toReflectValue(self.value.Type().Elem().Kind())
-	if err != nil {
-		panic(err)
-	}
-	indexValue.Set(reflectValue)
-	return true
-}
-
-func goSliceGetOwnProperty(self *_object, name string) *_property {
-	// length
-	if name == "length" {
-		return &_property{
-			value: toValue(self.value.(*_goSliceObject).value.Len()),
-			mode:  0,
-		}
-	}
-
-	// .0, .1, .2, ...
-	index := stringToArrayIndex(name)
-	if index >= 0 {
-		value := Value{}
-		reflectValue, exists := self.value.(*_goSliceObject).getValue(index)
-		if exists {
-			value = self.runtime.toValue(reflectValue.Interface())
-		}
-		return &_property{
-			value: value,
-			mode:  0110,
-		}
-	}
-
-	return objectGetOwnProperty(self, name)
-}
-
-func goSliceEnumerate(self *_object, all bool, each func(string) bool) {
-	object := self.value.(*_goSliceObject)
-	// .0, .1, .2, ...
-
-	for index, length := 0, object.value.Len(); index < length; index++ {
-		name := strconv.FormatInt(int64(index), 10)
-		if !each(name) {
-			return
-		}
-	}
-
-	objectEnumerate(self, all, each)
-}
-
-func goSliceDefineOwnProperty(self *_object, name string, descriptor _property, throw bool) bool {
-	if name == "length" {
-		return self.runtime.typeErrorResult(throw)
-	} else if index := stringToArrayIndex(name); index >= 0 {
-		if self.value.(*_goSliceObject).setValue(index, descriptor.value.(Value)) {
-			return true
-		}
-		return self.runtime.typeErrorResult(throw)
-	}
-	return objectDefineOwnProperty(self, name, descriptor, throw)
-}
-
-func goSliceDelete(self *_object, name string, throw bool) bool {
-	// length
-	if name == "length" {
-		return self.runtime.typeErrorResult(throw)
-	}
-
-	// .0, .1, .2, ...
-	index := stringToArrayIndex(name)
-	if index >= 0 {
-		object := self.value.(*_goSliceObject)
-		indexValue, exists := object.getValue(index)
-		if exists {
-			indexValue.Set(reflect.Zero(object.value.Type().Elem()))
-			return true
-		}
-		return self.runtime.typeErrorResult(throw)
-	}
-
-	return self.delete(name, throw)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_struct.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_struct.go
deleted file mode 100644
index 608ac6660..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_go_struct.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package otto
-
-import (
-	"encoding/json"
-	"reflect"
-)
-
-// FIXME Make a note about not being able to modify a struct unless it was
-// passed as a pointer-to: &struct{ ... }
-// This seems to be a limitation of the reflect package.
-// This goes for the other Go constructs too.
-// I guess we could get around it by either:
-// 1. Creating a new struct every time
-// 2. Creating an addressable? struct in the constructor
-
-func (runtime *_runtime) newGoStructObject(value reflect.Value) *_object {
-	self := runtime.newObject()
-	self.class = "Object" // TODO Should this be something else?
-	self.objectClass = _classGoStruct
-	self.value = _newGoStructObject(value)
-	return self
-}
-
-type _goStructObject struct {
-	value reflect.Value
-}
-
-func _newGoStructObject(value reflect.Value) *_goStructObject {
-	if reflect.Indirect(value).Kind() != reflect.Struct {
-		dbgf("%/panic//%@: %v != reflect.Struct", value.Kind())
-	}
-	self := &_goStructObject{
-		value: value,
-	}
-	return self
-}
-
-func (self _goStructObject) getValue(name string) reflect.Value {
-	if validGoStructName(name) {
-		// Do not reveal hidden or unexported fields
-		if field := reflect.Indirect(self.value).FieldByName(name); (field != reflect.Value{}) {
-			return field
-		}
-
-		if method := self.value.MethodByName(name); (method != reflect.Value{}) {
-			return method
-		}
-	}
-
-	return reflect.Value{}
-}
-
-func (self _goStructObject) field(name string) (reflect.StructField, bool) {
-	return reflect.Indirect(self.value).Type().FieldByName(name)
-}
-
-func (self _goStructObject) method(name string) (reflect.Method, bool) {
-	return reflect.Indirect(self.value).Type().MethodByName(name)
-}
-
-func (self _goStructObject) setValue(name string, value Value) bool {
-	field, exists := self.field(name)
-	if !exists {
-		return false
-	}
-	fieldValue := self.getValue(name)
-	reflectValue, err := value.toReflectValue(field.Type.Kind())
-	if err != nil {
-		panic(err)
-	}
-	fieldValue.Set(reflectValue)
-
-	return true
-}
-
-func goStructGetOwnProperty(self *_object, name string) *_property {
-	object := self.value.(*_goStructObject)
-	value := object.getValue(name)
-	if value.IsValid() {
-		return &_property{self.runtime.toValue(value.Interface()), 0110}
-	}
-
-	return objectGetOwnProperty(self, name)
-}
-
-func validGoStructName(name string) bool {
-	if name == "" {
-		return false
-	}
-	return 'A' <= name[0] && name[0] <= 'Z' // TODO What about Unicode?
-}
-
-func goStructEnumerate(self *_object, all bool, each func(string) bool) {
-	object := self.value.(*_goStructObject)
-
-	// Enumerate fields
-	for index := 0; index < reflect.Indirect(object.value).NumField(); index++ {
-		name := reflect.Indirect(object.value).Type().Field(index).Name
-		if validGoStructName(name) {
-			if !each(name) {
-				return
-			}
-		}
-	}
-
-	// Enumerate methods
-	for index := 0; index < object.value.NumMethod(); index++ {
-		name := object.value.Type().Method(index).Name
-		if validGoStructName(name) {
-			if !each(name) {
-				return
-			}
-		}
-	}
-
-	objectEnumerate(self, all, each)
-}
-
-func goStructCanPut(self *_object, name string) bool {
-	object := self.value.(*_goStructObject)
-	value := object.getValue(name)
-	if value.IsValid() {
-		return true
-	}
-
-	return objectCanPut(self, name)
-}
-
-func goStructPut(self *_object, name string, value Value, throw bool) {
-	object := self.value.(*_goStructObject)
-	if object.setValue(name, value) {
-		return
-	}
-
-	objectPut(self, name, value, throw)
-}
-
-func goStructMarshalJSON(self *_object) json.Marshaler {
-	object := self.value.(*_goStructObject)
-	goValue := reflect.Indirect(object.value).Interface()
-	switch marshaler := goValue.(type) {
-	case json.Marshaler:
-		return marshaler
-	}
-	return nil
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_number.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_number.go
deleted file mode 100644
index 28de4444c..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_number.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package otto
-
-func (runtime *_runtime) newNumberObject(value Value) *_object {
-	return runtime.newPrimitiveObject("Number", value.numberValue())
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_reference.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_reference.go
deleted file mode 100644
index fd770c6f4..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_reference.go
+++ /dev/null
@@ -1,103 +0,0 @@
-package otto
-
-type _reference interface {
-	invalid() bool         // IsUnresolvableReference
-	getValue() Value       // getValue
-	putValue(Value) string // PutValue
-	delete() bool
-}
-
-// PropertyReference
-
-type _propertyReference struct {
-	name    string
-	strict  bool
-	base    *_object
-	runtime *_runtime
-	at      _at
-}
-
-func newPropertyReference(rt *_runtime, base *_object, name string, strict bool, at _at) *_propertyReference {
-	return &_propertyReference{
-		runtime: rt,
-		name:    name,
-		strict:  strict,
-		base:    base,
-		at:      at,
-	}
-}
-
-func (self *_propertyReference) invalid() bool {
-	return self.base == nil
-}
-
-func (self *_propertyReference) getValue() Value {
-	if self.base == nil {
-		panic(self.runtime.panicReferenceError("'%s' is not defined", self.name, self.at))
-	}
-	return self.base.get(self.name)
-}
-
-func (self *_propertyReference) putValue(value Value) string {
-	if self.base == nil {
-		return self.name
-	}
-	self.base.put(self.name, value, self.strict)
-	return ""
-}
-
-func (self *_propertyReference) delete() bool {
-	if self.base == nil {
-		// TODO Throw an error if strict
-		return true
-	}
-	return self.base.delete(self.name, self.strict)
-}
-
-// ArgumentReference
-
-func newArgumentReference(runtime *_runtime, base *_object, name string, strict bool, at _at) *_propertyReference {
-	if base == nil {
-		panic(hereBeDragons())
-	}
-	return newPropertyReference(runtime, base, name, strict, at)
-}
-
-type _stashReference struct {
-	name   string
-	strict bool
-	base   _stash
-}
-
-func (self *_stashReference) invalid() bool {
-	return false // The base (an environment) will never be nil
-}
-
-func (self *_stashReference) getValue() Value {
-	return self.base.getBinding(self.name, self.strict)
-}
-
-func (self *_stashReference) putValue(value Value) string {
-	self.base.setValue(self.name, value, self.strict)
-	return ""
-}
-
-func (self *_stashReference) delete() bool {
-	if self.base == nil {
-		// This should never be reached, but just in case
-		return false
-	}
-	return self.base.deleteBinding(self.name)
-}
-
-// getIdentifierReference
-
-func getIdentifierReference(runtime *_runtime, stash _stash, name string, strict bool, at _at) _reference {
-	if stash == nil {
-		return newPropertyReference(runtime, nil, name, strict, at)
-	}
-	if stash.hasBinding(name) {
-		return stash.newReference(name, strict, at)
-	}
-	return getIdentifierReference(runtime, stash.outer(), name, strict, at)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_regexp.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_regexp.go
deleted file mode 100644
index 57fe31640..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_regexp.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"regexp"
-	"unicode/utf8"
-
-	"github.com/robertkrimen/otto/parser"
-)
-
-type _regExpObject struct {
-	regularExpression *regexp.Regexp
-	global            bool
-	ignoreCase        bool
-	multiline         bool
-	source            string
-	flags             string
-}
-
-func (runtime *_runtime) newRegExpObject(pattern string, flags string) *_object {
-	self := runtime.newObject()
-	self.class = "RegExp"
-
-	global := false
-	ignoreCase := false
-	multiline := false
-	re2flags := ""
-
-	// TODO Maybe clean up the panicking here... TypeError, SyntaxError, ?
-
-	for _, chr := range flags {
-		switch chr {
-		case 'g':
-			if global {
-				panic(runtime.panicSyntaxError("newRegExpObject: %s %s", pattern, flags))
-			}
-			global = true
-		case 'm':
-			if multiline {
-				panic(runtime.panicSyntaxError("newRegExpObject: %s %s", pattern, flags))
-			}
-			multiline = true
-			re2flags += "m"
-		case 'i':
-			if ignoreCase {
-				panic(runtime.panicSyntaxError("newRegExpObject: %s %s", pattern, flags))
-			}
-			ignoreCase = true
-			re2flags += "i"
-		}
-	}
-
-	re2pattern, err := parser.TransformRegExp(pattern)
-	if err != nil {
-		panic(runtime.panicTypeError("Invalid regular expression: %s", err.Error()))
-	}
-	if len(re2flags) > 0 {
-		re2pattern = fmt.Sprintf("(?%s:%s)", re2flags, re2pattern)
-	}
-
-	regularExpression, err := regexp.Compile(re2pattern)
-	if err != nil {
-		panic(runtime.panicSyntaxError("Invalid regular expression: %s", err.Error()[22:]))
-	}
-
-	self.value = _regExpObject{
-		regularExpression: regularExpression,
-		global:            global,
-		ignoreCase:        ignoreCase,
-		multiline:         multiline,
-		source:            pattern,
-		flags:             flags,
-	}
-	self.defineProperty("global", toValue_bool(global), 0, false)
-	self.defineProperty("ignoreCase", toValue_bool(ignoreCase), 0, false)
-	self.defineProperty("multiline", toValue_bool(multiline), 0, false)
-	self.defineProperty("lastIndex", toValue_int(0), 0100, false)
-	self.defineProperty("source", toValue_string(pattern), 0, false)
-	return self
-}
-
-func (self *_object) regExpValue() _regExpObject {
-	value, _ := self.value.(_regExpObject)
-	return value
-}
-
-func execRegExp(this *_object, target string) (match bool, result []int) {
-	if this.class != "RegExp" {
-		panic(this.runtime.panicTypeError("Calling RegExp.exec on a non-RegExp object"))
-	}
-	lastIndex := this.get("lastIndex").number().int64
-	index := lastIndex
-	global := this.get("global").bool()
-	if !global {
-		index = 0
-	}
-	if 0 > index || index > int64(len(target)) {
-	} else {
-		result = this.regExpValue().regularExpression.FindStringSubmatchIndex(target[index:])
-	}
-	if result == nil {
-		//this.defineProperty("lastIndex", toValue_(0), 0111, true)
-		this.put("lastIndex", toValue_int(0), true)
-		return // !match
-	}
-	match = true
-	startIndex := index
-	endIndex := int(lastIndex) + result[1]
-	// We do this shift here because the .FindStringSubmatchIndex above
-	// was done on a local subordinate slice of the string, not the whole string
-	for index, _ := range result {
-		result[index] += int(startIndex)
-	}
-	if global {
-		//this.defineProperty("lastIndex", toValue_(endIndex), 0111, true)
-		this.put("lastIndex", toValue_int(endIndex), true)
-	}
-	return // match
-}
-
-func execResultToArray(runtime *_runtime, target string, result []int) *_object {
-	captureCount := len(result) / 2
-	valueArray := make([]Value, captureCount)
-	for index := 0; index < captureCount; index++ {
-		offset := 2 * index
-		if result[offset] != -1 {
-			valueArray[index] = toValue_string(target[result[offset]:result[offset+1]])
-		} else {
-			valueArray[index] = Value{}
-		}
-	}
-	matchIndex := result[0]
-	if matchIndex != 0 {
-		matchIndex = 0
-		// Find the rune index in the string, not the byte index
-		for index := 0; index < result[0]; {
-			_, size := utf8.DecodeRuneInString(target[index:])
-			matchIndex += 1
-			index += size
-		}
-	}
-	match := runtime.newArrayOf(valueArray)
-	match.defineProperty("input", toValue_string(target), 0111, false)
-	match.defineProperty("index", toValue_int(matchIndex), 0111, false)
-	return match
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_string.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/type_string.go
deleted file mode 100644
index ef3afa42b..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/type_string.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package otto
-
-import (
-	"strconv"
-	"unicode/utf8"
-)
-
-type _stringObject interface {
-	Length() int
-	At(int) rune
-	String() string
-}
-
-type _stringASCII string
-
-func (str _stringASCII) Length() int {
-	return len(str)
-}
-
-func (str _stringASCII) At(at int) rune {
-	return rune(str[at])
-}
-
-func (str _stringASCII) String() string {
-	return string(str)
-}
-
-type _stringWide struct {
-	string string
-	length int
-	runes  []rune
-}
-
-func (str _stringWide) Length() int {
-	return str.length
-}
-
-func (str _stringWide) At(at int) rune {
-	if str.runes == nil {
-		str.runes = []rune(str.string)
-	}
-	return str.runes[at]
-}
-
-func (str _stringWide) String() string {
-	return str.string
-}
-
-func _newStringObject(str string) _stringObject {
-	for i := 0; i < len(str); i++ {
-		if str[i] >= utf8.RuneSelf {
-			goto wide
-		}
-	}
-
-	return _stringASCII(str)
-
-wide:
-	return &_stringWide{
-		string: str,
-		length: utf8.RuneCountInString(str),
-	}
-}
-
-func stringAt(str _stringObject, index int) rune {
-	if 0 <= index && index < str.Length() {
-		return str.At(index)
-	}
-	return utf8.RuneError
-}
-
-func (runtime *_runtime) newStringObject(value Value) *_object {
-	str := _newStringObject(value.string())
-
-	self := runtime.newClassObject("String")
-	self.defineProperty("length", toValue_int(str.Length()), 0, false)
-	self.objectClass = _classString
-	self.value = str
-	return self
-}
-
-func (self *_object) stringValue() _stringObject {
-	if str, ok := self.value.(_stringObject); ok {
-		return str
-	}
-	return nil
-}
-
-func stringEnumerate(self *_object, all bool, each func(string) bool) {
-	if str := self.stringValue(); str != nil {
-		length := str.Length()
-		for index := 0; index < length; index++ {
-			if !each(strconv.FormatInt(int64(index), 10)) {
-				return
-			}
-		}
-	}
-	objectEnumerate(self, all, each)
-}
-
-func stringGetOwnProperty(self *_object, name string) *_property {
-	if property := objectGetOwnProperty(self, name); property != nil {
-		return property
-	}
-	// TODO Test a string of length >= +int32 + 1?
-	if index := stringToArrayIndex(name); index >= 0 {
-		if chr := stringAt(self.stringValue(), int(index)); chr != utf8.RuneError {
-			return &_property{toValue_string(string(chr)), 0}
-		}
-	}
-	return nil
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/Makefile b/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/Makefile
deleted file mode 100644
index fc872917f..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-.PHONY: source
-
-source: source.go
-
-underscore.js:
-	curl -kL http://underscorejs.org/underscore.js > $@
-
-source.go: underscore.js
-	go-bindata -f underscore -p underscore -u true < $< 2>/dev/null | grep -v '^//' | gofmt > $@
-	head -4 $< >> $@
-	mv $< ..
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/README.markdown b/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/README.markdown
deleted file mode 100644
index bce37b695..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/README.markdown
+++ /dev/null
@@ -1,53 +0,0 @@
-# underscore
---
-    import "github.com/robertkrimen/otto/underscore"
-
-Package underscore contains the source for the JavaScript utility-belt library.
-
-    import (
-    	_ "github.com/robertkrimen/otto/underscore"
-    )
-    // Every Otto runtime will now include underscore
-
-http://underscorejs.org
-
-https://github.com/documentcloud/underscore
-
-By importing this package, you'll automatically load underscore every time you
-create a new Otto runtime.
-
-To prevent this behavior, you can do the following:
-
-    import (
-    	"github.com/robertkrimen/otto/underscore"
-    )
-
-    func init() {
-    	underscore.Disable()
-    }
-
-## Usage
-
-#### func  Disable
-
-```go
-func Disable()
-```
-Disable underscore runtime inclusion.
-
-#### func  Enable
-
-```go
-func Enable()
-```
-Enable underscore runtime inclusion.
-
-#### func  Source
-
-```go
-func Source() string
-```
-Source returns the underscore source.
-
---
-**godocdown** http://github.com/robertkrimen/godocdown
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/source.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/source.go
deleted file mode 100644
index 7c5df9714..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/source.go
+++ /dev/null
@@ -1,3463 +0,0 @@
-package underscore
-
-func underscore() []byte {
-	return []byte{
-		0x2f, 0x2f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x72,
-		0x73, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x6a, 0x73, 0x20, 0x31, 0x2e, 0x34,
-		0x2e, 0x34, 0x0a, 0x2f, 0x2f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x74,
-		0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63,
-		0x6f, 0x72, 0x65, 0x6a, 0x73, 0x2e, 0x6f, 0x72, 0x67, 0x0a, 0x2f, 0x2f,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x30,
-		0x39, 0x2d, 0x32, 0x30, 0x31, 0x33, 0x20, 0x4a, 0x65, 0x72, 0x65, 0x6d,
-		0x79, 0x20, 0x41, 0x73, 0x68, 0x6b, 0x65, 0x6e, 0x61, 0x73, 0x2c, 0x20,
-		0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6c, 0x6f, 0x75,
-		0x64, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x0a, 0x2f, 0x2f, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65,
-		0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x66, 0x72, 0x65, 0x65,
-		0x6c, 0x79, 0x20, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
-		0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x4d, 0x49, 0x54, 0x20, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65,
-		0x2e, 0x0a, 0x0a, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x29, 0x20, 0x7b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x42,
-		0x61, 0x73, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x73, 0x65, 0x74, 0x75,
-		0x70, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x45, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73,
-		0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x6f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x60, 0x77, 0x69, 0x6e, 0x64,
-		0x6f, 0x77, 0x60, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62,
-		0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x60,
-		0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x60, 0x20, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x0a, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x3d, 0x20,
-		0x74, 0x68, 0x69, 0x73, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x53, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65,
-		0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20,
-		0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60, 0x5f, 0x60, 0x20, 0x76,
-		0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x55,
-		0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x3d, 0x20,
-		0x72, 0x6f, 0x6f, 0x74, 0x2e, 0x5f, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x45, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x74, 0x73, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x72, 0x65,
-		0x61, 0x6b, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20,
-		0x6c, 0x6f, 0x6f, 0x70, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69,
-		0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x62, 0x72,
-		0x65, 0x61, 0x6b, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x53, 0x61, 0x76, 0x65, 0x20, 0x62,
-		0x79, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x6d, 0x69, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x28, 0x62, 0x75,
-		0x74, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x67, 0x7a, 0x69, 0x70, 0x70, 0x65,
-		0x64, 0x29, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3a, 0x0a,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50,
-		0x72, 0x6f, 0x74, 0x6f, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79,
-		0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20,
-		0x4f, 0x62, 0x6a, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x3d, 0x20, 0x4f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74,
-		0x79, 0x70, 0x65, 0x2c, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x50, 0x72, 0x6f,
-		0x74, 0x6f, 0x20, 0x3d, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x3b,
-		0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74,
-		0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x20, 0x72, 0x65, 0x66, 0x65,
-		0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62,
-		0x6c, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x70, 0x65, 0x65,
-		0x64, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x6f, 0x20,
-		0x63, 0x6f, 0x72, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79,
-		0x70, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x70,
-		0x75, 0x73, 0x68, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50,
-		0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x2c, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
-		0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73,
-		0x6c, 0x69, 0x63, 0x65, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79,
-		0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74,
-		0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x6f, 0x53, 0x74,
-		0x72, 0x69, 0x6e, 0x67, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x3d, 0x20, 0x4f, 0x62, 0x6a, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-		0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x68, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72,
-		0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x4f,
-		0x62, 0x6a, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x68, 0x61, 0x73, 0x4f,
-		0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x2a, 0x2a,
-		0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35,
-		0x2a, 0x2a, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65,
-		0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x77, 0x65, 0x20, 0x68, 0x6f, 0x70, 0x65, 0x20,
-		0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x61, 0x72, 0x65, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x64,
-		0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x46,
-		0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-		0x2e, 0x66, 0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x2c, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4d, 0x61, 0x70, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41,
-		0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x61,
-		0x70, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76,
-		0x65, 0x52, 0x65, 0x64, 0x75, 0x63, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f,
-		0x74, 0x6f, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x2c, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x64,
-		0x75, 0x63, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x20, 0x20, 0x3d, 0x20,
-		0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
-		0x65, 0x64, 0x75, 0x63, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x2c, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x46, 0x69,
-		0x6c, 0x74, 0x65, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d,
-		0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-		0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x72, 0x79, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72,
-		0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x72,
-		0x79, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76,
-		0x65, 0x53, 0x6f, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f,
-		0x74, 0x6f, 0x2e, 0x73, 0x6f, 0x6d, 0x65, 0x2c, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78,
-		0x4f, 0x66, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72,
-		0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64,
-		0x65, 0x78, 0x4f, 0x66, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61,
-		0x74, 0x69, 0x76, 0x65, 0x4c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65,
-		0x78, 0x4f, 0x66, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79,
-		0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e,
-		0x64, 0x65, 0x78, 0x4f, 0x66, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e,
-		0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x41, 0x72, 0x72, 0x61,
-		0x79, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4b, 0x65, 0x79,
-		0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
-		0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x2c,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x42,
-		0x69, 0x6e, 0x64, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x3d, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-		0x62, 0x69, 0x6e, 0x64, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x61, 0x66,
-		0x65, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20,
-		0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x72,
-		0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x20, 0x66, 0x6f, 0x72, 0x20, 0x75, 0x73, 0x65, 0x20, 0x62, 0x65, 0x6c,
-		0x6f, 0x77, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x5f, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
-		0x63, 0x65, 0x6f, 0x66, 0x20, 0x5f, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x21, 0x28, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69,
-		0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f, 0x66, 0x20, 0x5f, 0x29,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x65, 0x77,
-		0x20, 0x5f, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70,
-		0x65, 0x64, 0x20, 0x3d, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x45, 0x78, 0x70,
-		0x6f, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x64, 0x65,
-		0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x2a, 0x2a, 0x4e, 0x6f, 0x64, 0x65,
-		0x2e, 0x6a, 0x73, 0x2a, 0x2a, 0x2c, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72,
-		0x64, 0x73, 0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69,
-		0x6c, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x6f, 0x6c, 0x64, 0x20, 0x60, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
-		0x65, 0x28, 0x29, 0x60, 0x20, 0x41, 0x50, 0x49, 0x2e, 0x20, 0x49, 0x66,
-		0x20, 0x77, 0x65, 0x27, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x73,
-		0x65, 0x72, 0x2c, 0x20, 0x61, 0x64, 0x64, 0x20, 0x60, 0x5f, 0x60, 0x20,
-		0x61, 0x73, 0x20, 0x61, 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x76, 0x69, 0x61, 0x20, 0x61,
-		0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x64, 0x65, 0x6e,
-		0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x66, 0x6f, 0x72, 0x20, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65,
-		0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x22, 0x61,
-		0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x22, 0x20, 0x6d, 0x6f, 0x64,
-		0x65, 0x2e, 0x0a, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x74, 0x79, 0x70,
-		0x65, 0x6f, 0x66, 0x20, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20,
-		0x21, 0x3d, 0x3d, 0x20, 0x27, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e,
-		0x65, 0x64, 0x27, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6d, 0x6f,
-		0x64, 0x75, 0x6c, 0x65, 0x20, 0x21, 0x3d, 0x3d, 0x20, 0x27, 0x75, 0x6e,
-		0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x27, 0x20, 0x26, 0x26, 0x20,
-		0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x65, 0x78, 0x70, 0x6f, 0x72,
-		0x74, 0x73, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x6d, 0x6f,
-		0x64, 0x75, 0x6c, 0x65, 0x2e, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x73,
-		0x20, 0x3d, 0x20, 0x5f, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2e,
-		0x5f, 0x20, 0x3d, 0x20, 0x5f, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x20, 0x65,
-		0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x6f,
-		0x6f, 0x74, 0x2e, 0x5f, 0x20, 0x3d, 0x20, 0x5f, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x75, 0x72, 0x72,
-		0x65, 0x6e, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e,
-		0x20, 0x3d, 0x20, 0x27, 0x31, 0x2e, 0x34, 0x2e, 0x34, 0x27, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54,
-		0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x73, 0x74, 0x6f,
-		0x6e, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x20, 0x60, 0x65, 0x61, 0x63, 0x68,
-		0x60, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61,
-		0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x6b, 0x61, 0x20, 0x60, 0x66,
-		0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x20, 0x6f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x2d, 0x69, 0x6e, 0x20,
-		0x60, 0x66, 0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x60, 0x2c, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x73, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72,
-		0x61, 0x77, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
-		0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41,
-		0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73,
-		0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x66, 0x6f, 0x72,
-		0x45, 0x61, 0x63, 0x68, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61,
-		0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x65,
-		0x61, 0x63, 0x68, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x66, 0x6f, 0x72, 0x45,
-		0x61, 0x63, 0x68, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78,
-		0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
-		0x46, 0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x20, 0x26, 0x26, 0x20, 0x6f,
-		0x62, 0x6a, 0x2e, 0x66, 0x6f, 0x72, 0x45, 0x61, 0x63, 0x68, 0x20, 0x3d,
-		0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x46, 0x6f, 0x72,
-		0x45, 0x61, 0x63, 0x68, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x66, 0x6f, 0x72, 0x45, 0x61, 0x63,
-		0x68, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x20,
-		0x3d, 0x20, 0x30, 0x2c, 0x20, 0x6c, 0x20, 0x3d, 0x20, 0x6f, 0x62, 0x6a,
-		0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x20, 0x69, 0x20, 0x3c,
-		0x20, 0x6c, 0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x6f, 0x62,
-		0x6a, 0x5b, 0x69, 0x5d, 0x2c, 0x20, 0x69, 0x2c, 0x20, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x65,
-		0x72, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6b,
-		0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20,
-		0x6b, 0x65, 0x79, 0x29, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x6f, 0x62, 0x6a,
-		0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x2c, 0x20,
-		0x6f, 0x62, 0x6a, 0x29, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x62, 0x72, 0x65,
-		0x61, 0x6b, 0x65, 0x72, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61,
-		0x70, 0x70, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-		0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67,
-		0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43,
-		0x4d, 0x41, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a,
-		0x27, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x6d,
-		0x61, 0x70, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c,
-		0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d, 0x61,
-		0x70, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
-		0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72,
-		0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a,
-		0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61,
-		0x74, 0x69, 0x76, 0x65, 0x4d, 0x61, 0x70, 0x20, 0x26, 0x26, 0x20, 0x6f,
-		0x62, 0x6a, 0x2e, 0x6d, 0x61, 0x70, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e,
-		0x61, 0x74, 0x69, 0x76, 0x65, 0x4d, 0x61, 0x70, 0x29, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6d, 0x61, 0x70,
-		0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69,
-		0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5b, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x20,
-		0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65,
-		0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73,
-		0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x45, 0x72, 0x72, 0x6f,
-		0x72, 0x20, 0x3d, 0x20, 0x27, 0x52, 0x65, 0x64, 0x75, 0x63, 0x65, 0x20,
-		0x6f, 0x66, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6e, 0x6f, 0x20, 0x69,
-		0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x27, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2a, 0x2a, 0x52,
-		0x65, 0x64, 0x75, 0x63, 0x65, 0x2a, 0x2a, 0x20, 0x62, 0x75, 0x69, 0x6c,
-		0x64, 0x73, 0x20, 0x75, 0x70, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67,
-		0x6c, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x66, 0x72,
-		0x6f, 0x6d, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2c, 0x20, 0x61, 0x6b, 0x61,
-		0x20, 0x60, 0x69, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x60, 0x2c, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x72, 0x20, 0x60, 0x66, 0x6f, 0x6c, 0x64,
-		0x6c, 0x60, 0x2e, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65,
-		0x73, 0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53,
-		0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20,
-		0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x72, 0x65, 0x64, 0x75,
-		0x63, 0x65, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c,
-		0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x72, 0x65,
-		0x64, 0x75, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x66, 0x6f, 0x6c,
-		0x64, 0x6c, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69, 0x6e, 0x6a, 0x65, 0x63,
-		0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x2c, 0x20, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c,
-		0x20, 0x3d, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3e, 0x20, 0x32, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a,
-		0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x6f, 0x62,
-		0x6a, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65,
-		0x64, 0x75, 0x63, 0x65, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e,
-		0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e,
-		0x61, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x64, 0x75, 0x63, 0x65, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x62,
-		0x69, 0x6e, 0x64, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
-		0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x3f, 0x20, 0x6f,
-		0x62, 0x6a, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x28, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f,
-		0x29, 0x20, 0x3a, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x72, 0x65, 0x64, 0x75,
-		0x63, 0x65, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73,
-		0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x21, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6d,
-		0x65, 0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x69,
-		0x74, 0x69, 0x61, 0x6c, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73,
-		0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x6d, 0x65, 0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x2c, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x69, 0x6e,
-		0x69, 0x74, 0x69, 0x61, 0x6c, 0x29, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x77,
-		0x20, 0x6e, 0x65, 0x77, 0x20, 0x54, 0x79, 0x70, 0x65, 0x45, 0x72, 0x72,
-		0x6f, 0x72, 0x28, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x45, 0x72, 0x72,
-		0x6f, 0x72, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54, 0x68, 0x65,
-		0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x2d, 0x61, 0x73, 0x73, 0x6f, 0x63,
-		0x69, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69,
-		0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65,
-		0x2c, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e,
-		0x20, 0x61, 0x73, 0x20, 0x60, 0x66, 0x6f, 0x6c, 0x64, 0x72, 0x60, 0x2e,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-		0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d,
-		0x41, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27,
-		0x73, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x72, 0x65,
-		0x64, 0x75, 0x63, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x60, 0x20, 0x69,
-		0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x52,
-		0x69, 0x67, 0x68, 0x74, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x66, 0x6f, 0x6c,
-		0x64, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61,
-		0x6c, 0x20, 0x3d, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3e, 0x20, 0x32,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62,
-		0x6a, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x6f,
-		0x62, 0x6a, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x52,
-		0x65, 0x64, 0x75, 0x63, 0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x20, 0x26,
-		0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65,
-		0x52, 0x69, 0x67, 0x68, 0x74, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61,
-		0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x64, 0x75, 0x63, 0x65, 0x52, 0x69,
-		0x67, 0x68, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-		0x29, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d,
-		0x20, 0x5f, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x28, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78,
-		0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c,
-		0x20, 0x3f, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63,
-		0x65, 0x52, 0x69, 0x67, 0x68, 0x74, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x29, 0x20, 0x3a,
-		0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65, 0x52,
-		0x69, 0x67, 0x68, 0x74, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68,
-		0x20, 0x3d, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74,
-		0x68, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x21, 0x3d, 0x3d, 0x20, 0x2b, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20,
-		0x3d, 0x20, 0x5f, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3d, 0x20,
-		0x6b, 0x65, 0x79, 0x73, 0x20, 0x3f, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x5b,
-		0x2d, 0x2d, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x20, 0x3a, 0x20,
-		0x2d, 0x2d, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x69, 0x6e, 0x69,
-		0x74, 0x69, 0x61, 0x6c, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x6f,
-		0x62, 0x6a, 0x5b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5d, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69,
-		0x61, 0x6c, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x65,
-		0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x2c, 0x20, 0x6f, 0x62,
-		0x6a, 0x5b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5d, 0x2c, 0x20, 0x69, 0x6e,
-		0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28,
-		0x21, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x29, 0x20, 0x74, 0x68,
-		0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x54, 0x79, 0x70, 0x65,
-		0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x72, 0x65, 0x64, 0x75, 0x63, 0x65,
-		0x45, 0x72, 0x72, 0x6f, 0x72, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66,
-		0x69, 0x72, 0x73, 0x74, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x77,
-		0x68, 0x69, 0x63, 0x68, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x73, 0x20,
-		0x61, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x20, 0x74, 0x65, 0x73, 0x74,
-		0x2e, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73,
-		0x20, 0x60, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x60, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x5f, 0x2e,
-		0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x61, 0x6e, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20,
-		0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74,
-		0x65, 0x78, 0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20,
-		0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x61, 0x20, 0x74,
-		0x72, 0x75, 0x74, 0x68, 0x20, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65,
-		0x73, 0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53,
-		0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20,
-		0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x66, 0x69, 0x6c, 0x74,
-		0x65, 0x72, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c,
-		0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41,
-		0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x60, 0x73,
-		0x65, 0x6c, 0x65, 0x63, 0x74, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e,
-		0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x73,
-		0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74,
-		0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x3d,
-		0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x46, 0x69, 0x6c, 0x74,
-		0x65, 0x72, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x66, 0x69,
-		0x6c, 0x74, 0x65, 0x72, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74,
-		0x69, 0x76, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x66, 0x69,
-		0x6c, 0x74, 0x65, 0x72, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73,
-		0x74, 0x29, 0x29, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5b,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67,
-		0x74, 0x68, 0x5d, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61,
-		0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65,
-		0x6e, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x77, 0x68, 0x69, 0x63,
-		0x68, 0x20, 0x61, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x20, 0x74, 0x65,
-		0x73, 0x74, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x66,
-		0x69, 0x6c, 0x74, 0x65, 0x72, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69,
-		0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x21, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73,
-		0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x74, 0x65,
-		0x72, 0x6d, 0x69, 0x6e, 0x65, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65,
-		0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6d, 0x61,
-		0x74, 0x63, 0x68, 0x20, 0x61, 0x20, 0x74, 0x72, 0x75, 0x74, 0x68, 0x20,
-		0x74, 0x65, 0x73, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44,
-		0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20,
-		0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74,
-		0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76,
-		0x65, 0x20, 0x60, 0x65, 0x76, 0x65, 0x72, 0x79, 0x60, 0x20, 0x69, 0x66,
-		0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64,
-		0x20, 0x61, 0x73, 0x20, 0x60, 0x61, 0x6c, 0x6c, 0x60, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x3d, 0x20, 0x5f,
-		0x2e, 0x61, 0x6c, 0x6c, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65,
-		0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x7c, 0x7c, 0x20, 0x28, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x5f, 0x2e,
-		0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d,
-		0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
-		0x45, 0x76, 0x65, 0x72, 0x79, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a,
-		0x2e, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e,
-		0x61, 0x74, 0x69, 0x76, 0x65, 0x45, 0x76, 0x65, 0x72, 0x79, 0x29, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x65,
-		0x76, 0x65, 0x72, 0x79, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x28, 0x72, 0x65,
-		0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x20, 0x26, 0x26, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69,
-		0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x29,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62, 0x72, 0x65,
-		0x61, 0x6b, 0x65, 0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x21, 0x21, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65,
-		0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x66, 0x20, 0x61,
-		0x74, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74, 0x20, 0x6f, 0x6e, 0x65, 0x20,
-		0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x6d, 0x61,
-		0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x61, 0x20, 0x74, 0x72, 0x75, 0x74,
-		0x68, 0x20, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74,
-		0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69,
-		0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74,
-		0x69, 0x76, 0x65, 0x20, 0x60, 0x73, 0x6f, 0x6d, 0x65, 0x60, 0x20, 0x69,
-		0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x2e,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65,
-		0x64, 0x20, 0x61, 0x73, 0x20, 0x60, 0x61, 0x6e, 0x79, 0x60, 0x2e, 0x0a,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x3d, 0x20,
-		0x5f, 0x2e, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x61,
-		0x6e, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x20, 0x7c, 0x7c, 0x20, 0x28, 0x69, 0x74, 0x65,
-		0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69, 0x64,
-		0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20,
-		0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20,
-		0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x53,
-		0x6f, 0x6d, 0x65, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x73,
-		0x6f, 0x6d, 0x65, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69,
-		0x76, 0x65, 0x53, 0x6f, 0x6d, 0x65, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x73, 0x6f, 0x6d, 0x65, 0x28,
-		0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73,
-		0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x7c, 0x7c,
-		0x20, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20,
-		0x6c, 0x69, 0x73, 0x74, 0x29, 0x29, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x65, 0x72, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x21, 0x21, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e,
-		0x65, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x61, 0x20,
-		0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20,
-		0x28, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x60, 0x3d, 0x3d, 0x3d, 0x60,
-		0x29, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6c, 0x69, 0x61,
-		0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x60, 0x69, 0x6e, 0x63, 0x6c,
-		0x75, 0x64, 0x65, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x63, 0x6f,
-		0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69,
-		0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x74,
-		0x61, 0x72, 0x67, 0x65, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20,
-		0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e,
-		0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a,
-		0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x3d, 0x3d, 0x3d,
-		0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78,
-		0x4f, 0x66, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f,
-		0x62, 0x6a, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x74,
-		0x61, 0x72, 0x67, 0x65, 0x74, 0x29, 0x20, 0x21, 0x3d, 0x20, 0x2d, 0x31,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x61, 0x6e, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d,
-		0x3d, 0x3d, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65,
-		0x20, 0x61, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x28, 0x77,
-		0x69, 0x74, 0x68, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x29, 0x20, 0x6f, 0x6e, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20,
-		0x69, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x63, 0x6f,
-		0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x69, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20,
-		0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20,
-		0x32, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x69, 0x73, 0x46, 0x75, 0x6e, 0x63, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69,
-		0x73, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6d, 0x65,
-		0x74, 0x68, 0x6f, 0x64, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x6d, 0x61, 0x70, 0x28,
-		0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x28, 0x69, 0x73, 0x46, 0x75, 0x6e, 0x63, 0x20, 0x3f, 0x20, 0x6d, 0x65,
-		0x74, 0x68, 0x6f, 0x64, 0x20, 0x3a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x5b, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5d, 0x29, 0x2e, 0x61, 0x70,
-		0x70, 0x6c, 0x79, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x61,
-		0x72, 0x67, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x63, 0x65,
-		0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20,
-		0x61, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65,
-		0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x6d, 0x61,
-		0x70, 0x60, 0x3a, 0x20, 0x66, 0x65, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67,
-		0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x70, 0x6c, 0x75, 0x63, 0x6b, 0x20, 0x3d,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x6d,
-		0x61, 0x70, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x7b,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x3b, 0x20, 0x7d, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43,
-		0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x76,
-		0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20,
-		0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x20, 0x63,
-		0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x66, 0x69, 0x6c, 0x74,
-		0x65, 0x72, 0x60, 0x3a, 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69,
-		0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x70, 0x65, 0x63,
-		0x69, 0x66, 0x69, 0x63, 0x20, 0x60, 0x6b, 0x65, 0x79, 0x3a, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x60, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x2c, 0x20, 0x61, 0x74, 0x74, 0x72, 0x73, 0x2c, 0x20, 0x66, 0x69, 0x72,
-		0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x5f, 0x2e, 0x69, 0x73, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x28,
-		0x61, 0x74, 0x74, 0x72, 0x73, 0x29, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x3f, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x20, 0x3a, 0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x5b, 0x66,
-		0x69, 0x72, 0x73, 0x74, 0x20, 0x3f, 0x20, 0x27, 0x66, 0x69, 0x6e, 0x64,
-		0x27, 0x20, 0x3a, 0x20, 0x27, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x27,
-		0x5d, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28,
-		0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x61,
-		0x74, 0x74, 0x72, 0x73, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x74, 0x74, 0x72,
-		0x73, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20, 0x21, 0x3d, 0x3d, 0x20, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x72,
-		0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43,
-		0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x76,
-		0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20,
-		0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x20, 0x63,
-		0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x66, 0x69, 0x6e, 0x64,
-		0x60, 0x3a, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x70, 0x65, 0x63,
-		0x69, 0x66, 0x69, 0x63, 0x20, 0x60, 0x6b, 0x65, 0x79, 0x3a, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x60, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x66, 0x69, 0x6e, 0x64, 0x57, 0x68, 0x65, 0x72,
-		0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x61, 0x74, 0x74, 0x72, 0x73, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x5f, 0x2e, 0x77, 0x68, 0x65, 0x72, 0x65, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x61, 0x74, 0x74, 0x72, 0x73, 0x2c, 0x20, 0x74, 0x72,
-		0x75, 0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x65,
-		0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x28, 0x65,
-		0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, 0x64,
-		0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-		0x29, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x61, 0x6e, 0x27,
-		0x74, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x74,
-		0x65, 0x67, 0x65, 0x72, 0x73, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72,
-		0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x36, 0x35, 0x2c, 0x35, 0x33, 0x35,
-		0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x53, 0x65, 0x65, 0x3a, 0x20, 0x68, 0x74, 0x74,
-		0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x62, 0x75, 0x67, 0x73, 0x2e, 0x77, 0x65,
-		0x62, 0x6b, 0x69, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x73, 0x68, 0x6f,
-		0x77, 0x5f, 0x62, 0x75, 0x67, 0x2e, 0x63, 0x67, 0x69, 0x3f, 0x69, 0x64,
-		0x3d, 0x38, 0x30, 0x37, 0x39, 0x37, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d,
-		0x61, 0x78, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28,
-		0x21, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x26, 0x26,
-		0x20, 0x5f, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x30,
-		0x5d, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x2b, 0x6f, 0x62, 0x6a, 0x5b, 0x30,
-		0x5d, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x20, 0x3c, 0x20, 0x36, 0x35, 0x35, 0x33, 0x35, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x6d, 0x61, 0x78,
-		0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x4d, 0x61, 0x74, 0x68, 0x2c,
-		0x20, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x26, 0x26, 0x20, 0x5f, 0x2e,
-		0x69, 0x73, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x29,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x2d, 0x49, 0x6e,
-		0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d,
-		0x20, 0x7b, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x3a,
-		0x20, 0x2d, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x2c, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x20, 0x2d, 0x49, 0x6e, 0x66, 0x69,
-		0x6e, 0x69, 0x74, 0x79, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65,
-		0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c,
-		0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x3d,
-		0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3f, 0x20,
-		0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c,
-		0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c,
-		0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x3a, 0x20, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f,
-		0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x3e, 0x3d, 0x20, 0x72, 0x65,
-		0x73, 0x75, 0x6c, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65,
-		0x64, 0x20, 0x26, 0x26, 0x20, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
-		0x20, 0x3d, 0x20, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3a, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75,
-		0x74, 0x65, 0x64, 0x20, 0x3a, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74,
-		0x65, 0x64, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x20, 0x65, 0x6c, 0x65,
-		0x6d, 0x65, 0x6e, 0x74, 0x20, 0x28, 0x6f, 0x72, 0x20, 0x65, 0x6c, 0x65,
-		0x6d, 0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x63,
-		0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d, 0x69, 0x6e, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x20, 0x26, 0x26, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x41,
-		0x72, 0x72, 0x61, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x26, 0x26,
-		0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x30, 0x5d, 0x20, 0x3d, 0x3d, 0x3d, 0x20,
-		0x2b, 0x6f, 0x62, 0x6a, 0x5b, 0x30, 0x5d, 0x20, 0x26, 0x26, 0x20, 0x6f,
-		0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3c, 0x20,
-		0x36, 0x35, 0x35, 0x33, 0x35, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x4d, 0x61,
-		0x74, 0x68, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79,
-		0x28, 0x4d, 0x61, 0x74, 0x68, 0x2c, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x21, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
-		0x20, 0x26, 0x26, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x45, 0x6d, 0x70, 0x74,
-		0x79, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x7b, 0x63, 0x6f, 0x6d, 0x70, 0x75,
-		0x74, 0x65, 0x64, 0x20, 0x3a, 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69,
-		0x74, 0x79, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x20, 0x49,
-		0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x7d, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c,
-		0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65,
-		0x64, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
-		0x20, 0x3f, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e,
-		0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-		0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64,
-		0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x3a, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x3c, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x75,
-		0x74, 0x65, 0x64, 0x20, 0x26, 0x26, 0x20, 0x28, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x20, 0x3d, 0x20, 0x7b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20,
-		0x3a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x63, 0x6f, 0x6d,
-		0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x3a, 0x20, 0x63, 0x6f, 0x6d, 0x70,
-		0x75, 0x74, 0x65, 0x64, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x53, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x20,
-		0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x72, 0x61, 0x6e, 0x64, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3d, 0x20, 0x30, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x73, 0x68, 0x75,
-		0x66, 0x66, 0x6c, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6f, 0x62, 0x6a,
-		0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x72,
-		0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x28, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2b,
-		0x2b, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x68,
-		0x75, 0x66, 0x66, 0x6c, 0x65, 0x64, 0x5b, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x20, 0x2d, 0x20, 0x31, 0x5d, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x75, 0x66,
-		0x66, 0x6c, 0x65, 0x64, 0x5b, 0x72, 0x61, 0x6e, 0x64, 0x5d, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c,
-		0x65, 0x64, 0x5b, 0x72, 0x61, 0x6e, 0x64, 0x5d, 0x20, 0x3d, 0x20, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x73, 0x68, 0x75, 0x66, 0x66, 0x6c, 0x65, 0x64, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6e,
-		0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x65,
-		0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75,
-		0x70, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2e,
-		0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75,
-		0x70, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x46, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29,
-		0x20, 0x3f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3a, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29,
-		0x7b, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a,
-		0x5b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5d, 0x3b, 0x20, 0x7d, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x53,
-		0x6f, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x27, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20,
-		0x62, 0x79, 0x20, 0x61, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69,
-		0x6f, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20,
-		0x62, 0x79, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x73, 0x6f, 0x72, 0x74,
-		0x42, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x74, 0x65,
-		0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x6f, 0x6b,
-		0x75, 0x70, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x28, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x70, 0x6c, 0x75, 0x63,
-		0x6b, 0x28, 0x5f, 0x2e, 0x6d, 0x61, 0x70, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20,
-		0x6c, 0x69, 0x73, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x20, 0x3a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20,
-		0x3a, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69,
-		0x61, 0x20, 0x3a, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
-		0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78,
-		0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e,
-		0x64, 0x65, 0x78, 0x2c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x29, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x29, 0x2e, 0x73, 0x6f, 0x72, 0x74, 0x28, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6c, 0x65, 0x66, 0x74, 0x2c, 0x20, 0x72,
-		0x69, 0x67, 0x68, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x6c, 0x65,
-		0x66, 0x74, 0x2e, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x62,
-		0x20, 0x3d, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x63, 0x72, 0x69,
-		0x74, 0x65, 0x72, 0x69, 0x61, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x20, 0x21, 0x3d, 0x3d, 0x20, 0x62,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x20, 0x62, 0x20, 0x7c, 0x7c,
-		0x20, 0x61, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x76, 0x6f, 0x69, 0x64, 0x20,
-		0x30, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x31, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x61, 0x20, 0x3c, 0x20, 0x62, 0x20, 0x7c, 0x7c, 0x20, 0x62, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x30, 0x29, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x2d, 0x31, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x65, 0x66, 0x74,
-		0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3c, 0x20, 0x72, 0x69, 0x67,
-		0x68, 0x74, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3f, 0x20, 0x2d,
-		0x31, 0x20, 0x3a, 0x20, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x29, 0x2c, 0x20, 0x27, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x27, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x41, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65,
-		0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67,
-		0x61, 0x74, 0x65, 0x20, 0x22, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x62,
-		0x79, 0x22, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-		0x73, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x67, 0x72, 0x6f,
-		0x75, 0x70, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x62,
-		0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x20, 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
-		0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x49, 0x74, 0x65,
-		0x72, 0x61, 0x74, 0x6f, 0x72, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20,
-		0x7c, 0x7c, 0x20, 0x5f, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74,
-		0x79, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e,
-		0x64, 0x65, 0x78, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x3d, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20,
-		0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x28, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x2c, 0x20, 0x76, 0x61,
-		0x6c, 0x75, 0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x47, 0x72, 0x6f, 0x75,
-		0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x27, 0x73, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x62,
-		0x79, 0x20, 0x61, 0x20, 0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x6f,
-		0x6e, 0x2e, 0x20, 0x50, 0x61, 0x73, 0x73, 0x20, 0x65, 0x69, 0x74, 0x68,
-		0x65, 0x72, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20,
-		0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x74, 0x6f, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20,
-		0x62, 0x79, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63,
-		0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c,
-		0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x28,
-		0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
-		0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x3f, 0x20, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20, 0x3a, 0x20, 0x28,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20,
-		0x3d, 0x20, 0x5b, 0x5d, 0x29, 0x29, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e,
-		0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61,
-		0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x61,
-		0x74, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x62, 0x79, 0x20, 0x61,
-		0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x72, 0x69,
-		0x74, 0x65, 0x72, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x50, 0x61, 0x73, 0x73,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72,
-		0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74,
-		0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x63,
-		0x6f, 0x75, 0x6e, 0x74, 0x20, 0x62, 0x79, 0x2c, 0x20, 0x6f, 0x72, 0x20,
-		0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20,
-		0x74, 0x68, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x63, 0x72, 0x69,
-		0x74, 0x65, 0x72, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e,
-		0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x28, 0x6f,
-		0x62, 0x6a, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2c,
-		0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x5f, 0x2e, 0x68, 0x61, 0x73,
-		0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x6b, 0x65, 0x79,
-		0x29, 0x29, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6b, 0x65,
-		0x79, 0x5d, 0x20, 0x3d, 0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6b, 0x65, 0x79,
-		0x5d, 0x2b, 0x2b, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x55, 0x73, 0x65, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x20,
-		0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x6d, 0x61, 0x6c,
-		0x6c, 0x65, 0x73, 0x74, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x61,
-		0x74, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x73,
-		0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x73,
-		0x65, 0x72, 0x74, 0x65, 0x64, 0x20, 0x73, 0x6f, 0x20, 0x61, 0x73, 0x20,
-		0x74, 0x6f, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20,
-		0x6f, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x73, 0x20,
-		0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63,
-		0x68, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x73, 0x6f, 0x72, 0x74, 0x65,
-		0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c,
-		0x20, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x3f,
-		0x20, 0x5f, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20,
-		0x3a, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x49, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x28, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f,
-		0x72, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x6f, 0x77,
-		0x20, 0x3d, 0x20, 0x30, 0x2c, 0x20, 0x68, 0x69, 0x67, 0x68, 0x20, 0x3d,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74,
-		0x68, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65,
-		0x20, 0x28, 0x6c, 0x6f, 0x77, 0x20, 0x3c, 0x20, 0x68, 0x69, 0x67, 0x68,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x6d, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x28, 0x6c, 0x6f, 0x77,
-		0x20, 0x2b, 0x20, 0x68, 0x69, 0x67, 0x68, 0x29, 0x20, 0x3e, 0x3e, 0x3e,
-		0x20, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x5b, 0x6d, 0x69, 0x64, 0x5d, 0x29, 0x20, 0x3c, 0x20, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x20, 0x3f, 0x20, 0x6c, 0x6f, 0x77, 0x20, 0x3d,
-		0x20, 0x6d, 0x69, 0x64, 0x20, 0x2b, 0x20, 0x31, 0x20, 0x3a, 0x20, 0x68,
-		0x69, 0x67, 0x68, 0x20, 0x3d, 0x20, 0x6d, 0x69, 0x64, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x6c, 0x6f, 0x77, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x53, 0x61, 0x66, 0x65,
-		0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x61,
-		0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x20,
-		0x72, 0x65, 0x61, 0x6c, 0x2c, 0x20, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x74, 0x6f,
-		0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5b, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x69,
-		0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a,
-		0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x3d, 0x3d, 0x20,
-		0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x6d, 0x61,
-		0x70, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x5f, 0x2e, 0x69, 0x64, 0x65,
-		0x6e, 0x74, 0x69, 0x74, 0x79, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62,
-		0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
-		0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x73, 0x69, 0x7a,
-		0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74,
-		0x68, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x2b, 0x6f, 0x62, 0x6a, 0x2e, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x29, 0x20, 0x3f, 0x20, 0x6f, 0x62, 0x6a,
-		0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3a, 0x20, 0x5f, 0x2e,
-		0x6b, 0x65, 0x79, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2e, 0x6c, 0x65,
-		0x6e, 0x67, 0x74, 0x68, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x46,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73,
-		0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66,
-		0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x20, 0x50,
-		0x61, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x2a, 0x2a, 0x6e, 0x2a, 0x2a,
-		0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x4e,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
-		0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x2e, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61,
-		0x73, 0x20, 0x60, 0x68, 0x65, 0x61, 0x64, 0x60, 0x20, 0x61, 0x6e, 0x64,
-		0x20, 0x60, 0x74, 0x61, 0x6b, 0x65, 0x60, 0x2e, 0x20, 0x54, 0x68, 0x65,
-		0x20, 0x2a, 0x2a, 0x67, 0x75, 0x61, 0x72, 0x64, 0x2a, 0x2a, 0x20, 0x63,
-		0x68, 0x65, 0x63, 0x6b, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x61, 0x6c,
-		0x6c, 0x6f, 0x77, 0x73, 0x20, 0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x77,
-		0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x60, 0x5f, 0x2e,
-		0x6d, 0x61, 0x70, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x66, 0x69,
-		0x72, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x68, 0x65, 0x61, 0x64,
-		0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x2c, 0x20, 0x6e, 0x2c, 0x20, 0x67, 0x75, 0x61, 0x72, 0x64,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28,
-		0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c,
-		0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x6f,
-		0x69, 0x64, 0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x6e, 0x20, 0x21, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x29, 0x20, 0x26, 0x26, 0x20, 0x21, 0x67, 0x75, 0x61,
-		0x72, 0x64, 0x20, 0x3f, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x30,
-		0x2c, 0x20, 0x6e, 0x29, 0x20, 0x3a, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x5b, 0x30, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20,
-		0x65, 0x76, 0x65, 0x72, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x62,
-		0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20,
-		0x65, 0x6e, 0x74, 0x72, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x20, 0x45, 0x73, 0x70, 0x65,
-		0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75,
-		0x6c, 0x20, 0x6f, 0x6e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x20, 0x50, 0x61, 0x73, 0x73,
-		0x69, 0x6e, 0x67, 0x20, 0x2a, 0x2a, 0x6e, 0x2a, 0x2a, 0x20, 0x77, 0x69,
-		0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x6c,
-		0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
-		0x20, 0x69, 0x6e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x65, 0x78, 0x63, 0x6c,
-		0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61,
-		0x73, 0x74, 0x20, 0x4e, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x2a, 0x2a,
-		0x67, 0x75, 0x61, 0x72, 0x64, 0x2a, 0x2a, 0x20, 0x63, 0x68, 0x65, 0x63,
-		0x6b, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x69, 0x74, 0x20,
-		0x74, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x60, 0x5f, 0x2e, 0x6d, 0x61, 0x70,
-		0x60, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x6e, 0x69, 0x74, 0x69,
-		0x61, 0x6c, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x6e, 0x2c, 0x20,
-		0x67, 0x75, 0x61, 0x72, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x2c, 0x20, 0x30, 0x2c, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x2d, 0x20, 0x28, 0x28, 0x6e, 0x20,
-		0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x7c, 0x7c, 0x20,
-		0x67, 0x75, 0x61, 0x72, 0x64, 0x20, 0x3f, 0x20, 0x31, 0x20, 0x3a, 0x20,
-		0x6e, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x47, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x6c, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-		0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x2e, 0x20, 0x50, 0x61, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x2a, 0x2a,
-		0x6e, 0x2a, 0x2a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74,
-		0x20, 0x4e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72,
-		0x72, 0x61, 0x79, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x2a, 0x2a, 0x67,
-		0x75, 0x61, 0x72, 0x64, 0x2a, 0x2a, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b,
-		0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x69, 0x74, 0x20, 0x74,
-		0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20,
-		0x60, 0x5f, 0x2e, 0x6d, 0x61, 0x70, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20,
-		0x6e, 0x2c, 0x20, 0x67, 0x75, 0x61, 0x72, 0x64, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x30,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x28, 0x6e,
-		0x20, 0x21, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x26, 0x26,
-		0x20, 0x21, 0x67, 0x75, 0x61, 0x72, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x6d,
-		0x61, 0x78, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x20, 0x2d, 0x20, 0x6e, 0x2c, 0x20, 0x30, 0x29, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5b, 0x61, 0x72,
-		0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x2d,
-		0x20, 0x31, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x74,
-		0x68, 0x69, 0x6e, 0x67, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79,
-		0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x2e, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61,
-		0x73, 0x20, 0x60, 0x74, 0x61, 0x69, 0x6c, 0x60, 0x20, 0x61, 0x6e, 0x64,
-		0x20, 0x60, 0x64, 0x72, 0x6f, 0x70, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x45, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79,
-		0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x20, 0x50, 0x61, 0x73,
-		0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x2a, 0x2a, 0x6e, 0x2a,
-		0x2a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72,
-		0x65, 0x73, 0x74, 0x20, 0x4e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
-		0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x2a, 0x2a, 0x67, 0x75, 0x61,
-		0x72, 0x64, 0x2a, 0x2a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x63, 0x68,
-		0x65, 0x63, 0x6b, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x20, 0x69,
-		0x74, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69,
-		0x74, 0x68, 0x20, 0x60, 0x5f, 0x2e, 0x6d, 0x61, 0x70, 0x60, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x72, 0x65, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x5f,
-		0x2e, 0x74, 0x61, 0x69, 0x6c, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x64, 0x72,
-		0x6f, 0x70, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x6e, 0x2c, 0x20,
-		0x67, 0x75, 0x61, 0x72, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x2c, 0x20, 0x28, 0x6e, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c,
-		0x29, 0x20, 0x7c, 0x7c, 0x20, 0x67, 0x75, 0x61, 0x72, 0x64, 0x20, 0x3f,
-		0x20, 0x31, 0x20, 0x3a, 0x20, 0x6e, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54, 0x72, 0x69, 0x6d,
-		0x20, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x66, 0x61, 0x6c,
-		0x73, 0x79, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x66, 0x72,
-		0x6f, 0x6d, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x61, 0x72, 0x72, 0x61, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x66, 0x69,
-		0x6c, 0x74, 0x65, 0x72, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20,
-		0x5f, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6d, 0x70,
-		0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
-		0x6f, 0x66, 0x20, 0x61, 0x20, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69,
-		0x76, 0x65, 0x20, 0x60, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x60,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x69, 0x6e, 0x70, 0x75, 0x74, 0x2c, 0x20, 0x73, 0x68, 0x61, 0x6c, 0x6c,
-		0x6f, 0x77, 0x2c, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x69,
-		0x6e, 0x70, 0x75, 0x74, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e,
-		0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x29, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x3f, 0x20,
-		0x70, 0x75, 0x73, 0x68, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x6f,
-		0x75, 0x74, 0x70, 0x75, 0x74, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x29, 0x20, 0x3a, 0x20, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x73, 0x68, 0x61, 0x6c, 0x6c,
-		0x6f, 0x77, 0x2c, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73,
-		0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f,
-		0x75, 0x74, 0x70, 0x75, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c,
-		0x79, 0x20, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x65, 0x64, 0x20,
-		0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61,
-		0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x2c, 0x20, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x28, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x2c, 0x20, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x2c,
-		0x20, 0x5b, 0x5d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74,
-		0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x28, 0x73, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72,
-		0x65, 0x6e, 0x63, 0x65, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20,
-		0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61,
-		0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x20, 0x61, 0x20,
-		0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2d, 0x66, 0x72,
-		0x65, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f,
-		0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e,
-		0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64,
-		0x79, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20,
-		0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x79, 0x6f, 0x75, 0x20,
-		0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x74,
-		0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67,
-		0x20, 0x61, 0x20, 0x66, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x61, 0x6c,
-		0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x2e, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73,
-		0x20, 0x60, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x60, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x75, 0x6e, 0x69, 0x71, 0x20, 0x3d, 0x20, 0x5f, 0x2e,
-		0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c,
-		0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x69, 0x73, 0x46, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65,
-		0x64, 0x29, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x3d, 0x20, 0x69, 0x74,
-		0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3d,
-		0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65,
-		0x64, 0x20, 0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x20, 0x3d, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x3f, 0x20, 0x5f, 0x2e,
-		0x6d, 0x61, 0x70, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x69,
-		0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x3a, 0x20, 0x61, 0x72, 0x72, 0x61,
-		0x79, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72,
-		0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x73, 0x65, 0x65,
-		0x6e, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x28, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c,
-		0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76,
-		0x61, 0x6c, 0x75, 0x65, 0x2c, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3f, 0x20,
-		0x28, 0x21, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x7c, 0x7c, 0x20, 0x73,
-		0x65, 0x65, 0x6e, 0x5b, 0x73, 0x65, 0x65, 0x6e, 0x2e, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x20, 0x2d, 0x20, 0x31, 0x5d, 0x20, 0x21, 0x3d, 0x3d,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x20, 0x3a, 0x20, 0x21, 0x5f,
-		0x2e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x28, 0x73, 0x65,
-		0x65, 0x6e, 0x2c, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x65,
-		0x65, 0x6e, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x70, 0x75, 0x73, 0x68,
-		0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5b, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x5d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x20, 0x61,
-		0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x74, 0x68, 0x61, 0x74,
-		0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x65, 0x61, 0x63,
-		0x68, 0x20, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x20, 0x65,
-		0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20,
-		0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x2d, 0x69,
-		0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e,
-		0x75, 0x6e, 0x69, 0x71, 0x28, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x2e,
-		0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50,
-		0x72, 0x6f, 0x74, 0x6f, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65,
-		0x6e, 0x74, 0x73, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63,
-		0x65, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73,
-		0x20, 0x65, 0x76, 0x65, 0x72, 0x79, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x20,
-		0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65,
-		0x65, 0x6e, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x2d, 0x69,
-		0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x65, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x74, 0x20,
-		0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20,
-		0x31, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x28,
-		0x5f, 0x2e, 0x75, 0x6e, 0x69, 0x71, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x29, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x69, 0x74, 0x65, 0x6d, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x65,
-		0x76, 0x65, 0x72, 0x79, 0x28, 0x72, 0x65, 0x73, 0x74, 0x2c, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x74, 0x68, 0x65,
-		0x72, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x69, 0x6e,
-		0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2c,
-		0x20, 0x69, 0x74, 0x65, 0x6d, 0x29, 0x20, 0x3e, 0x3d, 0x20, 0x30, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54, 0x61, 0x6b, 0x65, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-		0x65, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x6f, 0x6e,
-		0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20,
-		0x61, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20,
-		0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x20,
-		0x6a, 0x75, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72,
-		0x73, 0x74, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x77, 0x69, 0x6c,
-		0x6c, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x61, 0x72, 0x72, 0x61, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x74, 0x20, 0x3d, 0x20,
-		0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79,
-		0x28, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2c,
-		0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31,
-		0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x28,
-		0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x7b, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x21, 0x5f, 0x2e, 0x63, 0x6f,
-		0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x28, 0x72, 0x65, 0x73, 0x74, 0x2c,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29, 0x3b, 0x20, 0x7d, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x5a, 0x69, 0x70, 0x20, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72,
-		0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x6c, 0x69,
-		0x73, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73,
-		0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20,
-		0x2d, 0x2d, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20,
-		0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x61, 0x72, 0x65, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x20, 0x67, 0x6f, 0x20, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72,
-		0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x7a, 0x69, 0x70, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67,
-		0x73, 0x20, 0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61,
-		0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c,
-		0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x6d, 0x61,
-		0x78, 0x28, 0x5f, 0x2e, 0x70, 0x6c, 0x75, 0x63, 0x6b, 0x28, 0x61, 0x72,
-		0x67, 0x73, 0x2c, 0x20, 0x27, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x27,
-		0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x6e, 0x65,
-		0x77, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x6c, 0x65, 0x6e, 0x67,
-		0x74, 0x68, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x20, 0x3d, 0x20, 0x30, 0x3b,
-		0x20, 0x69, 0x20, 0x3c, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b,
-		0x20, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5b, 0x69, 0x5d,
-		0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x70, 0x6c, 0x75, 0x63, 0x6b, 0x28, 0x61,
-		0x72, 0x67, 0x73, 0x2c, 0x20, 0x22, 0x22, 0x20, 0x2b, 0x20, 0x69, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x73, 0x20,
-		0x6c, 0x69, 0x73, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x6f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x20, 0x50, 0x61, 0x73, 0x73,
-		0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x61, 0x20, 0x73, 0x69,
-		0x6e, 0x67, 0x6c, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f,
-		0x66, 0x20, 0x60, 0x5b, 0x6b, 0x65, 0x79, 0x2c, 0x20, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x5d, 0x60, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x70, 0x61,
-		0x69, 0x72, 0x73, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x77, 0x6f, 0x20,
-		0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
-		0x61, 0x6d, 0x65, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x2d,
-		0x2d, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6b, 0x65, 0x79,
-		0x73, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f,
-		0x66, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63,
-		0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6c, 0x69, 0x73, 0x74, 0x2c,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6c, 0x69, 0x73, 0x74, 0x20,
-		0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d,
-		0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x69, 0x20, 0x3d, 0x20, 0x30, 0x2c,
-		0x20, 0x6c, 0x20, 0x3d, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x6c, 0x65,
-		0x6e, 0x67, 0x74, 0x68, 0x3b, 0x20, 0x69, 0x20, 0x3c, 0x20, 0x6c, 0x3b,
-		0x20, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6c, 0x69, 0x73, 0x74, 0x5b,
-		0x69, 0x5d, 0x5d, 0x20, 0x3d, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73,
-		0x5b, 0x69, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6c,
-		0x69, 0x73, 0x74, 0x5b, 0x69, 0x5d, 0x5b, 0x30, 0x5d, 0x5d, 0x20, 0x3d,
-		0x20, 0x6c, 0x69, 0x73, 0x74, 0x5b, 0x69, 0x5d, 0x5b, 0x31, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x66, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x20,
-		0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70,
-		0x6c, 0x79, 0x20, 0x75, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x69,
-		0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x28, 0x49, 0x27, 0x6d, 0x20,
-		0x6c, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x74, 0x20, 0x79,
-		0x6f, 0x75, 0x2c, 0x20, 0x2a, 0x2a, 0x4d, 0x53, 0x49, 0x45, 0x2a, 0x2a,
-		0x29, 0x2c, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x77, 0x65, 0x20, 0x6e,
-		0x65, 0x65, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-		0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69,
-		0x72, 0x73, 0x74, 0x20, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e,
-		0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x6e,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x2d,
-		0x31, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x74, 0x65,
-		0x6d, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x69, 0x6e, 0x63,
-		0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74,
-		0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69,
-		0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74,
-		0x69, 0x76, 0x65, 0x20, 0x60, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66,
-		0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62,
-		0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x66, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x69, 0x73,
-		0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61,
-		0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x73, 0x6f,
-		0x72, 0x74, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x2c, 0x20, 0x70, 0x61,
-		0x73, 0x73, 0x20, 0x60, 0x74, 0x72, 0x75, 0x65, 0x60, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x2a, 0x2a, 0x69, 0x73, 0x53,
-		0x6f, 0x72, 0x74, 0x65, 0x64, 0x2a, 0x2a, 0x20, 0x74, 0x6f, 0x20, 0x75,
-		0x73, 0x65, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x73, 0x65,
-		0x61, 0x72, 0x63, 0x68, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x6e,
-		0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20,
-		0x69, 0x74, 0x65, 0x6d, 0x2c, 0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74,
-		0x65, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x3d, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x2d, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x69, 0x20, 0x3d, 0x20, 0x30, 0x2c, 0x20, 0x6c, 0x20, 0x3d, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x73, 0x53,
-		0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f,
-		0x66, 0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d,
-		0x3d, 0x20, 0x27, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x27, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x20,
-		0x3d, 0x20, 0x28, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20,
-		0x3c, 0x20, 0x30, 0x20, 0x3f, 0x20, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x6d,
-		0x61, 0x78, 0x28, 0x30, 0x2c, 0x20, 0x6c, 0x20, 0x2b, 0x20, 0x69, 0x73,
-		0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x20, 0x3a, 0x20, 0x69, 0x73,
-		0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x20, 0x3d, 0x20,
-		0x5f, 0x2e, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x49, 0x6e, 0x64, 0x65,
-		0x78, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2c, 0x20, 0x69, 0x74, 0x65,
-		0x6d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x5b, 0x69, 0x5d, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x6d,
-		0x20, 0x3f, 0x20, 0x69, 0x20, 0x3a, 0x20, 0x2d, 0x31, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74,
-		0x69, 0x76, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x26,
-		0x26, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x69, 0x6e, 0x64, 0x65,
-		0x78, 0x4f, 0x66, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69,
-		0x76, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e,
-		0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x69, 0x74, 0x65, 0x6d,
-		0x2c, 0x20, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x3b, 0x20,
-		0x69, 0x20, 0x3c, 0x20, 0x6c, 0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x29, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x5b, 0x69, 0x5d,
-		0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x2d, 0x31, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44,
-		0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20,
-		0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74,
-		0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76,
-		0x65, 0x20, 0x60, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78,
-		0x4f, 0x66, 0x60, 0x20, 0x69, 0x66, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c,
-		0x61, 0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6c, 0x61,
-		0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x2c, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x2c, 0x20, 0x66, 0x72,
-		0x6f, 0x6d, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x3d, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x2d, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x68, 0x61, 0x73, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3d, 0x20, 0x66,
-		0x72, 0x6f, 0x6d, 0x20, 0x21, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6e, 0x61, 0x74,
-		0x69, 0x76, 0x65, 0x4c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78,
-		0x4f, 0x66, 0x20, 0x26, 0x26, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e,
-		0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4c, 0x61,
-		0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x68, 0x61, 0x73, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x3f,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x61, 0x73, 0x74, 0x49,
-		0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x28, 0x69, 0x74, 0x65, 0x6d, 0x2c,
-		0x20, 0x66, 0x72, 0x6f, 0x6d, 0x29, 0x20, 0x3a, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x2e, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78,
-		0x4f, 0x66, 0x28, 0x69, 0x74, 0x65, 0x6d, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x69, 0x20, 0x3d, 0x20, 0x28, 0x68, 0x61, 0x73, 0x49, 0x6e, 0x64, 0x65,
-		0x78, 0x20, 0x3f, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x3a, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20,
-		0x28, 0x69, 0x2d, 0x2d, 0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x72,
-		0x72, 0x61, 0x79, 0x5b, 0x69, 0x5d, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x69,
-		0x74, 0x65, 0x6d, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x69, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x2d, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
-		0x65, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72,
-		0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61,
-		0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x72, 0x69,
-		0x74, 0x68, 0x6d, 0x65, 0x74, 0x69, 0x63, 0x20, 0x70, 0x72, 0x6f, 0x67,
-		0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x41, 0x20, 0x70,
-		0x6f, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x50,
-		0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x60, 0x72, 0x61, 0x6e, 0x67, 0x65,
-		0x28, 0x29, 0x60, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x2e, 0x20, 0x53, 0x65, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x5b,
-		0x74, 0x68, 0x65, 0x20, 0x50, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x20, 0x64,
-		0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-		0x5d, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x64, 0x6f, 0x63,
-		0x73, 0x2e, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2e, 0x6f, 0x72, 0x67,
-		0x2f, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x2f, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x23,
-		0x72, 0x61, 0x6e, 0x67, 0x65, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e,
-		0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2c, 0x20,
-		0x73, 0x74, 0x6f, 0x70, 0x2c, 0x20, 0x73, 0x74, 0x65, 0x70, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x6c, 0x65, 0x6e, 0x67,
-		0x74, 0x68, 0x20, 0x3c, 0x3d, 0x20, 0x31, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74, 0x6f, 0x70, 0x20, 0x3d, 0x20,
-		0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x7c, 0x7c, 0x20, 0x30, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20,
-		0x3d, 0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x73, 0x74, 0x65, 0x70, 0x20, 0x3d, 0x20, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x5b, 0x32, 0x5d, 0x20, 0x7c,
-		0x7c, 0x20, 0x31, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x6c, 0x65, 0x6e, 0x20, 0x3d, 0x20, 0x4d, 0x61, 0x74, 0x68,
-		0x2e, 0x6d, 0x61, 0x78, 0x28, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x63, 0x65,
-		0x69, 0x6c, 0x28, 0x28, 0x73, 0x74, 0x6f, 0x70, 0x20, 0x2d, 0x20, 0x73,
-		0x74, 0x61, 0x72, 0x74, 0x29, 0x20, 0x2f, 0x20, 0x73, 0x74, 0x65, 0x70,
-		0x29, 0x2c, 0x20, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x69, 0x64, 0x78, 0x20, 0x3d, 0x20, 0x30, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x61, 0x6e, 0x67,
-		0x65, 0x20, 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x41, 0x72, 0x72, 0x61,
-		0x79, 0x28, 0x6c, 0x65, 0x6e, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x28, 0x69, 0x64, 0x78, 0x20, 0x3c,
-		0x20, 0x6c, 0x65, 0x6e, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5b, 0x69, 0x64, 0x78, 0x2b,
-		0x2b, 0x5d, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20,
-		0x2b, 0x3d, 0x20, 0x73, 0x74, 0x65, 0x70, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x46, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x68, 0x65, 0x6d, 0x29,
-		0x20, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20,
-		0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62,
-		0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x67, 0x69,
-		0x76, 0x65, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x28,
-		0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x60, 0x74,
-		0x68, 0x69, 0x73, 0x60, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79,
-		0x29, 0x2e, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73,
-		0x20, 0x74, 0x6f, 0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63,
-		0x72, 0x69, 0x70, 0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e,
-		0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x60, 0x46, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x60, 0x20, 0x69, 0x66,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
-		0x62, 0x6c, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x62, 0x69, 0x6e,
-		0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x66, 0x75, 0x6e, 0x63, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x42, 0x69,
-		0x6e, 0x64, 0x20, 0x26, 0x26, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
-		0x42, 0x69, 0x6e, 0x64, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x2e,
-		0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x2c, 0x20,
-		0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61,
-		0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61,
-		0x72, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e,
-		0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e,
-		0x74, 0x73, 0x2c, 0x20, 0x32, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x63, 0x6f, 0x6e, 0x74,
-		0x65, 0x78, 0x74, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x2e, 0x63, 0x6f,
-		0x6e, 0x63, 0x61, 0x74, 0x28, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x29, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x61, 0x70,
-		0x70, 0x6c, 0x79, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69,
-		0x6e, 0x67, 0x20, 0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
-		0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x68, 0x61,
-		0x64, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74,
-		0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d,
-		0x65, 0x6e, 0x74, 0x73, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x66, 0x69, 0x6c,
-		0x6c, 0x65, 0x64, 0x2c, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74,
-		0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74,
-		0x73, 0x20, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x20, 0x60, 0x74,
-		0x68, 0x69, 0x73, 0x60, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
-		0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61,
-		0x6c, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x66, 0x75, 0x6e, 0x63, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, 0x3d, 0x20,
-		0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61,
-		0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c,
-		0x79, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73,
-		0x2e, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x28, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d,
-		0x65, 0x6e, 0x74, 0x73, 0x29, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x42, 0x69, 0x6e, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20,
-		0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x27, 0x73, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x74,
-		0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x66, 0x6f,
-		0x72, 0x20, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x61, 0x6c, 0x6c,
-		0x20, 0x63, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x73, 0x20, 0x64,
-		0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x61, 0x6e,
-		0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x62, 0x65, 0x6c, 0x6f,
-		0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x20, 0x20,
-		0x5f, 0x2e, 0x62, 0x69, 0x6e, 0x64, 0x41, 0x6c, 0x6c, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d,
-		0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x73, 0x2e,
-		0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x30,
-		0x29, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x5f, 0x2e,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x28, 0x6f, 0x62,
-		0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68,
-		0x28, 0x66, 0x75, 0x6e, 0x63, 0x73, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x29, 0x20, 0x7b, 0x20, 0x6f, 0x62,
-		0x6a, 0x5b, 0x66, 0x5d, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x62, 0x69, 0x6e,
-		0x64, 0x28, 0x6f, 0x62, 0x6a, 0x5b, 0x66, 0x5d, 0x2c, 0x20, 0x6f, 0x62,
-		0x6a, 0x29, 0x3b, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4d,
-		0x65, 0x6d, 0x6f, 0x69, 0x7a, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78,
-		0x70, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x79, 0x20, 0x73, 0x74, 0x6f, 0x72,
-		0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x73, 0x20, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d, 0x65, 0x6d,
-		0x6f, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x2c, 0x20, 0x68, 0x61,
-		0x73, 0x68, 0x65, 0x72, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x7b,
-		0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x68, 0x61, 0x73, 0x68, 0x65,
-		0x72, 0x20, 0x7c, 0x7c, 0x20, 0x28, 0x68, 0x61, 0x73, 0x68, 0x65, 0x72,
-		0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74,
-		0x79, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x3d, 0x20, 0x68, 0x61, 0x73, 0x68,
-		0x65, 0x72, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x74, 0x68, 0x69,
-		0x73, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28, 0x6d, 0x65,
-		0x6d, 0x6f, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x3f, 0x20, 0x6d,
-		0x65, 0x6d, 0x6f, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20, 0x3a, 0x20, 0x28,
-		0x6d, 0x65, 0x6d, 0x6f, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x74,
-		0x68, 0x69, 0x73, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e,
-		0x74, 0x73, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x44, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x6e, 0x75, 0x6d, 0x62,
-		0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x73,
-		0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20,
-		0x74, 0x68, 0x65, 0x6e, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x64, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e,
-		0x63, 0x2c, 0x20, 0x77, 0x61, 0x69, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20,
-		0x3d, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c,
-		0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20,
-		0x32, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x73, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75,
-		0x74, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29,
-		0x7b, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x6e, 0x75, 0x6c, 0x6c,
-		0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x3b, 0x20, 0x7d, 0x2c, 0x20,
-		0x77, 0x61, 0x69, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x66, 0x65, 0x72, 0x73,
-		0x20, 0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c,
-		0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x69, 0x6e, 0x67, 0x20,
-		0x69, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x61, 0x66,
-		0x74, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x72,
-		0x65, 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x61,
-		0x63, 0x6b, 0x20, 0x68, 0x61, 0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x63, 0x6c, 0x65, 0x61, 0x72, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x64, 0x65, 0x66, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x5f, 0x2e, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x2e, 0x61, 0x70, 0x70,
-		0x6c, 0x79, 0x28, 0x5f, 0x2c, 0x20, 0x5b, 0x66, 0x75, 0x6e, 0x63, 0x2c,
-		0x20, 0x31, 0x5d, 0x2e, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x28, 0x73,
-		0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29, 0x29,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x74, 0x68,
-		0x61, 0x74, 0x2c, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x69, 0x6e, 0x76,
-		0x6f, 0x6b, 0x65, 0x64, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f,
-		0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67,
-		0x65, 0x72, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x6d, 0x6f, 0x73, 0x74,
-		0x20, 0x6f, 0x6e, 0x63, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x64,
-		0x75, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65,
-		0x6e, 0x20, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x20, 0x6f, 0x66, 0x20,
-		0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x74, 0x68,
-		0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e, 0x63, 0x2c, 0x20,
-		0x77, 0x61, 0x69, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c,
-		0x20, 0x61, 0x72, 0x67, 0x73, 0x2c, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x6f,
-		0x75, 0x74, 0x2c, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x65, 0x76,
-		0x69, 0x6f, 0x75, 0x73, 0x20, 0x3d, 0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70, 0x72, 0x65,
-		0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20,
-		0x44, 0x61, 0x74, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x6e, 0x75,
-		0x6c, 0x6c, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e,
-		0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78,
-		0x74, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x6e, 0x65, 0x77,
-		0x20, 0x44, 0x61, 0x74, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69,
-		0x6e, 0x67, 0x20, 0x3d, 0x20, 0x77, 0x61, 0x69, 0x74, 0x20, 0x2d, 0x20,
-		0x28, 0x6e, 0x6f, 0x77, 0x20, 0x2d, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69,
-		0x6f, 0x75, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x3d, 0x20, 0x74, 0x68,
-		0x69, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x61, 0x72,
-		0x67, 0x73, 0x20, 0x3d, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e,
-		0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20,
-		0x3c, 0x3d, 0x20, 0x30, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x54, 0x69, 0x6d,
-		0x65, 0x6f, 0x75, 0x74, 0x28, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74,
-		0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x6e, 0x75, 0x6c,
-		0x6c, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70,
-		0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x3d, 0x20, 0x6e, 0x6f,
-		0x77, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-		0x78, 0x74, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x21, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x65,
-		0x74, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x28, 0x6c, 0x61, 0x74,
-		0x65, 0x72, 0x2c, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e,
-		0x67, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x6c, 0x6f, 0x6e, 0x67,
-		0x20, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69,
-		0x6e, 0x75, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x69,
-		0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x64, 0x2c, 0x20, 0x77, 0x69, 0x6c, 0x6c,
-		0x20, 0x6e, 0x6f, 0x74, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x62, 0x65,
-		0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x65, 0x64, 0x2e, 0x20,
-		0x54, 0x68, 0x65, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x63, 0x61, 0x6c,
-		0x6c, 0x65, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20, 0x69, 0x74,
-		0x20, 0x73, 0x74, 0x6f, 0x70, 0x73, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67,
-		0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4e, 0x20, 0x6d, 0x69, 0x6c, 0x6c, 0x69,
-		0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x2e, 0x20, 0x49, 0x66, 0x20,
-		0x60, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x60, 0x20,
-		0x69, 0x73, 0x20, 0x70, 0x61, 0x73, 0x73, 0x65, 0x64, 0x2c, 0x20, 0x74,
-		0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6c, 0x65, 0x61, 0x64,
-		0x69, 0x6e, 0x67, 0x20, 0x65, 0x64, 0x67, 0x65, 0x2c, 0x20, 0x69, 0x6e,
-		0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x64, 0x65, 0x62, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66,
-		0x75, 0x6e, 0x63, 0x2c, 0x20, 0x77, 0x61, 0x69, 0x74, 0x2c, 0x20, 0x69,
-		0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x74, 0x69, 0x6d, 0x65,
-		0x6f, 0x75, 0x74, 0x2c, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x3d, 0x20, 0x74, 0x68, 0x69,
-		0x73, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x72,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x6e, 0x75,
-		0x6c, 0x6c, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x21, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61,
-		0x74, 0x65, 0x29, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28,
-		0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x61, 0x72, 0x67,
-		0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x63,
-		0x61, 0x6c, 0x6c, 0x4e, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x69, 0x6d, 0x6d,
-		0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x20, 0x26, 0x26, 0x20, 0x21, 0x74,
-		0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x6f,
-		0x75, 0x74, 0x28, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x6f,
-		0x75, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65,
-		0x6f, 0x75, 0x74, 0x28, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x77,
-		0x61, 0x69, 0x74, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x63, 0x61, 0x6c, 0x6c, 0x4e, 0x6f, 0x77, 0x29,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x63, 0x6f, 0x6e,
-		0x74, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20,
-		0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20,
-		0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20,
-		0x6d, 0x6f, 0x73, 0x74, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x69, 0x6d,
-		0x65, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72,
-		0x20, 0x68, 0x6f, 0x77, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x66,
-		0x74, 0x65, 0x6e, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x63, 0x61, 0x6c, 0x6c,
-		0x20, 0x69, 0x74, 0x2e, 0x20, 0x55, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20,
-		0x66, 0x6f, 0x72, 0x20, 0x6c, 0x61, 0x7a, 0x79, 0x20, 0x69, 0x6e, 0x69,
-		0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e,
-		0x63, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x72, 0x61, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65,
-		0x2c, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x72, 0x61, 0x6e, 0x29, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x65, 0x6d, 0x6f, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x61, 0x6e, 0x20, 0x3d, 0x20,
-		0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x6d, 0x65, 0x6d, 0x6f, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e,
-		0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20,
-		0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x20, 0x3d,
-		0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x65, 0x6d, 0x6f,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73,
-		0x74, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70,
-		0x61, 0x73, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x20,
-		0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x2c, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e,
-		0x67, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x6a,
-		0x75, 0x73, 0x74, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x2c, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20,
-		0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61,
-		0x66, 0x74, 0x65, 0x72, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-		0x61, 0x6c, 0x6c, 0x79, 0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61,
-		0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x77, 0x72, 0x61, 0x70, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x66, 0x75, 0x6e, 0x63,
-		0x2c, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61,
-		0x72, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x66, 0x75, 0x6e, 0x63, 0x5d,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70, 0x75, 0x73, 0x68,
-		0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x61, 0x72, 0x67, 0x73, 0x2c,
-		0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x2e, 0x61, 0x70,
-		0x70, 0x6c, 0x79, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20, 0x61, 0x72,
-		0x67, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69,
-		0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73,
-		0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x6c,
-		0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x65, 0x61, 0x63, 0x68, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x69, 0x6e,
-		0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x73, 0x20, 0x3d, 0x20, 0x61, 0x72, 0x67, 0x75,
-		0x6d, 0x65, 0x6e, 0x74, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73, 0x20, 0x3d, 0x20,
-		0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61,
-		0x72, 0x20, 0x69, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x73, 0x2e,
-		0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x2d, 0x20, 0x31, 0x3b, 0x20,
-		0x69, 0x20, 0x3e, 0x3d, 0x20, 0x30, 0x3b, 0x20, 0x69, 0x2d, 0x2d, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x61,
-		0x72, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x66, 0x75, 0x6e, 0x63, 0x73,
-		0x5b, 0x69, 0x5d, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x74, 0x68,
-		0x69, 0x73, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73, 0x29, 0x5d, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x72, 0x67,
-		0x73, 0x5b, 0x30, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20,
-		0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x65,
-		0x20, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x20, 0x61, 0x66,
-		0x74, 0x65, 0x72, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x61,
-		0x6c, 0x6c, 0x65, 0x64, 0x20, 0x4e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74,
-		0x69, 0x6d, 0x65, 0x73, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x74, 0x69,
-		0x6d, 0x65, 0x73, 0x20, 0x3c, 0x3d, 0x20, 0x30, 0x29, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x28, 0x29, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x2d,
-		0x2d, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x3c, 0x20, 0x31, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e, 0x61, 0x70,
-		0x70, 0x6c, 0x79, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20, 0x61, 0x72,
-		0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74,
-		0x72, 0x69, 0x65, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61,
-		0x6d, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x27, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65,
-		0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f,
-		0x20, 0x2a, 0x2a, 0x45, 0x43, 0x4d, 0x41, 0x53, 0x63, 0x72, 0x69, 0x70,
-		0x74, 0x20, 0x35, 0x2a, 0x2a, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x69,
-		0x76, 0x65, 0x20, 0x60, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x6b,
-		0x65, 0x79, 0x73, 0x60, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6b, 0x65, 0x79,
-		0x73, 0x20, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x4b, 0x65,
-		0x79, 0x73, 0x20, 0x7c, 0x7c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x21, 0x3d,
-		0x3d, 0x20, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x29, 0x20, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x6e, 0x65, 0x77,
-		0x20, 0x54, 0x79, 0x70, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x27,
-		0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x27, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61,
-		0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28,
-		0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29, 0x20, 0x6b,
-		0x65, 0x79, 0x73, 0x5b, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x6c, 0x65, 0x6e,
-		0x67, 0x74, 0x68, 0x5d, 0x20, 0x3d, 0x20, 0x6b, 0x65, 0x79, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6b,
-		0x65, 0x79, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20,
-		0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x27, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65,
-		0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x73, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x3d,
-		0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e,
-		0x20, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e,
-		0x68, 0x61, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79,
-		0x29, 0x29, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x70, 0x75,
-		0x73, 0x68, 0x28, 0x6f, 0x62, 0x6a, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x29,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6e, 0x76,
-		0x65, 0x72, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x6c, 0x69, 0x73,
-		0x74, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x5b, 0x6b, 0x65, 0x79, 0x2c, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x5d, 0x60, 0x20, 0x70, 0x61, 0x69, 0x72,
-		0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x70, 0x61, 0x69, 0x72, 0x73,
-		0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x20, 0x3d, 0x20, 0x5b,
-		0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28,
-		0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68, 0x61,
-		0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29,
-		0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28,
-		0x5b, 0x6b, 0x65, 0x79, 0x2c, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x6b, 0x65,
-		0x79, 0x5d, 0x5d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x61, 0x69, 0x72, 0x73, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49,
-		0x6e, 0x76, 0x65, 0x72, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65,
-		0x79, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73,
-		0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x7b,
-		0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28,
-		0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68, 0x61,
-		0x73, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5b, 0x6f, 0x62, 0x6a, 0x5b,
-		0x6b, 0x65, 0x79, 0x5d, 0x5d, 0x20, 0x3d, 0x20, 0x6b, 0x65, 0x79, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x61, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6c,
-		0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65,
-		0x73, 0x20, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x20,
-		0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6c, 0x69, 0x61,
-		0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x60, 0x6d, 0x65, 0x74, 0x68,
-		0x6f, 0x64, 0x73, 0x60, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x6d,
-		0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x61, 0x6d,
-		0x65, 0x73, 0x20, 0x3d, 0x20, 0x5b, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x6b, 0x65,
-		0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e,
-		0x69, 0x73, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f,
-		0x62, 0x6a, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x29, 0x29, 0x20, 0x6e, 0x61,
-		0x6d, 0x65, 0x73, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28, 0x6b, 0x65, 0x79,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65,
-		0x73, 0x2e, 0x73, 0x6f, 0x72, 0x74, 0x28, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x45, 0x78, 0x74,
-		0x65, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20,
-		0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x70,
-		0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x70, 0x61,
-		0x73, 0x73, 0x65, 0x64, 0x2d, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x28, 0x73, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x65,
-		0x78, 0x74, 0x65, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x73, 0x6c, 0x69,
-		0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75,
-		0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29, 0x2c, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x6f, 0x75, 0x72,
-		0x63, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f,
-		0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x20,
-		0x69, 0x6e, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f,
-		0x62, 0x6a, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x5d, 0x20, 0x3d, 0x20, 0x73,
-		0x6f, 0x75, 0x72, 0x63, 0x65, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x5d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x61, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x6e,
-		0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e,
-		0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65, 0x6c,
-		0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72,
-		0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x70, 0x69,
-		0x63, 0x6b, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x3d, 0x20,
-		0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x6b, 0x65, 0x79, 0x73, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x61,
-		0x74, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x41, 0x72, 0x72, 0x61,
-		0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2c, 0x20, 0x73, 0x6c, 0x69, 0x63,
-		0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d,
-		0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x6b, 0x65, 0x79, 0x73,
-		0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6b,
-		0x65, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f,
-		0x62, 0x6a, 0x29, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x5b, 0x6b, 0x65, 0x79,
-		0x5d, 0x20, 0x3d, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x6b, 0x65, 0x79, 0x5d,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x63, 0x6f, 0x70,
-		0x79, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20,
-		0x63, 0x6f, 0x70, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6f,
-		0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x6c, 0x61, 0x63, 0x6b,
-		0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65,
-		0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6f,
-		0x6d, 0x69, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x20, 0x3d,
-		0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x3d, 0x20, 0x63, 0x6f, 0x6e, 0x63,
-		0x61, 0x74, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x41, 0x72, 0x72,
-		0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2c, 0x20, 0x73, 0x6c, 0x69,
-		0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67, 0x75,
-		0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31, 0x29, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72,
-		0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x21, 0x5f, 0x2e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73,
-		0x28, 0x6b, 0x65, 0x79, 0x73, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29,
-		0x20, 0x63, 0x6f, 0x70, 0x79, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x20, 0x3d,
-		0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x6b, 0x65, 0x79, 0x5d, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x63, 0x6f, 0x70, 0x79, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x46, 0x69, 0x6c,
-		0x6c, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e,
-		0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68,
-		0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x70, 0x72, 0x6f,
-		0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68,
-		0x28, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x31,
-		0x29, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x73, 0x6f, 0x75, 0x72,
-		0x63, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20, 0x70,
-		0x72, 0x6f, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63,
-		0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x5b, 0x70,
-		0x72, 0x6f, 0x70, 0x5d, 0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c,
-		0x29, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x70, 0x72, 0x6f, 0x70, 0x5d, 0x20,
-		0x3d, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5b, 0x70, 0x72, 0x6f,
-		0x70, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x72, 0x65,
-		0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x28, 0x73, 0x68, 0x61, 0x6c, 0x6c,
-		0x6f, 0x77, 0x2d, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x29, 0x20, 0x64,
-		0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x20,
-		0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x20, 0x3d, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21,
-		0x5f, 0x2e, 0x69, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f,
-		0x62, 0x6a, 0x29, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61,
-		0x79, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x3f, 0x20, 0x6f, 0x62, 0x6a,
-		0x2e, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x28, 0x29, 0x20, 0x3a, 0x20, 0x5f,
-		0x2e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x28, 0x7b, 0x7d, 0x2c, 0x20,
-		0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x73,
-		0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x6f, 0x72,
-		0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x6f, 0x62, 0x6a, 0x2e,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x72,
-		0x69, 0x6d, 0x61, 0x72, 0x79, 0x20, 0x70, 0x75, 0x72, 0x70, 0x6f, 0x73,
-		0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65,
-		0x74, 0x68, 0x6f, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x22,
-		0x74, 0x61, 0x70, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x22, 0x20, 0x61, 0x20,
-		0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e,
-		0x2c, 0x20, 0x69, 0x6e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x72,
-		0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f,
-		0x72, 0x6d, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-		0x73, 0x20, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6d, 0x65,
-		0x64, 0x69, 0x61, 0x74, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
-		0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
-		0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e,
-		0x74, 0x61, 0x70, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x69, 0x6e, 0x74, 0x65,
-		0x72, 0x63, 0x65, 0x70, 0x74, 0x6f, 0x72, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74,
-		0x6f, 0x72, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x63,
-		0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61,
-		0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x60, 0x69, 0x73, 0x45, 0x71,
-		0x75, 0x61, 0x6c, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x65, 0x71, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x61, 0x2c, 0x20, 0x62, 0x2c, 0x20, 0x61, 0x53, 0x74, 0x61,
-		0x63, 0x6b, 0x2c, 0x20, 0x62, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x64, 0x65,
-		0x6e, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c,
-		0x2e, 0x20, 0x60, 0x30, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x2d, 0x30, 0x60,
-		0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61,
-		0x72, 0x65, 0x6e, 0x27, 0x74, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69,
-		0x63, 0x61, 0x6c, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x53, 0x65, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x48, 0x61, 0x72, 0x6d,
-		0x6f, 0x6e, 0x79, 0x20, 0x60, 0x65, 0x67, 0x61, 0x6c, 0x60, 0x20, 0x70,
-		0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x3a, 0x20, 0x68, 0x74, 0x74,
-		0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x69, 0x6b, 0x69, 0x2e, 0x65, 0x63, 0x6d,
-		0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
-		0x64, 0x6f, 0x6b, 0x75, 0x2e, 0x70, 0x68, 0x70, 0x3f, 0x69, 0x64, 0x3d,
-		0x68, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x79, 0x3a, 0x65, 0x67, 0x61, 0x6c,
-		0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x62, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x61, 0x20, 0x21, 0x3d, 0x3d, 0x20, 0x30, 0x20, 0x7c, 0x7c,
-		0x20, 0x31, 0x20, 0x2f, 0x20, 0x61, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20,
-		0x2f, 0x20, 0x62, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x41, 0x20, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x20, 0x63, 0x6f, 0x6d,
-		0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x6e,
-		0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x20, 0x62, 0x65, 0x63,
-		0x61, 0x75, 0x73, 0x65, 0x20, 0x60, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x3d,
-		0x3d, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x60,
-		0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x20,
-		0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x7c, 0x7c, 0x20, 0x62,
-		0x20, 0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x62,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x55, 0x6e, 0x77,
-		0x72, 0x61, 0x70, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x77, 0x72, 0x61, 0x70,
-		0x70, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x20, 0x69,
-		0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f, 0x66, 0x20, 0x5f, 0x29,
-		0x20, 0x61, 0x20, 0x3d, 0x20, 0x61, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70,
-		0x70, 0x65, 0x64, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x62, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f,
-		0x66, 0x20, 0x5f, 0x29, 0x20, 0x62, 0x20, 0x3d, 0x20, 0x62, 0x2e, 0x5f,
-		0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x20,
-		0x60, 0x5b, 0x5b, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x5d, 0x5d, 0x60, 0x20,
-		0x6e, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65,
-		0x20, 0x3d, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e,
-		0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61,
-		0x6d, 0x65, 0x20, 0x21, 0x3d, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69,
-		0x6e, 0x67, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x62, 0x29, 0x29, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68,
-		0x20, 0x28, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x2c, 0x20, 0x6e, 0x75, 0x6d,
-		0x62, 0x65, 0x72, 0x73, 0x2c, 0x20, 0x64, 0x61, 0x74, 0x65, 0x73, 0x2c,
-		0x20, 0x61, 0x6e, 0x64, 0x20, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e,
-		0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72,
-		0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20,
-		0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x53, 0x74, 0x72,
-		0x69, 0x6e, 0x67, 0x5d, 0x27, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x50, 0x72, 0x69, 0x6d, 0x69, 0x74,
-		0x69, 0x76, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65,
-		0x69, 0x72, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-		0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20,
-		0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65,
-		0x20, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x3b,
-		0x20, 0x74, 0x68, 0x75, 0x73, 0x2c, 0x20, 0x60, 0x22, 0x35, 0x22, 0x60,
-		0x20, 0x69, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e,
-		0x74, 0x20, 0x74, 0x6f, 0x20, 0x60, 0x6e, 0x65, 0x77, 0x20, 0x53, 0x74,
-		0x72, 0x69, 0x6e, 0x67, 0x28, 0x22, 0x35, 0x22, 0x29, 0x60, 0x2e, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x61, 0x20, 0x3d, 0x3d, 0x20, 0x53, 0x74, 0x72, 0x69,
-		0x6e, 0x67, 0x28, 0x62, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x20, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5d, 0x27, 0x3a,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x60, 0x4e, 0x61, 0x4e, 0x60, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x65,
-		0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x62,
-		0x75, 0x74, 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x72, 0x65, 0x66, 0x6c, 0x65,
-		0x78, 0x69, 0x76, 0x65, 0x2e, 0x20, 0x41, 0x6e, 0x20, 0x60, 0x65, 0x67,
-		0x61, 0x6c, 0x60, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73,
-		0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72,
-		0x6d, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72,
-		0x20, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x21, 0x3d,
-		0x20, 0x2b, 0x61, 0x20, 0x3f, 0x20, 0x62, 0x20, 0x21, 0x3d, 0x20, 0x2b,
-		0x62, 0x20, 0x3a, 0x20, 0x28, 0x61, 0x20, 0x3d, 0x3d, 0x20, 0x30, 0x20,
-		0x3f, 0x20, 0x31, 0x20, 0x2f, 0x20, 0x61, 0x20, 0x3d, 0x3d, 0x20, 0x31,
-		0x20, 0x2f, 0x20, 0x62, 0x20, 0x3a, 0x20, 0x61, 0x20, 0x3d, 0x3d, 0x20,
-		0x2b, 0x62, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63,
-		0x61, 0x73, 0x65, 0x20, 0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x20, 0x44, 0x61, 0x74, 0x65, 0x5d, 0x27, 0x3a, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x27, 0x5b, 0x6f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x20, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e,
-		0x5d, 0x27, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x65, 0x72, 0x63, 0x65, 0x20, 0x64, 0x61,
-		0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x62, 0x6f, 0x6f, 0x6c,
-		0x65, 0x61, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6e, 0x75, 0x6d, 0x65,
-		0x72, 0x69, 0x63, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76,
-		0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x2e, 0x20, 0x44, 0x61,
-		0x74, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70,
-		0x61, 0x72, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x69,
-		0x72, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64,
-		0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74,
-		0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74,
-		0x68, 0x61, 0x74, 0x20, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20,
-		0x64, 0x61, 0x74, 0x65, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6d,
-		0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, 0x72,
-		0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
-		0x6e, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x6f, 0x66, 0x20, 0x60, 0x4e, 0x61, 0x4e, 0x60, 0x20, 0x61,
-		0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x71, 0x75, 0x69, 0x76,
-		0x61, 0x6c, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x2b, 0x61,
-		0x20, 0x3d, 0x3d, 0x20, 0x2b, 0x62, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x67, 0x45, 0x78, 0x70, 0x73,
-		0x20, 0x61, 0x72, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65,
-		0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x73,
-		0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x61, 0x74, 0x74, 0x65, 0x72,
-		0x6e, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6c, 0x61, 0x67, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x61, 0x73, 0x65,
-		0x20, 0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x52, 0x65,
-		0x67, 0x45, 0x78, 0x70, 0x5d, 0x27, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61,
-		0x2e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x62,
-		0x2e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x26, 0x26, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x61, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x3d,
-		0x3d, 0x20, 0x62, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x26,
-		0x26, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x61, 0x2e, 0x6d, 0x75, 0x6c, 0x74, 0x69,
-		0x6c, 0x69, 0x6e, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x62, 0x2e, 0x6d, 0x75,
-		0x6c, 0x74, 0x69, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x26, 0x26, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x61, 0x2e, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61,
-		0x73, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x62, 0x2e, 0x69, 0x67, 0x6e, 0x6f,
-		0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x74, 0x79,
-		0x70, 0x65, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x21, 0x3d, 0x20, 0x27, 0x6f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x27, 0x20, 0x7c, 0x7c, 0x20, 0x74, 0x79,
-		0x70, 0x65, 0x6f, 0x66, 0x20, 0x62, 0x20, 0x21, 0x3d, 0x20, 0x27, 0x6f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x27, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x20,
-		0x65, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x63, 0x79, 0x63, 0x6c, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72, 0x75,
-		0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20,
-		0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x20, 0x66, 0x6f,
-		0x72, 0x20, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x20,
-		0x63, 0x79, 0x63, 0x6c, 0x69, 0x63, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73,
-		0x20, 0x69, 0x73, 0x20, 0x61, 0x64, 0x61, 0x70, 0x74, 0x65, 0x64, 0x20,
-		0x66, 0x72, 0x6f, 0x6d, 0x20, 0x45, 0x53, 0x20, 0x35, 0x2e, 0x31, 0x20,
-		0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x31, 0x35, 0x2e, 0x31,
-		0x32, 0x2e, 0x33, 0x2c, 0x20, 0x61, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63,
-		0x74, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
-		0x60, 0x4a, 0x4f, 0x60, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61,
-		0x72, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x61,
-		0x53, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20,
-		0x28, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x2d, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4c, 0x69,
-		0x6e, 0x65, 0x61, 0x72, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x2e,
-		0x20, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65,
-		0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x6c,
-		0x79, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e,
-		0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x75,
-		0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20,
-		0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63,
-		0x74, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x61, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x5b,
-		0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x20, 0x3d, 0x3d, 0x20, 0x61,
-		0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62, 0x53, 0x74,
-		0x61, 0x63, 0x6b, 0x5b, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5d, 0x20,
-		0x3d, 0x3d, 0x20, 0x62, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
-		0x74, 0x61, 0x63, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61, 0x76,
-		0x65, 0x72, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x53, 0x74, 0x61, 0x63,
-		0x6b, 0x2e, 0x70, 0x75, 0x73, 0x68, 0x28, 0x61, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x62, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x70, 0x75,
-		0x73, 0x68, 0x28, 0x62, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x2c,
-		0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x74, 0x72,
-		0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52,
-		0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x20, 0x63,
-		0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
-		0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x63,
-		0x6c, 0x61, 0x73, 0x73, 0x4e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x3d, 0x20,
-		0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x41, 0x72, 0x72,
-		0x61, 0x79, 0x5d, 0x27, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65,
-		0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6c, 0x65, 0x6e, 0x67, 0x74,
-		0x68, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d,
-		0x69, 0x6e, 0x65, 0x20, 0x69, 0x66, 0x20, 0x61, 0x20, 0x64, 0x65, 0x65,
-		0x70, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e,
-		0x20, 0x69, 0x73, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72,
-		0x79, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x69, 0x7a,
-		0x65, 0x20, 0x3d, 0x20, 0x61, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x3d,
-		0x20, 0x62, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x72, 0x65, 0x73,
-		0x75, 0x6c, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x65, 0x70, 0x20, 0x63,
-		0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63,
-		0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x69, 0x67, 0x6e,
-		0x6f, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x6e, 0x75,
-		0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72,
-		0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x28, 0x73, 0x69, 0x7a,
-		0x65, 0x2d, 0x2d, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x21, 0x28, 0x72,
-		0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x65, 0x71, 0x28, 0x61,
-		0x5b, 0x73, 0x69, 0x7a, 0x65, 0x5d, 0x2c, 0x20, 0x62, 0x5b, 0x73, 0x69,
-		0x7a, 0x65, 0x5d, 0x2c, 0x20, 0x61, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x2c,
-		0x20, 0x62, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x29, 0x29, 0x29, 0x20, 0x62,
-		0x72, 0x65, 0x61, 0x6b, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x64,
-		0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e,
-		0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x20, 0x61, 0x72,
-		0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61,
-		0x6c, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x60, 0x4f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x60, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x64, 0x69,
-		0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x72, 0x61, 0x6d,
-		0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x43, 0x74, 0x6f, 0x72, 0x20,
-		0x3d, 0x20, 0x61, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63,
-		0x74, 0x6f, 0x72, 0x2c, 0x20, 0x62, 0x43, 0x74, 0x6f, 0x72, 0x20, 0x3d,
-		0x20, 0x62, 0x2e, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
-		0x6f, 0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x61, 0x43, 0x74, 0x6f, 0x72, 0x20, 0x21, 0x3d, 0x3d, 0x20,
-		0x62, 0x43, 0x74, 0x6f, 0x72, 0x20, 0x26, 0x26, 0x20, 0x21, 0x28, 0x5f,
-		0x2e, 0x69, 0x73, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x61, 0x43, 0x74, 0x6f, 0x72, 0x29, 0x20, 0x26, 0x26, 0x20, 0x28, 0x61,
-		0x43, 0x74, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
-		0x65, 0x6f, 0x66, 0x20, 0x61, 0x43, 0x74, 0x6f, 0x72, 0x29, 0x20, 0x26,
-		0x26, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5f, 0x2e, 0x69,
-		0x73, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x62, 0x43,
-		0x74, 0x6f, 0x72, 0x29, 0x20, 0x26, 0x26, 0x20, 0x28, 0x62, 0x43, 0x74,
-		0x6f, 0x72, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x6f,
-		0x66, 0x20, 0x62, 0x43, 0x74, 0x6f, 0x72, 0x29, 0x29, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x65, 0x70, 0x20, 0x63, 0x6f, 0x6d,
-		0x70, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20,
-		0x28, 0x76, 0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20,
-		0x61, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28, 0x61,
-		0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43,
-		0x6f, 0x75, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78, 0x70,
-		0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
-		0x20, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69,
-		0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x73, 0x69, 0x7a, 0x65, 0x2b, 0x2b, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44,
-		0x65, 0x65, 0x70, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x2e,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x21, 0x28, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20,
-		0x3d, 0x20, 0x5f, 0x2e, 0x68, 0x61, 0x73, 0x28, 0x62, 0x2c, 0x20, 0x6b,
-		0x65, 0x79, 0x29, 0x20, 0x26, 0x26, 0x20, 0x65, 0x71, 0x28, 0x61, 0x5b,
-		0x6b, 0x65, 0x79, 0x5d, 0x2c, 0x20, 0x62, 0x5b, 0x6b, 0x65, 0x79, 0x5d,
-		0x2c, 0x20, 0x61, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x2c, 0x20, 0x62, 0x53,
-		0x74, 0x61, 0x63, 0x6b, 0x29, 0x29, 0x29, 0x20, 0x62, 0x72, 0x65, 0x61,
-		0x6b, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x45, 0x6e, 0x73, 0x75, 0x72, 0x65,
-		0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x6f,
-		0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61,
-		0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20,
-		0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x72,
-		0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x6b, 0x65, 0x79, 0x20, 0x69,
-		0x6e, 0x20, 0x62, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68,
-		0x61, 0x73, 0x28, 0x62, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x26,
-		0x26, 0x20, 0x21, 0x28, 0x73, 0x69, 0x7a, 0x65, 0x2d, 0x2d, 0x29, 0x29,
-		0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x21,
-		0x73, 0x69, 0x7a, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20,
-		0x73, 0x74, 0x61, 0x63, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x72, 0x61,
-		0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x53, 0x74, 0x61,
-		0x63, 0x6b, 0x2e, 0x70, 0x6f, 0x70, 0x28, 0x29, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x62, 0x53, 0x74, 0x61, 0x63, 0x6b, 0x2e, 0x70, 0x6f, 0x70,
-		0x28, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x50, 0x65,
-		0x72, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x61, 0x20, 0x64, 0x65, 0x65, 0x70,
-		0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20,
-		0x74, 0x6f, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x20, 0x69, 0x66, 0x20,
-		0x74, 0x77, 0x6f, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20,
-		0x61, 0x72, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x69, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x3d,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x2c,
-		0x20, 0x62, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-		0x74, 0x75, 0x72, 0x6e, 0x20, 0x65, 0x71, 0x28, 0x61, 0x2c, 0x20, 0x62,
-		0x2c, 0x20, 0x5b, 0x5d, 0x2c, 0x20, 0x5b, 0x5d, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73,
-		0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x72, 0x72,
-		0x61, 0x79, 0x2c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2c, 0x20,
-		0x6f, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x65, 0x6d,
-		0x70, 0x74, 0x79, 0x3f, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6e,
-		0x20, 0x22, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x65,
-		0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x6f, 0x77,
-		0x6e, 0x2d, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x45, 0x6d, 0x70, 0x74,
-		0x79, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x5f, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28,
-		0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7c, 0x7c, 0x20, 0x5f, 0x2e, 0x69, 0x73,
-		0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x2e,
-		0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x30,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76,
-		0x61, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x62,
-		0x6a, 0x29, 0x20, 0x69, 0x66, 0x20, 0x28, 0x5f, 0x2e, 0x68, 0x61, 0x73,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x29, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67,
-		0x69, 0x76, 0x65, 0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x61,
-		0x20, 0x44, 0x4f, 0x4d, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-		0x3f, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x45, 0x6c, 0x65, 0x6d,
-		0x65, 0x6e, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x21, 0x21, 0x28,
-		0x6f, 0x62, 0x6a, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6e,
-		0x6f, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x20, 0x3d, 0x3d, 0x3d, 0x20,
-		0x31, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65,
-		0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x61,
-		0x72, 0x72, 0x61, 0x79, 0x3f, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44,
-		0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20,
-		0x45, 0x43, 0x4d, 0x41, 0x35, 0x27, 0x73, 0x20, 0x6e, 0x61, 0x74, 0x69,
-		0x76, 0x65, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x69, 0x73, 0x41,
-		0x72, 0x72, 0x61, 0x79, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x41,
-		0x72, 0x72, 0x61, 0x79, 0x20, 0x3d, 0x20, 0x6e, 0x61, 0x74, 0x69, 0x76,
-		0x65, 0x49, 0x73, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x7c, 0x7c, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e,
-		0x63, 0x61, 0x6c, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x3d, 0x3d,
-		0x20, 0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x41, 0x72,
-		0x72, 0x61, 0x79, 0x5d, 0x27, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67,
-		0x69, 0x76, 0x65, 0x6e, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c,
-		0x65, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x3f,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x4f, 0x62, 0x6a, 0x65, 0x63,
-		0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x20, 0x3d,
-		0x3d, 0x3d, 0x20, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x28, 0x6f, 0x62,
-		0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20,
-		0x69, 0x73, 0x54, 0x79, 0x70, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f,
-		0x64, 0x73, 0x3a, 0x20, 0x69, 0x73, 0x41, 0x72, 0x67, 0x75, 0x6d, 0x65,
-		0x6e, 0x74, 0x73, 0x2c, 0x20, 0x69, 0x73, 0x46, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e,
-		0x67, 0x2c, 0x20, 0x69, 0x73, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c,
-		0x20, 0x69, 0x73, 0x44, 0x61, 0x74, 0x65, 0x2c, 0x20, 0x69, 0x73, 0x52,
-		0x65, 0x67, 0x45, 0x78, 0x70, 0x2e, 0x0a, 0x20, 0x20, 0x65, 0x61, 0x63,
-		0x68, 0x28, 0x5b, 0x27, 0x41, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x27, 0x2c, 0x20, 0x27, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x27, 0x2c, 0x20, 0x27, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x27,
-		0x2c, 0x20, 0x27, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x27, 0x2c, 0x20,
-		0x27, 0x44, 0x61, 0x74, 0x65, 0x27, 0x2c, 0x20, 0x27, 0x52, 0x65, 0x67,
-		0x45, 0x78, 0x70, 0x27, 0x5d, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x5f, 0x5b, 0x27, 0x69, 0x73, 0x27, 0x20, 0x2b,
-		0x20, 0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x74, 0x6f, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x3d, 0x3d, 0x20,
-		0x27, 0x5b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x27, 0x20, 0x2b,
-		0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x2b, 0x20, 0x27, 0x5d, 0x27, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x29,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x44, 0x65, 0x66, 0x69,
-		0x6e, 0x65, 0x20, 0x61, 0x20, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63,
-		0x6b, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20,
-		0x69, 0x6e, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x73, 0x20,
-		0x28, 0x61, 0x68, 0x65, 0x6d, 0x2c, 0x20, 0x49, 0x45, 0x29, 0x2c, 0x20,
-		0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x74,
-		0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x61,
-		0x6e, 0x79, 0x20, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x61, 0x62,
-		0x6c, 0x65, 0x20, 0x22, 0x41, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x22, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x21, 0x5f, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x67, 0x75,
-		0x6d, 0x65, 0x6e, 0x74, 0x73, 0x28, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65,
-		0x6e, 0x74, 0x73, 0x29, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x5f, 0x2e, 0x69, 0x73, 0x41, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x21, 0x21, 0x28,
-		0x6f, 0x62, 0x6a, 0x20, 0x26, 0x26, 0x20, 0x5f, 0x2e, 0x68, 0x61, 0x73,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x27, 0x63, 0x61, 0x6c, 0x6c, 0x65,
-		0x65, 0x27, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4f,
-		0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x20, 0x60, 0x69, 0x73, 0x46,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x60, 0x20, 0x69, 0x66, 0x20,
-		0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x2e,
-		0x0a, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x74, 0x79, 0x70, 0x65, 0x6f,
-		0x66, 0x20, 0x28, 0x2f, 0x2e, 0x2f, 0x29, 0x20, 0x21, 0x3d, 0x3d, 0x20,
-		0x27, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x46, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x20, 0x6f, 0x62, 0x6a,
-		0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x27, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x27, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73,
-		0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65,
-		0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x3f, 0x0a, 0x20, 0x20, 0x5f,
-		0x2e, 0x69, 0x73, 0x46, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x69, 0x73, 0x46, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x28,
-		0x6f, 0x62, 0x6a, 0x29, 0x20, 0x26, 0x26, 0x20, 0x21, 0x69, 0x73, 0x4e,
-		0x61, 0x4e, 0x28, 0x70, 0x61, 0x72, 0x73, 0x65, 0x46, 0x6c, 0x6f, 0x61,
-		0x74, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x76, 0x61, 0x6c,
-		0x75, 0x65, 0x20, 0x60, 0x4e, 0x61, 0x4e, 0x60, 0x3f, 0x20, 0x28, 0x4e,
-		0x61, 0x4e, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e,
-		0x6c, 0x79, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x77, 0x68,
-		0x69, 0x63, 0x68, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74,
-		0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c,
-		0x66, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x4e, 0x61,
-		0x4e, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x4e,
-		0x75, 0x6d, 0x62, 0x65, 0x72, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x26,
-		0x26, 0x20, 0x6f, 0x62, 0x6a, 0x20, 0x21, 0x3d, 0x20, 0x2b, 0x6f, 0x62,
-		0x6a, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65, 0x6e,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x61, 0x20, 0x62, 0x6f, 0x6f,
-		0x6c, 0x65, 0x61, 0x6e, 0x3f, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x73,
-		0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x74, 0x72, 0x75,
-		0x65, 0x20, 0x7c, 0x7c, 0x20, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x3d,
-		0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x20, 0x7c, 0x7c, 0x20, 0x74, 0x6f,
-		0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x6f, 0x62, 0x6a, 0x29, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x5b, 0x6f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x20, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e,
-		0x5d, 0x27, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76, 0x65,
-		0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61,
-		0x6c, 0x20, 0x74, 0x6f, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3f, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x69, 0x73, 0x4e, 0x75, 0x6c, 0x6c, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x6e,
-		0x75, 0x6c, 0x6c, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x49, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x76,
-		0x65, 0x6e, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20,
-		0x75, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x3f, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x69, 0x73, 0x55, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e,
-		0x65, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x62, 0x6a, 0x20,
-		0x3d, 0x3d, 0x3d, 0x20, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x30, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x53,
-		0x68, 0x6f, 0x72, 0x74, 0x63, 0x75, 0x74, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x68, 0x65,
-		0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x66, 0x20, 0x61, 0x6e, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x68, 0x61, 0x73, 0x20, 0x61,
-		0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65,
-		0x72, 0x74, 0x79, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x6e, 0x20, 0x69, 0x74, 0x73,
-		0x65, 0x6c, 0x66, 0x20, 0x28, 0x69, 0x6e, 0x20, 0x6f, 0x74, 0x68, 0x65,
-		0x72, 0x20, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x2c, 0x20, 0x6e, 0x6f, 0x74,
-		0x20, 0x6f, 0x6e, 0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74,
-		0x79, 0x70, 0x65, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x68, 0x61,
-		0x73, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x2c, 0x20, 0x6b, 0x65, 0x79, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x68, 0x61, 0x73, 0x4f, 0x77, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72,
-		0x74, 0x79, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x2c,
-		0x20, 0x6b, 0x65, 0x79, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74,
-		0x79, 0x20, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x55, 0x6e, 0x64,
-		0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x6a, 0x73, 0x20, 0x69,
-		0x6e, 0x20, 0x2a, 0x6e, 0x6f, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63,
-		0x74, 0x2a, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x60,
-		0x5f, 0x60, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20,
-		0x74, 0x6f, 0x20, 0x69, 0x74, 0x73, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x6f, 0x77, 0x6e,
-		0x65, 0x72, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20,
-		0x61, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20,
-		0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x72,
-		0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
-		0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6e, 0x6f, 0x43, 0x6f, 0x6e, 0x66,
-		0x6c, 0x69, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x6f, 0x6f, 0x74, 0x2e, 0x5f, 0x20, 0x3d, 0x20, 0x70, 0x72, 0x65,
-		0x76, 0x69, 0x6f, 0x75, 0x73, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63,
-		0x6f, 0x72, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x3b, 0x0a, 0x20, 0x20,
-		0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4b, 0x65, 0x65,
-		0x70, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69,
-		0x74, 0x79, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20,
-		0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64,
-		0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61,
-		0x74, 0x6f, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x69, 0x64,
-		0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x75, 0x6e, 0x20,
-		0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x2a,
-		0x2a, 0x6e, 0x2a, 0x2a, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x2c, 0x20,
-		0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2c, 0x20, 0x63, 0x6f,
-		0x6e, 0x74, 0x65, 0x78, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6d, 0x20, 0x3d,
-		0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x28, 0x6e, 0x29, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x76, 0x61, 0x72, 0x20,
-		0x69, 0x20, 0x3d, 0x20, 0x30, 0x3b, 0x20, 0x69, 0x20, 0x3c, 0x20, 0x6e,
-		0x3b, 0x20, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6d,
-		0x5b, 0x69, 0x5d, 0x20, 0x3d, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74,
-		0x6f, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x63, 0x6f, 0x6e, 0x74,
-		0x65, 0x78, 0x74, 0x2c, 0x20, 0x69, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x75,
-		0x6d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x72,
-		0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65,
-		0x72, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x6d, 0x69,
-		0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x28, 0x69,
-		0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x29, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x20, 0x3d, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6d, 0x69, 0x6e,
-		0x2c, 0x20, 0x6d, 0x61, 0x78, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6d, 0x61, 0x78, 0x20, 0x3d, 0x3d, 0x20,
-		0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x6d, 0x61, 0x78, 0x20, 0x3d, 0x20, 0x6d, 0x69, 0x6e, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x69, 0x6e, 0x20, 0x3d,
-		0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x69, 0x6e,
-		0x20, 0x2b, 0x20, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x66, 0x6c, 0x6f, 0x6f,
-		0x72, 0x28, 0x4d, 0x61, 0x74, 0x68, 0x2e, 0x72, 0x61, 0x6e, 0x64, 0x6f,
-		0x6d, 0x28, 0x29, 0x20, 0x2a, 0x20, 0x28, 0x6d, 0x61, 0x78, 0x20, 0x2d,
-		0x20, 0x6d, 0x69, 0x6e, 0x20, 0x2b, 0x20, 0x31, 0x29, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4c,
-		0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20,
-		0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x20,
-		0x20, 0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4d,
-		0x61, 0x70, 0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65,
-		0x73, 0x63, 0x61, 0x70, 0x65, 0x3a, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x27, 0x26, 0x27, 0x3a, 0x20, 0x27, 0x26, 0x61, 0x6d,
-		0x70, 0x3b, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x27,
-		0x3c, 0x27, 0x3a, 0x20, 0x27, 0x26, 0x6c, 0x74, 0x3b, 0x27, 0x2c, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x27, 0x3e, 0x27, 0x3a, 0x20, 0x27,
-		0x26, 0x67, 0x74, 0x3b, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x27, 0x22, 0x27, 0x3a, 0x20, 0x27, 0x26, 0x71, 0x75, 0x6f, 0x74,
-		0x3b, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x27,
-		0x22, 0x3a, 0x20, 0x27, 0x26, 0x23, 0x78, 0x32, 0x37, 0x3b, 0x27, 0x2c,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x27, 0x2f, 0x27, 0x3a, 0x20,
-		0x27, 0x26, 0x23, 0x78, 0x32, 0x46, 0x3b, 0x27, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x7d, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x65, 0x6e,
-		0x74, 0x69, 0x74, 0x79, 0x4d, 0x61, 0x70, 0x2e, 0x75, 0x6e, 0x65, 0x73,
-		0x63, 0x61, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x69, 0x6e, 0x76,
-		0x65, 0x72, 0x74, 0x28, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4d, 0x61,
-		0x70, 0x2e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x29, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x52, 0x65, 0x67, 0x65, 0x78, 0x65, 0x73,
-		0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x61, 0x6e, 0x64,
-		0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x6c, 0x69, 0x73, 0x74,
-		0x65, 0x64, 0x20, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65,
-		0x6c, 0x79, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65,
-		0x67, 0x65, 0x78, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x3a, 0x20, 0x20, 0x20,
-		0x6e, 0x65, 0x77, 0x20, 0x52, 0x65, 0x67, 0x45, 0x78, 0x70, 0x28, 0x27,
-		0x5b, 0x27, 0x20, 0x2b, 0x20, 0x5f, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x28,
-		0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4d, 0x61, 0x70, 0x2e, 0x65, 0x73,
-		0x63, 0x61, 0x70, 0x65, 0x29, 0x2e, 0x6a, 0x6f, 0x69, 0x6e, 0x28, 0x27,
-		0x27, 0x29, 0x20, 0x2b, 0x20, 0x27, 0x5d, 0x27, 0x2c, 0x20, 0x27, 0x67,
-		0x27, 0x29, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x6e, 0x65, 0x73,
-		0x63, 0x61, 0x70, 0x65, 0x3a, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x52, 0x65,
-		0x67, 0x45, 0x78, 0x70, 0x28, 0x27, 0x28, 0x27, 0x20, 0x2b, 0x20, 0x5f,
-		0x2e, 0x6b, 0x65, 0x79, 0x73, 0x28, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79,
-		0x4d, 0x61, 0x70, 0x2e, 0x75, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65,
-		0x29, 0x2e, 0x6a, 0x6f, 0x69, 0x6e, 0x28, 0x27, 0x7c, 0x27, 0x29, 0x20,
-		0x2b, 0x20, 0x27, 0x29, 0x27, 0x2c, 0x20, 0x27, 0x67, 0x27, 0x29, 0x0a,
-		0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x46,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e,
-		0x64, 0x20, 0x75, 0x6e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x69, 0x6e, 0x67,
-		0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2f,
-		0x66, 0x72, 0x6f, 0x6d, 0x20, 0x48, 0x54, 0x4d, 0x4c, 0x20, 0x69, 0x6e,
-		0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-		0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x65, 0x61, 0x63, 0x68, 0x28, 0x5b, 0x27,
-		0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x27, 0x2c, 0x20, 0x27, 0x75, 0x6e,
-		0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x27, 0x5d, 0x2c, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6d, 0x65, 0x74, 0x68, 0x6f,
-		0x64, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x5f, 0x5b, 0x6d,
-		0x65, 0x74, 0x68, 0x6f, 0x64, 0x5d, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
-		0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x3d, 0x20,
-		0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-		0x20, 0x27, 0x27, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x27, 0x27, 0x20, 0x2b, 0x20,
-		0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x29, 0x2e, 0x72, 0x65, 0x70, 0x6c,
-		0x61, 0x63, 0x65, 0x28, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65,
-		0x67, 0x65, 0x78, 0x65, 0x73, 0x5b, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,
-		0x5d, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x6d, 0x61, 0x74, 0x63, 0x68, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4d, 0x61, 0x70, 0x5b, 0x6d, 0x65,
-		0x74, 0x68, 0x6f, 0x64, 0x5d, 0x5b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5d,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x29, 0x3b,
-		0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f,
-		0x70, 0x65, 0x72, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x6e,
-		0x20, 0x69, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x20, 0x69, 0x74, 0x3b, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69,
-		0x73, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69,
-		0x74, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x72, 0x65, 0x73, 0x75, 0x6c,
-		0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2c, 0x20, 0x70, 0x72, 0x6f,
-		0x70, 0x65, 0x72, 0x74, 0x79, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x69, 0x66, 0x20, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20,
-		0x3d, 0x3d, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x29, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x6e, 0x75, 0x6c, 0x6c, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20,
-		0x3d, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5b, 0x70, 0x72, 0x6f,
-		0x70, 0x65, 0x72, 0x74, 0x79, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x2e, 0x69, 0x73, 0x46,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x76, 0x61, 0x6c, 0x75,
-		0x65, 0x29, 0x20, 0x3f, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x29, 0x20,
-		0x3a, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20,
-		0x79, 0x6f, 0x75, 0x72, 0x20, 0x6f, 0x77, 0x6e, 0x20, 0x63, 0x75, 0x73,
-		0x74, 0x6f, 0x6d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e, 0x64,
-		0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d, 0x69, 0x78, 0x69,
-		0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x61, 0x63, 0x68, 0x28, 0x5f, 0x2e, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x73, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2c, 0x20, 0x66,
-		0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65,
-		0x29, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x20, 0x3d, 0x20, 0x5f, 0x5b, 0x6e, 0x61,
-		0x6d, 0x65, 0x5d, 0x20, 0x3d, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x6e, 0x61,
-		0x6d, 0x65, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5f,
-		0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x5b, 0x6e,
-		0x61, 0x6d, 0x65, 0x5d, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x61, 0x72, 0x67, 0x73,
-		0x20, 0x3d, 0x20, 0x5b, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72,
-		0x61, 0x70, 0x70, 0x65, 0x64, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x70, 0x75, 0x73, 0x68, 0x2e, 0x61, 0x70, 0x70,
-		0x6c, 0x79, 0x28, 0x61, 0x72, 0x67, 0x73, 0x2c, 0x20, 0x61, 0x72, 0x67,
-		0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-		0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28,
-		0x74, 0x68, 0x69, 0x73, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x2e, 0x61,
-		0x70, 0x70, 0x6c, 0x79, 0x28, 0x5f, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x73,
-		0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x47, 0x65, 0x6e, 0x65,
-		0x72, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75,
-		0x65, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x20, 0x69, 0x64,
-		0x20, 0x28, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74,
-		0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x74, 0x69,
-		0x72, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x65,
-		0x73, 0x73, 0x69, 0x6f, 0x6e, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x55, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x20,
-		0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x20, 0x44, 0x4f,
-		0x4d, 0x20, 0x69, 0x64, 0x73, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x69, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x20, 0x3d,
-		0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x75, 0x6e, 0x69, 0x71,
-		0x75, 0x65, 0x49, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x29, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x64,
-		0x20, 0x3d, 0x20, 0x2b, 0x2b, 0x69, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74,
-		0x65, 0x72, 0x20, 0x2b, 0x20, 0x27, 0x27, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x66,
-		0x69, 0x78, 0x20, 0x3f, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x20,
-		0x2b, 0x20, 0x69, 0x64, 0x20, 0x3a, 0x20, 0x69, 0x64, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x42, 0x79,
-		0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x55, 0x6e,
-		0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x75, 0x73, 0x65,
-		0x73, 0x20, 0x45, 0x52, 0x42, 0x2d, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20,
-		0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x64, 0x65, 0x6c,
-		0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2c, 0x20, 0x63, 0x68, 0x61,
-		0x6e, 0x67, 0x65, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74,
-		0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x73, 0x65, 0x74, 0x74,
-		0x69, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20,
-		0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20,
-		0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2e, 0x0a,
-		0x20, 0x20, 0x5f, 0x2e, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65,
-		0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74,
-		0x65, 0x20, 0x20, 0x20, 0x20, 0x3a, 0x20, 0x2f, 0x3c, 0x25, 0x28, 0x5b,
-		0x5c, 0x73, 0x5c, 0x53, 0x5d, 0x2b, 0x3f, 0x29, 0x25, 0x3e, 0x2f, 0x67,
-		0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70,
-		0x6f, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x3a, 0x20, 0x2f, 0x3c, 0x25, 0x3d,
-		0x28, 0x5b, 0x5c, 0x73, 0x5c, 0x53, 0x5d, 0x2b, 0x3f, 0x29, 0x25, 0x3e,
-		0x2f, 0x67, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x73, 0x63, 0x61,
-		0x70, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3a, 0x20, 0x2f, 0x3c,
-		0x25, 0x2d, 0x28, 0x5b, 0x5c, 0x73, 0x5c, 0x53, 0x5d, 0x2b, 0x3f, 0x29,
-		0x25, 0x3e, 0x2f, 0x67, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x63, 0x75, 0x73,
-		0x74, 0x6f, 0x6d, 0x69, 0x7a, 0x69, 0x6e, 0x67, 0x20, 0x60, 0x74, 0x65,
-		0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e,
-		0x67, 0x73, 0x60, 0x2c, 0x20, 0x69, 0x66, 0x20, 0x79, 0x6f, 0x75, 0x20,
-		0x64, 0x6f, 0x6e, 0x27, 0x74, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, 0x74,
-		0x6f, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, 0x61, 0x6e, 0x0a,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f,
-		0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x65, 0x76, 0x61, 0x6c,
-		0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x72, 0x20, 0x65, 0x73,
-		0x63, 0x61, 0x70, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x67, 0x65, 0x78,
-		0x2c, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x6f, 0x6e,
-		0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65,
-		0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x74,
-		0x63, 0x68, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6e, 0x6f,
-		0x4d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x3d, 0x20, 0x2f, 0x28, 0x2e, 0x29,
-		0x5e, 0x2f, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x65,
-		0x72, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63,
-		0x74, 0x65, 0x72, 0x73, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f,
-		0x20, 0x62, 0x65, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x64, 0x20,
-		0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x79,
-		0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x70, 0x75, 0x74, 0x20,
-		0x69, 0x6e, 0x74, 0x6f, 0x20, 0x61, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x72,
-		0x61, 0x6c, 0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x65, 0x73,
-		0x63, 0x61, 0x70, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x22, 0x27, 0x22, 0x3a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x22, 0x27, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x27, 0x5c, 0x5c,
-		0x27, 0x3a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x27, 0x5c, 0x5c, 0x27, 0x2c,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x27, 0x5c, 0x72, 0x27, 0x3a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x27, 0x72, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x27, 0x5c, 0x6e, 0x27, 0x3a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x27, 0x6e,
-		0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x27, 0x5c, 0x74, 0x27, 0x3a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x27, 0x74, 0x27, 0x2c, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x27, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x38, 0x27, 0x3a, 0x20,
-		0x27, 0x75, 0x32, 0x30, 0x32, 0x38, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x27, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x39, 0x27, 0x3a, 0x20, 0x27,
-		0x75, 0x32, 0x30, 0x32, 0x39, 0x27, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70,
-		0x65, 0x72, 0x20, 0x3d, 0x20, 0x2f, 0x5c, 0x5c, 0x7c, 0x27, 0x7c, 0x5c,
-		0x72, 0x7c, 0x5c, 0x6e, 0x7c, 0x5c, 0x74, 0x7c, 0x5c, 0x75, 0x32, 0x30,
-		0x32, 0x38, 0x7c, 0x5c, 0x75, 0x32, 0x30, 0x32, 0x39, 0x2f, 0x67, 0x3b,
-		0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x4a, 0x61, 0x76, 0x61, 0x53,
-		0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x2d,
-		0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x20,
-		0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x4a,
-		0x6f, 0x68, 0x6e, 0x20, 0x52, 0x65, 0x73, 0x69, 0x67, 0x27, 0x73, 0x20,
-		0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69,
-		0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x55, 0x6e, 0x64,
-		0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x65, 0x6d, 0x70,
-		0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c,
-		0x65, 0x73, 0x20, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x79,
-		0x20, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x2c,
-		0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x73, 0x20, 0x77,
-		0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2c, 0x0a, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x72, 0x72,
-		0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65,
-		0x73, 0x20, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x20, 0x77, 0x69, 0x74,
-		0x68, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c,
-		0x61, 0x74, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x20,
-		0x20, 0x5f, 0x2e, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x74,
-		0x65, 0x78, 0x74, 0x2c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2c, 0x20, 0x73,
-		0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x29, 0x20, 0x7b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x6e, 0x64, 0x65,
-		0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x73, 0x65, 0x74, 0x74, 0x69,
-		0x6e, 0x67, 0x73, 0x20, 0x3d, 0x20, 0x5f, 0x2e, 0x64, 0x65, 0x66, 0x61,
-		0x75, 0x6c, 0x74, 0x73, 0x28, 0x7b, 0x7d, 0x2c, 0x20, 0x73, 0x65, 0x74,
-		0x74, 0x69, 0x6e, 0x67, 0x73, 0x2c, 0x20, 0x5f, 0x2e, 0x74, 0x65, 0x6d,
-		0x70, 0x6c, 0x61, 0x74, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67,
-		0x73, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x20, 0x64, 0x65, 0x6c, 0x69,
-		0x6d, 0x69, 0x74, 0x65, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20,
-		0x6f, 0x6e, 0x65, 0x20, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x20,
-		0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x76,
-		0x69, 0x61, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
-		0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20,
-		0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x6e, 0x65,
-		0x77, 0x20, 0x52, 0x65, 0x67, 0x45, 0x78, 0x70, 0x28, 0x5b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x28, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e,
-		0x67, 0x73, 0x2e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x20, 0x7c, 0x7c,
-		0x20, 0x6e, 0x6f, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x29, 0x2e, 0x73, 0x6f,
-		0x75, 0x72, 0x63, 0x65, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x28, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x69, 0x6e,
-		0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x7c, 0x7c,
-		0x20, 0x6e, 0x6f, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x29, 0x2e, 0x73, 0x6f,
-		0x75, 0x72, 0x63, 0x65, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x28, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x65, 0x76,
-		0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x20, 0x7c, 0x7c, 0x20, 0x6e, 0x6f,
-		0x4d, 0x61, 0x74, 0x63, 0x68, 0x29, 0x2e, 0x73, 0x6f, 0x75, 0x72, 0x63,
-		0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x5d, 0x2e, 0x6a, 0x6f, 0x69, 0x6e,
-		0x28, 0x27, 0x7c, 0x27, 0x29, 0x20, 0x2b, 0x20, 0x27, 0x7c, 0x24, 0x27,
-		0x2c, 0x20, 0x27, 0x67, 0x27, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x20,
-		0x74, 0x68, 0x65, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65,
-		0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2c, 0x20, 0x65, 0x73, 0x63,
-		0x61, 0x70, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
-		0x20, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x20, 0x61, 0x70,
-		0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x2e,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x64,
-		0x65, 0x78, 0x20, 0x3d, 0x20, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x3d,
-		0x20, 0x22, 0x5f, 0x5f, 0x70, 0x2b, 0x3d, 0x27, 0x22, 0x3b, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x72, 0x65, 0x70, 0x6c,
-		0x61, 0x63, 0x65, 0x28, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2c,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6d, 0x61,
-		0x74, 0x63, 0x68, 0x2c, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x2c,
-		0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61, 0x74, 0x65,
-		0x2c, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x2c, 0x20,
-		0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2b,
-		0x3d, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x73, 0x6c, 0x69, 0x63, 0x65,
-		0x28, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x6f, 0x66, 0x66, 0x73,
-		0x65, 0x74, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x2e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x28, 0x65, 0x73, 0x63,
-		0x61, 0x70, 0x65, 0x72, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-		0x6f, 0x6e, 0x28, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x29, 0x20, 0x7b, 0x20,
-		0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x27, 0x5c, 0x5c, 0x27, 0x20,
-		0x2b, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x73, 0x5b, 0x6d, 0x61,
-		0x74, 0x63, 0x68, 0x5d, 0x3b, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x0a, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x65, 0x73, 0x63,
-		0x61, 0x70, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2b, 0x3d,
-		0x20, 0x22, 0x27, 0x2b, 0x5c, 0x6e, 0x28, 0x28, 0x5f, 0x5f, 0x74, 0x3d,
-		0x28, 0x22, 0x20, 0x2b, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x20,
-		0x2b, 0x20, 0x22, 0x29, 0x29, 0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3f,
-		0x27, 0x27, 0x3a, 0x5f, 0x2e, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x28,
-		0x5f, 0x5f, 0x74, 0x29, 0x29, 0x2b, 0x5c, 0x6e, 0x27, 0x22, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70,
-		0x6f, 0x6c, 0x61, 0x74, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20,
-		0x2b, 0x3d, 0x20, 0x22, 0x27, 0x2b, 0x5c, 0x6e, 0x28, 0x28, 0x5f, 0x5f,
-		0x74, 0x3d, 0x28, 0x22, 0x20, 0x2b, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72,
-		0x70, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x20, 0x2b, 0x20, 0x22, 0x29, 0x29,
-		0x3d, 0x3d, 0x6e, 0x75, 0x6c, 0x6c, 0x3f, 0x27, 0x27, 0x3a, 0x5f, 0x5f,
-		0x74, 0x29, 0x2b, 0x5c, 0x6e, 0x27, 0x22, 0x3b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
-		0x66, 0x20, 0x28, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x29,
-		0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73,
-		0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2b, 0x3d, 0x20, 0x22, 0x27, 0x3b,
-		0x5c, 0x6e, 0x22, 0x20, 0x2b, 0x20, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61,
-		0x74, 0x65, 0x20, 0x2b, 0x20, 0x22, 0x5c, 0x6e, 0x5f, 0x5f, 0x70, 0x2b,
-		0x3d, 0x27, 0x22, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
-		0x20, 0x3d, 0x20, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x20, 0x2b, 0x20,
-		0x6d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68,
-		0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
-		0x72, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x73, 0x6f,
-		0x75, 0x72, 0x63, 0x65, 0x20, 0x2b, 0x3d, 0x20, 0x22, 0x27, 0x3b, 0x5c,
-		0x6e, 0x22, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20,
-		0x49, 0x66, 0x20, 0x61, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c,
-		0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x70, 0x65,
-		0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2c, 0x20, 0x70, 0x6c, 0x61, 0x63,
-		0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
-		0x73, 0x20, 0x69, 0x6e, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73,
-		0x63, 0x6f, 0x70, 0x65, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-		0x20, 0x28, 0x21, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x2e,
-		0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x29, 0x20, 0x73, 0x6f,
-		0x75, 0x72, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x27, 0x77, 0x69, 0x74, 0x68,
-		0x28, 0x6f, 0x62, 0x6a, 0x7c, 0x7c, 0x7b, 0x7d, 0x29, 0x7b, 0x5c, 0x6e,
-		0x27, 0x20, 0x2b, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2b,
-		0x20, 0x27, 0x7d, 0x5c, 0x6e, 0x27, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x22, 0x76,
-		0x61, 0x72, 0x20, 0x5f, 0x5f, 0x74, 0x2c, 0x5f, 0x5f, 0x70, 0x3d, 0x27,
-		0x27, 0x2c, 0x5f, 0x5f, 0x6a, 0x3d, 0x41, 0x72, 0x72, 0x61, 0x79, 0x2e,
-		0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6a, 0x6f,
-		0x69, 0x6e, 0x2c, 0x22, 0x20, 0x2b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x22, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x3d, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x7b, 0x5f, 0x5f, 0x70, 0x2b, 0x3d,
-		0x5f, 0x5f, 0x6a, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x61, 0x72, 0x67,
-		0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x27, 0x27, 0x29, 0x3b, 0x7d,
-		0x3b, 0x5c, 0x6e, 0x22, 0x20, 0x2b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x2b, 0x20, 0x22, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f, 0x5f, 0x70, 0x3b, 0x5c, 0x6e,
-		0x22, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x74, 0x72, 0x79, 0x20,
-		0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x6e, 0x64,
-		0x65, 0x72, 0x20, 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x46, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e,
-		0x67, 0x73, 0x2e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20,
-		0x7c, 0x7c, 0x20, 0x27, 0x6f, 0x62, 0x6a, 0x27, 0x2c, 0x20, 0x27, 0x5f,
-		0x27, 0x2c, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x63, 0x61, 0x74, 0x63, 0x68, 0x20,
-		0x28, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x65, 0x2e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x73,
-		0x6f, 0x75, 0x72, 0x63, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x20, 0x65, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x64, 0x61, 0x74, 0x61, 0x29, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-		0x6e, 0x20, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x28, 0x64, 0x61, 0x74,
-		0x61, 0x2c, 0x20, 0x5f, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76,
-		0x61, 0x72, 0x20, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x20,
-		0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x64,
-		0x61, 0x74, 0x61, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x6e, 0x64,
-		0x65, 0x72, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x74, 0x68, 0x69, 0x73,
-		0x2c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2c, 0x20, 0x5f, 0x29, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x64, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x6f, 0x75,
-		0x72, 0x63, 0x65, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e,
-		0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x66, 0x6f, 0x72,
-		0x20, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x61, 0x74,
-		0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x74, 0x65, 0x6d,
-		0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
-		0x20, 0x3d, 0x20, 0x27, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x27, 0x20, 0x2b, 0x20, 0x28, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e,
-		0x67, 0x73, 0x2e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x20,
-		0x7c, 0x7c, 0x20, 0x27, 0x6f, 0x62, 0x6a, 0x27, 0x29, 0x20, 0x2b, 0x20,
-		0x27, 0x29, 0x7b, 0x5c, 0x6e, 0x27, 0x20, 0x2b, 0x20, 0x73, 0x6f, 0x75,
-		0x72, 0x63, 0x65, 0x20, 0x2b, 0x20, 0x27, 0x7d, 0x27, 0x3b, 0x0a, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74,
-		0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x3b, 0x0a, 0x20, 0x20, 0x7d,
-		0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20,
-		0x61, 0x20, 0x22, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63,
-		0x68, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x67,
-		0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77,
-		0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e,
-		0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
-		0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x5f,
-		0x28, 0x6f, 0x62, 0x6a, 0x29, 0x2e, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x28,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x4f, 0x4f, 0x50, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x2d,
-		0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
-		0x2d, 0x2d, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x49, 0x66, 0x20, 0x55,
-		0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x69, 0x73,
-		0x20, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61,
-		0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69,
-		0x74, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x61, 0x20,
-		0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a, 0x65,
-		0x63, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x0a, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64,
-		0x20, 0x4f, 0x4f, 0x2d, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x2e, 0x20, 0x54,
-		0x68, 0x69, 0x73, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20,
-		0x68, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x65,
-		0x64, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f,
-		0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72,
-		0x65, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e,
-		0x20, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x6f, 0x62, 0x6a,
-		0x65, 0x63, 0x74, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20,
-		0x63, 0x68, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x20, 0x20,
-		0x2f, 0x2f, 0x20, 0x48, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f,
-		0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e,
-		0x69, 0x6e, 0x67, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6d, 0x65, 0x64,
-		0x69, 0x61, 0x74, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73,
-		0x2e, 0x0a, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x72, 0x65, 0x73, 0x75,
-		0x6c, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-		0x6e, 0x28, 0x6f, 0x62, 0x6a, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
-		0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73,
-		0x2e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x3f, 0x20, 0x5f, 0x28,
-		0x6f, 0x62, 0x6a, 0x29, 0x2e, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x28, 0x29,
-		0x20, 0x3a, 0x20, 0x6f, 0x62, 0x6a, 0x3b, 0x0a, 0x20, 0x20, 0x7d, 0x3b,
-		0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x64, 0x64, 0x20, 0x61,
-		0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x6e,
-		0x64, 0x65, 0x72, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x66, 0x75, 0x6e,
-		0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x6f, 0x62,
-		0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x6d, 0x69,
-		0x78, 0x69, 0x6e, 0x28, 0x5f, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f,
-		0x2f, 0x20, 0x41, 0x64, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6d, 0x75,
-		0x74, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f,
-		0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72,
-		0x2e, 0x0a, 0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x5b, 0x27, 0x70,
-		0x6f, 0x70, 0x27, 0x2c, 0x20, 0x27, 0x70, 0x75, 0x73, 0x68, 0x27, 0x2c,
-		0x20, 0x27, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x27, 0x2c, 0x20,
-		0x27, 0x73, 0x68, 0x69, 0x66, 0x74, 0x27, 0x2c, 0x20, 0x27, 0x73, 0x6f,
-		0x72, 0x74, 0x27, 0x2c, 0x20, 0x27, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65,
-		0x27, 0x2c, 0x20, 0x27, 0x75, 0x6e, 0x73, 0x68, 0x69, 0x66, 0x74, 0x27,
-		0x5d, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-		0x6e, 0x61, 0x6d, 0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x72, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x3d,
-		0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x5b,
-		0x6e, 0x61, 0x6d, 0x65, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x5f,
-		0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x5b, 0x6e,
-		0x61, 0x6d, 0x65, 0x5d, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x20, 0x3d, 0x20,
-		0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
-		0x64, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x74,
-		0x68, 0x6f, 0x64, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x28, 0x6f, 0x62,
-		0x6a, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-		0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-		0x28, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x73,
-		0x68, 0x69, 0x66, 0x74, 0x27, 0x20, 0x7c, 0x7c, 0x20, 0x6e, 0x61, 0x6d,
-		0x65, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x73, 0x70, 0x6c, 0x69, 0x63, 0x65,
-		0x27, 0x29, 0x20, 0x26, 0x26, 0x20, 0x6f, 0x62, 0x6a, 0x2e, 0x6c, 0x65,
-		0x6e, 0x67, 0x74, 0x68, 0x20, 0x3d, 0x3d, 0x3d, 0x20, 0x30, 0x29, 0x20,
-		0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x5b, 0x30,
-		0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x63,
-		0x61, 0x6c, 0x6c, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20, 0x6f, 0x62,
-		0x6a, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x20,
-		0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41,
-		0x64, 0x64, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73,
-		0x73, 0x6f, 0x72, 0x20, 0x41, 0x72, 0x72, 0x61, 0x79, 0x20, 0x66, 0x75,
-		0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74,
-		0x68, 0x65, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x2e, 0x0a,
-		0x20, 0x20, 0x65, 0x61, 0x63, 0x68, 0x28, 0x5b, 0x27, 0x63, 0x6f, 0x6e,
-		0x63, 0x61, 0x74, 0x27, 0x2c, 0x20, 0x27, 0x6a, 0x6f, 0x69, 0x6e, 0x27,
-		0x2c, 0x20, 0x27, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x27, 0x5d, 0x2c, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x61, 0x6d,
-		0x65, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72,
-		0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x3d, 0x20, 0x41, 0x72,
-		0x72, 0x61, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x5b, 0x6e, 0x61, 0x6d,
-		0x65, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x5f, 0x2e, 0x70, 0x72,
-		0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x5b, 0x6e, 0x61, 0x6d, 0x65,
-		0x5d, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-		0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72,
-		0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
-		0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x74, 0x68, 0x69, 0x73, 0x2c, 0x20,
-		0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x2e, 0x61, 0x70, 0x70, 0x6c, 0x79,
-		0x28, 0x74, 0x68, 0x69, 0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70,
-		0x65, 0x64, 0x2c, 0x20, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74,
-		0x73, 0x29, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a,
-		0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x5f, 0x2e, 0x65,
-		0x78, 0x74, 0x65, 0x6e, 0x64, 0x28, 0x5f, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-		0x6f, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20, 0x7b, 0x0a, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x2f, 0x2f, 0x20, 0x53, 0x74, 0x61, 0x72, 0x74, 0x20, 0x63,
-		0x68, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x72,
-		0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x73,
-		0x63, 0x6f, 0x72, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x3a, 0x20,
-		0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b,
-		0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x68, 0x69, 0x73, 0x2e,
-		0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75,
-		0x65, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-		0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x3b, 0x0a, 0x20, 0x20,
-		0x20, 0x20, 0x7d, 0x2c, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f,
-		0x20, 0x45, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68,
-		0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x66, 0x72, 0x6f,
-		0x6d, 0x20, 0x61, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20,
-		0x61, 0x6e, 0x64, 0x20, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x20,
-		0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-		0x69, 0x6f, 0x6e, 0x28, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74, 0x68, 0x69,
-		0x73, 0x2e, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x3b, 0x0a,
-		0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x0a, 0x20, 0x20, 0x7d, 0x29, 0x3b,
-		0x0a, 0x0a, 0x7d, 0x29, 0x2e, 0x63, 0x61, 0x6c, 0x6c, 0x28, 0x74, 0x68,
-		0x69, 0x73, 0x29, 0x3b, 0x0a,
-	}
-}
-
-//     Underscore.js 1.4.4
-//     http://underscorejs.org
-//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
-//     Underscore may be freely distributed under the MIT license.
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/testify b/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/testify
deleted file mode 100644
index 7f6e0f7c1..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/testify
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-
-my $underscore_test = shift @ARGV || "";
-if (!-d $underscore_test) {
-    print <<_END_;
-Usage:
-
-    testify ./underscore/test
-
-    # Should look something like:
-    arrays.js
-    chaining.js
-    collections.js
-    functions.js
-    index.html
-    objects.js
-    speed.js
-    utility.js
-    vendor
-
-_END_
-    if ($underscore_test) {
-        die "!: Not a directory: $underscore_test\n"
-    }
-    exit;
-}
-
-chdir $underscore_test or die "!: $!";
-
-my @js = <*.js>;
-
-for my $file (@js) {
-    open my $fh, '<', $file or die "!: $!";
-    my $tests = join "", <$fh>;
-    my @tests = $tests =~ m/
-        ^(\s{2}test\(.*?
-        ^\s{2}}\);)$
-    /mgxs;
-    close $fh;
-    next unless @tests;
-    print "$file: ", scalar(@tests), "\n";
-    my $underscore_name = "underscore_$file";
-    $underscore_name =~ s/.js$//;
-    my $go_file = "${underscore_name}_test.go";
-    $go_file =~ s/.js$/.go/;
-    open $fh, '>', $go_file or die "!: $!";
-
-    $fh->print(<<_END_);
-package otto
-
-import (
-	"testing"
-)
-
-_END_
-
-    my $count = 0;
-    for my $test (@tests) {
-        $test =~ s/`([^`]+)`/<$1>/g;
-        my ($name) = $test =~ m/^\s*test\(['"]([^'"]+)['"]/;
-        $fh->print(<<_END_);
-// $name
-func Test_${underscore_name}_$count(t *testing.T) {
-    tt(t, func(){
-	    test := underscoreTest()
-
-	    test(`
-$test
-        `)
-    })
-}
-
-_END_
-        $count++;
-    }
-}
-
-#  test('#779 - delimeters are applied to unescaped text.', 1, function() {
-#    var template = _.template('<<\nx\n>>', null, {evaluate: /<<(.*?)>>/g});
-#    strictEqual(template(), '<<\nx\n>>');
-#  });
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/underscore.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/underscore.go
deleted file mode 100644
index 714b8f3cf..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/underscore/underscore.go
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-Package underscore contains the source for the JavaScript utility-belt library.
-
-	import (
-		_ "github.com/robertkrimen/otto/underscore"
-	)
-	// Every Otto runtime will now include underscore
-
-http://underscorejs.org
-
-https://github.com/documentcloud/underscore
-
-By importing this package, you'll automatically load underscore every time you create a new Otto runtime.
-
-To prevent this behavior, you can do the following:
-
-	import (
-		"github.com/robertkrimen/otto/underscore"
-	)
-
-	func init() {
-		underscore.Disable()
-	}
-
-*/
-package underscore
-
-import (
-	"github.com/robertkrimen/otto/registry"
-)
-
-var entry *registry.Entry = registry.Register(func() string {
-	return Source()
-})
-
-// Enable underscore runtime inclusion.
-func Enable() {
-	entry.Enable()
-}
-
-// Disable underscore runtime inclusion.
-func Disable() {
-	entry.Disable()
-}
-
-// Source returns the underscore source.
-func Source() string {
-	return string(underscore())
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/value.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/value.go
deleted file mode 100644
index a1c341f4d..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/value.go
+++ /dev/null
@@ -1,1025 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"strconv"
-	"unicode/utf16"
-)
-
-type _valueKind int
-
-const (
-	valueUndefined _valueKind = iota
-	valueNull
-	valueNumber
-	valueString
-	valueBoolean
-	valueObject
-
-	// These are invalid outside of the runtime
-	valueEmpty
-	valueResult
-	valueReference
-)
-
-// Value is the representation of a JavaScript value.
-type Value struct {
-	kind  _valueKind
-	value interface{}
-}
-
-func (vl Value) safe() bool {
-	return vl.kind < valueEmpty
-}
-
-var (
-	emptyValue = Value{kind: valueEmpty}
-	nullValue  = Value{kind: valueNull}
-	falseValue = Value{kind: valueBoolean, value: false}
-	trueValue  = Value{kind: valueBoolean, value: true}
-)
-
-// ToValue will convert an interface{} value to a value digestible by otto/JavaScript
-//
-// This function will not work for advanced types (struct, map, slice/array, etc.) and
-// you should use Otto.ToValue instead.
-func ToValue(value interface{}) (Value, error) {
-	result := Value{}
-	err := catchPanic(func() {
-		result = toValue(value)
-	})
-	return result, err
-}
-
-func (value Value) isEmpty() bool {
-	return value.kind == valueEmpty
-}
-
-// Undefined
-
-// UndefinedValue will return a Value representing undefined.
-func UndefinedValue() Value {
-	return Value{}
-}
-
-// IsDefined will return false if the value is undefined, and true otherwise.
-func (value Value) IsDefined() bool {
-	return value.kind != valueUndefined
-}
-
-// IsUndefined will return true if the value is undefined, and false otherwise.
-func (value Value) IsUndefined() bool {
-	return value.kind == valueUndefined
-}
-
-// NullValue will return a Value representing null.
-func NullValue() Value {
-	return Value{kind: valueNull}
-}
-
-// IsNull will return true if the value is null, and false otherwise.
-func (value Value) IsNull() bool {
-	return value.kind == valueNull
-}
-
-// ---
-
-func (value Value) isCallable() bool {
-	switch value := value.value.(type) {
-	case *_object:
-		return value.isCall()
-	}
-	return false
-}
-
-// Call the value as a function with the given this value and argument list and
-// return the result of invocation. It is essentially equivalent to:
-//
-//		value.apply(thisValue, argumentList)
-//
-// An undefined value and an error will result if:
-//
-//		1. There is an error during conversion of the argument list
-//		2. The value is not actually a function
-//		3. An (uncaught) exception is thrown
-//
-func (value Value) Call(this Value, argumentList ...interface{}) (Value, error) {
-	result := Value{}
-	err := catchPanic(func() {
-		// FIXME
-		result = value.call(nil, this, argumentList...)
-	})
-	if !value.safe() {
-		value = Value{}
-	}
-	return result, err
-}
-
-func (value Value) call(rt *_runtime, this Value, argumentList ...interface{}) Value {
-	switch function := value.value.(type) {
-	case *_object:
-		return function.call(this, function.runtime.toValueArray(argumentList...), false, nativeFrame)
-	}
-	if rt == nil {
-		panic("FIXME TypeError")
-	}
-	panic(rt.panicTypeError())
-}
-
-func (value Value) constructSafe(rt *_runtime, this Value, argumentList ...interface{}) (Value, error) {
-	result := Value{}
-	err := catchPanic(func() {
-		result = value.construct(rt, this, argumentList...)
-	})
-	return result, err
-}
-
-func (value Value) construct(rt *_runtime, this Value, argumentList ...interface{}) Value {
-	switch fn := value.value.(type) {
-	case *_object:
-		return fn.construct(fn.runtime.toValueArray(argumentList...))
-	}
-	if rt == nil {
-		panic("FIXME TypeError")
-	}
-	panic(rt.panicTypeError())
-}
-
-// IsPrimitive will return true if value is a primitive (any kind of primitive).
-func (value Value) IsPrimitive() bool {
-	return !value.IsObject()
-}
-
-// IsBoolean will return true if value is a boolean (primitive).
-func (value Value) IsBoolean() bool {
-	return value.kind == valueBoolean
-}
-
-// IsNumber will return true if value is a number (primitive).
-func (value Value) IsNumber() bool {
-	return value.kind == valueNumber
-}
-
-// IsNaN will return true if value is NaN (or would convert to NaN).
-func (value Value) IsNaN() bool {
-	switch value := value.value.(type) {
-	case float64:
-		return math.IsNaN(value)
-	case float32:
-		return math.IsNaN(float64(value))
-	case int, int8, int32, int64:
-		return false
-	case uint, uint8, uint32, uint64:
-		return false
-	}
-
-	return math.IsNaN(value.float64())
-}
-
-// IsString will return true if value is a string (primitive).
-func (value Value) IsString() bool {
-	return value.kind == valueString
-}
-
-// IsObject will return true if value is an object.
-func (value Value) IsObject() bool {
-	return value.kind == valueObject
-}
-
-// IsFunction will return true if value is a function.
-func (value Value) IsFunction() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "Function"
-}
-
-// Class will return the class string of the value or the empty string if value is not an object.
-//
-// The return value will (generally) be one of:
-//
-//		Object
-//		Function
-//		Array
-//		String
-//		Number
-//		Boolean
-//		Date
-//		RegExp
-//
-func (value Value) Class() string {
-	if value.kind != valueObject {
-		return ""
-	}
-	return value.value.(*_object).class
-}
-
-func (value Value) isArray() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return isArray(value.value.(*_object))
-}
-
-func (value Value) isStringObject() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "String"
-}
-
-func (value Value) isBooleanObject() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "Boolean"
-}
-
-func (value Value) isNumberObject() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "Number"
-}
-
-func (value Value) isDate() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "Date"
-}
-
-func (value Value) isRegExp() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "RegExp"
-}
-
-func (value Value) isError() bool {
-	if value.kind != valueObject {
-		return false
-	}
-	return value.value.(*_object).class == "Error"
-}
-
-// ---
-
-func toValue_reflectValuePanic(value interface{}, kind reflect.Kind) {
-	// FIXME?
-	switch kind {
-	case reflect.Struct:
-		panic(newError(nil, "TypeError", "invalid value (struct): missing runtime: %v (%T)", value, value))
-	case reflect.Map:
-		panic(newError(nil, "TypeError", "invalid value (map): missing runtime: %v (%T)", value, value))
-	case reflect.Slice:
-		panic(newError(nil, "TypeError", "invalid value (slice): missing runtime: %v (%T)", value, value))
-	}
-}
-
-func toValue(value interface{}) Value {
-	switch value := value.(type) {
-	case Value:
-		return value
-	case bool:
-		return Value{valueBoolean, value}
-	case int:
-		return Value{valueNumber, value}
-	case int8:
-		return Value{valueNumber, value}
-	case int16:
-		return Value{valueNumber, value}
-	case int32:
-		return Value{valueNumber, value}
-	case int64:
-		return Value{valueNumber, value}
-	case uint:
-		return Value{valueNumber, value}
-	case uint8:
-		return Value{valueNumber, value}
-	case uint16:
-		return Value{valueNumber, value}
-	case uint32:
-		return Value{valueNumber, value}
-	case uint64:
-		return Value{valueNumber, value}
-	case float32:
-		return Value{valueNumber, float64(value)}
-	case float64:
-		return Value{valueNumber, value}
-	case []uint16:
-		return Value{valueString, value}
-	case string:
-		return Value{valueString, value}
-	// A rune is actually an int32, which is handled above
-	case *_object:
-		return Value{valueObject, value}
-	case *Object:
-		return Value{valueObject, value.object}
-	case Object:
-		return Value{valueObject, value.object}
-	case _reference: // reference is an interface (already a pointer)
-		return Value{valueReference, value}
-	case _result:
-		return Value{valueResult, value}
-	case nil:
-		// TODO Ugh.
-		return Value{}
-	case reflect.Value:
-		for value.Kind() == reflect.Ptr {
-			// We were given a pointer, so we'll drill down until we get a non-pointer
-			//
-			// These semantics might change if we want to start supporting pointers to values transparently
-			// (It would be best not to depend on this behavior)
-			// FIXME: UNDEFINED
-			if value.IsNil() {
-				return Value{}
-			}
-			value = value.Elem()
-		}
-		switch value.Kind() {
-		case reflect.Bool:
-			return Value{valueBoolean, bool(value.Bool())}
-		case reflect.Int:
-			return Value{valueNumber, int(value.Int())}
-		case reflect.Int8:
-			return Value{valueNumber, int8(value.Int())}
-		case reflect.Int16:
-			return Value{valueNumber, int16(value.Int())}
-		case reflect.Int32:
-			return Value{valueNumber, int32(value.Int())}
-		case reflect.Int64:
-			return Value{valueNumber, int64(value.Int())}
-		case reflect.Uint:
-			return Value{valueNumber, uint(value.Uint())}
-		case reflect.Uint8:
-			return Value{valueNumber, uint8(value.Uint())}
-		case reflect.Uint16:
-			return Value{valueNumber, uint16(value.Uint())}
-		case reflect.Uint32:
-			return Value{valueNumber, uint32(value.Uint())}
-		case reflect.Uint64:
-			return Value{valueNumber, uint64(value.Uint())}
-		case reflect.Float32:
-			return Value{valueNumber, float32(value.Float())}
-		case reflect.Float64:
-			return Value{valueNumber, float64(value.Float())}
-		case reflect.String:
-			return Value{valueString, string(value.String())}
-		default:
-			toValue_reflectValuePanic(value.Interface(), value.Kind())
-		}
-	default:
-		return toValue(reflect.ValueOf(value))
-	}
-	// FIXME?
-	panic(newError(nil, "TypeError", "invalid value: %v (%T)", value, value))
-}
-
-// String will return the value as a string.
-//
-// This method will make return the empty string if there is an error.
-func (value Value) String() string {
-	result := ""
-	catchPanic(func() {
-		result = value.string()
-	})
-	return result
-}
-
-// ToBoolean will convert the value to a boolean (bool).
-//
-//		ToValue(0).ToBoolean() => false
-//		ToValue("").ToBoolean() => false
-//		ToValue(true).ToBoolean() => true
-//		ToValue(1).ToBoolean() => true
-//		ToValue("Nothing happens").ToBoolean() => true
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be false and an error.
-func (value Value) ToBoolean() (bool, error) {
-	result := false
-	err := catchPanic(func() {
-		result = value.bool()
-	})
-	return result, err
-}
-
-func (value Value) numberValue() Value {
-	if value.kind == valueNumber {
-		return value
-	}
-	return Value{valueNumber, value.float64()}
-}
-
-// ToFloat will convert the value to a number (float64).
-//
-//		ToValue(0).ToFloat() => 0.
-//		ToValue(1.1).ToFloat() => 1.1
-//		ToValue("11").ToFloat() => 11.
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be 0 and an error.
-func (value Value) ToFloat() (float64, error) {
-	result := float64(0)
-	err := catchPanic(func() {
-		result = value.float64()
-	})
-	return result, err
-}
-
-// ToInteger will convert the value to a number (int64).
-//
-//		ToValue(0).ToInteger() => 0
-//		ToValue(1.1).ToInteger() => 1
-//		ToValue("11").ToInteger() => 11
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be 0 and an error.
-func (value Value) ToInteger() (int64, error) {
-	result := int64(0)
-	err := catchPanic(func() {
-		result = value.number().int64
-	})
-	return result, err
-}
-
-// ToString will convert the value to a string (string).
-//
-//		ToValue(0).ToString() => "0"
-//		ToValue(false).ToString() => "false"
-//		ToValue(1.1).ToString() => "1.1"
-//		ToValue("11").ToString() => "11"
-//		ToValue('Nothing happens.').ToString() => "Nothing happens."
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be the empty string ("") and an error.
-func (value Value) ToString() (string, error) {
-	result := ""
-	err := catchPanic(func() {
-		result = value.string()
-	})
-	return result, err
-}
-
-func (value Value) _object() *_object {
-	switch value := value.value.(type) {
-	case *_object:
-		return value
-	}
-	return nil
-}
-
-// Object will return the object of the value, or nil if value is not an object.
-//
-// This method will not do any implicit conversion. For example, calling this method on a string primitive value will not return a String object.
-func (value Value) Object() *Object {
-	switch object := value.value.(type) {
-	case *_object:
-		return _newObject(object, value)
-	}
-	return nil
-}
-
-func (value Value) reference() _reference {
-	switch value := value.value.(type) {
-	case _reference:
-		return value
-	}
-	return nil
-}
-
-func (value Value) resolve() Value {
-	switch value := value.value.(type) {
-	case _reference:
-		return value.getValue()
-	}
-	return value
-}
-
-var (
-	__NaN__              float64 = math.NaN()
-	__PositiveInfinity__ float64 = math.Inf(+1)
-	__NegativeInfinity__ float64 = math.Inf(-1)
-	__PositiveZero__     float64 = 0
-	__NegativeZero__     float64 = math.Float64frombits(0 | (1 << 63))
-)
-
-func positiveInfinity() float64 {
-	return __PositiveInfinity__
-}
-
-func negativeInfinity() float64 {
-	return __NegativeInfinity__
-}
-
-func positiveZero() float64 {
-	return __PositiveZero__
-}
-
-func negativeZero() float64 {
-	return __NegativeZero__
-}
-
-// NaNValue will return a value representing NaN.
-//
-// It is equivalent to:
-//
-//		ToValue(math.NaN())
-//
-func NaNValue() Value {
-	return Value{valueNumber, __NaN__}
-}
-
-func positiveInfinityValue() Value {
-	return Value{valueNumber, __PositiveInfinity__}
-}
-
-func negativeInfinityValue() Value {
-	return Value{valueNumber, __NegativeInfinity__}
-}
-
-func positiveZeroValue() Value {
-	return Value{valueNumber, __PositiveZero__}
-}
-
-func negativeZeroValue() Value {
-	return Value{valueNumber, __NegativeZero__}
-}
-
-// TrueValue will return a value representing true.
-//
-// It is equivalent to:
-//
-//		ToValue(true)
-//
-func TrueValue() Value {
-	return Value{valueBoolean, true}
-}
-
-// FalseValue will return a value representing false.
-//
-// It is equivalent to:
-//
-//		ToValue(false)
-//
-func FalseValue() Value {
-	return Value{valueBoolean, false}
-}
-
-func sameValue(x Value, y Value) bool {
-	if x.kind != y.kind {
-		return false
-	}
-	result := false
-	switch x.kind {
-	case valueUndefined, valueNull:
-		result = true
-	case valueNumber:
-		x := x.float64()
-		y := y.float64()
-		if math.IsNaN(x) && math.IsNaN(y) {
-			result = true
-		} else {
-			result = x == y
-			if result && x == 0 {
-				// Since +0 != -0
-				result = math.Signbit(x) == math.Signbit(y)
-			}
-		}
-	case valueString:
-		result = x.string() == y.string()
-	case valueBoolean:
-		result = x.bool() == y.bool()
-	case valueObject:
-		result = x._object() == y._object()
-	default:
-		panic(hereBeDragons())
-	}
-
-	return result
-}
-
-func strictEqualityComparison(x Value, y Value) bool {
-	if x.kind != y.kind {
-		return false
-	}
-	result := false
-	switch x.kind {
-	case valueUndefined, valueNull:
-		result = true
-	case valueNumber:
-		x := x.float64()
-		y := y.float64()
-		if math.IsNaN(x) && math.IsNaN(y) {
-			result = false
-		} else {
-			result = x == y
-		}
-	case valueString:
-		result = x.string() == y.string()
-	case valueBoolean:
-		result = x.bool() == y.bool()
-	case valueObject:
-		result = x._object() == y._object()
-	default:
-		panic(hereBeDragons())
-	}
-
-	return result
-}
-
-// Export will attempt to convert the value to a Go representation
-// and return it via an interface{} kind.
-//
-// Export returns an error, but it will always be nil. It is present
-// for backwards compatibility.
-//
-// If a reasonable conversion is not possible, then the original
-// value is returned.
-//
-//      undefined   -> nil (FIXME?: Should be Value{})
-//      null        -> nil
-//      boolean     -> bool
-//      number      -> A number type (int, float32, uint64, ...)
-//      string      -> string
-//      Array       -> []interface{}
-//      Object      -> map[string]interface{}
-//
-func (self Value) Export() (interface{}, error) {
-	return self.export(), nil
-}
-
-func (self Value) export() interface{} {
-
-	switch self.kind {
-	case valueUndefined:
-		return nil
-	case valueNull:
-		return nil
-	case valueNumber, valueBoolean:
-		return self.value
-	case valueString:
-		switch value := self.value.(type) {
-		case string:
-			return value
-		case []uint16:
-			return string(utf16.Decode(value))
-		}
-	case valueObject:
-		object := self._object()
-		switch value := object.value.(type) {
-		case *_goStructObject:
-			return value.value.Interface()
-		case *_goMapObject:
-			return value.value.Interface()
-		case *_goArrayObject:
-			return value.value.Interface()
-		case *_goSliceObject:
-			return value.value.Interface()
-		}
-		if object.class == "Array" {
-			result := make([]interface{}, 0)
-			lengthValue := object.get("length")
-			length := lengthValue.value.(uint32)
-			kind := reflect.Invalid
-			state := 0
-			var t reflect.Type
-			for index := uint32(0); index < length; index += 1 {
-				name := strconv.FormatInt(int64(index), 10)
-				if !object.hasProperty(name) {
-					continue
-				}
-				value := object.get(name).export()
-				t = reflect.TypeOf(value)
-				if state == 0 {
-					kind = t.Kind()
-					state = 1
-				} else if state == 1 && kind != t.Kind() {
-					state = 2
-				}
-				result = append(result, value)
-			}
-
-			if state != 1 || kind == reflect.Interface {
-				// No common type
-				return result
-			}
-
-			// Convert to the common type
-			val := reflect.MakeSlice(reflect.SliceOf(t), len(result), len(result))
-			for i, v := range result {
-				val.Index(i).Set(reflect.ValueOf(v))
-			}
-			return val.Interface()
-		} else {
-			result := make(map[string]interface{})
-			// TODO Should we export everything? Or just what is enumerable?
-			object.enumerate(false, func(name string) bool {
-				value := object.get(name)
-				if value.IsDefined() {
-					result[name] = value.export()
-				}
-				return true
-			})
-			return result
-		}
-	}
-
-	if self.safe() {
-		return self
-	}
-
-	return Value{}
-}
-
-func (self Value) evaluateBreakContinue(labels []string) _resultKind {
-	result := self.value.(_result)
-	if result.kind == resultBreak || result.kind == resultContinue {
-		for _, label := range labels {
-			if label == result.target {
-				return result.kind
-			}
-		}
-	}
-	return resultReturn
-}
-
-func (self Value) evaluateBreak(labels []string) _resultKind {
-	result := self.value.(_result)
-	if result.kind == resultBreak {
-		for _, label := range labels {
-			if label == result.target {
-				return result.kind
-			}
-		}
-	}
-	return resultReturn
-}
-
-func (self Value) exportNative() interface{} {
-
-	switch self.kind {
-	case valueUndefined:
-		return self
-	case valueNull:
-		return nil
-	case valueNumber, valueBoolean:
-		return self.value
-	case valueString:
-		switch value := self.value.(type) {
-		case string:
-			return value
-		case []uint16:
-			return string(utf16.Decode(value))
-		}
-	case valueObject:
-		object := self._object()
-		switch value := object.value.(type) {
-		case *_goStructObject:
-			return value.value.Interface()
-		case *_goMapObject:
-			return value.value.Interface()
-		case *_goArrayObject:
-			return value.value.Interface()
-		case *_goSliceObject:
-			return value.value.Interface()
-		}
-	}
-
-	return self
-}
-
-// Make a best effort to return a reflect.Value corresponding to reflect.Kind, but
-// fallback to just returning the Go value we have handy.
-func (value Value) toReflectValue(kind reflect.Kind) (reflect.Value, error) {
-	if kind != reflect.Float32 && kind != reflect.Float64 && kind != reflect.Interface {
-		switch value := value.value.(type) {
-		case float32:
-			_, frac := math.Modf(float64(value))
-			if frac > 0 {
-				return reflect.Value{}, fmt.Errorf("RangeError: %v to reflect.Kind: %v", value, kind)
-			}
-		case float64:
-			_, frac := math.Modf(value)
-			if frac > 0 {
-				return reflect.Value{}, fmt.Errorf("RangeError: %v to reflect.Kind: %v", value, kind)
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Bool: // Bool
-		return reflect.ValueOf(value.bool()), nil
-	case reflect.Int: // Int
-		// We convert to float64 here because converting to int64 will not tell us
-		// if a value is outside the range of int64
-		tmp := toIntegerFloat(value)
-		if tmp < float_minInt || tmp > float_maxInt {
-			return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to int", tmp, value)
-		} else {
-			return reflect.ValueOf(int(tmp)), nil
-		}
-	case reflect.Int8: // Int8
-		tmp := value.number().int64
-		if tmp < int64_minInt8 || tmp > int64_maxInt8 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int8", tmp, value)
-		} else {
-			return reflect.ValueOf(int8(tmp)), nil
-		}
-	case reflect.Int16: // Int16
-		tmp := value.number().int64
-		if tmp < int64_minInt16 || tmp > int64_maxInt16 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int16", tmp, value)
-		} else {
-			return reflect.ValueOf(int16(tmp)), nil
-		}
-	case reflect.Int32: // Int32
-		tmp := value.number().int64
-		if tmp < int64_minInt32 || tmp > int64_maxInt32 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int32", tmp, value)
-		} else {
-			return reflect.ValueOf(int32(tmp)), nil
-		}
-	case reflect.Int64: // Int64
-		// We convert to float64 here because converting to int64 will not tell us
-		// if a value is outside the range of int64
-		tmp := toIntegerFloat(value)
-		if tmp < float_minInt64 || tmp > float_maxInt64 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to int", tmp, value)
-		} else {
-			return reflect.ValueOf(int64(tmp)), nil
-		}
-	case reflect.Uint: // Uint
-		// We convert to float64 here because converting to int64 will not tell us
-		// if a value is outside the range of uint
-		tmp := toIntegerFloat(value)
-		if tmp < 0 || tmp > float_maxUint {
-			return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to uint", tmp, value)
-		} else {
-			return reflect.ValueOf(uint(tmp)), nil
-		}
-	case reflect.Uint8: // Uint8
-		tmp := value.number().int64
-		if tmp < 0 || tmp > int64_maxUint8 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint8", tmp, value)
-		} else {
-			return reflect.ValueOf(uint8(tmp)), nil
-		}
-	case reflect.Uint16: // Uint16
-		tmp := value.number().int64
-		if tmp < 0 || tmp > int64_maxUint16 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint16", tmp, value)
-		} else {
-			return reflect.ValueOf(uint16(tmp)), nil
-		}
-	case reflect.Uint32: // Uint32
-		tmp := value.number().int64
-		if tmp < 0 || tmp > int64_maxUint32 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint32", tmp, value)
-		} else {
-			return reflect.ValueOf(uint32(tmp)), nil
-		}
-	case reflect.Uint64: // Uint64
-		// We convert to float64 here because converting to int64 will not tell us
-		// if a value is outside the range of uint64
-		tmp := toIntegerFloat(value)
-		if tmp < 0 || tmp > float_maxUint64 {
-			return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to uint64", tmp, value)
-		} else {
-			return reflect.ValueOf(uint64(tmp)), nil
-		}
-	case reflect.Float32: // Float32
-		tmp := value.float64()
-		tmp1 := tmp
-		if 0 > tmp1 {
-			tmp1 = -tmp1
-		}
-		if tmp1 > 0 && (tmp1 < math.SmallestNonzeroFloat32 || tmp1 > math.MaxFloat32) {
-			return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to float32", tmp, value)
-		} else {
-			return reflect.ValueOf(float32(tmp)), nil
-		}
-	case reflect.Float64: // Float64
-		value := value.float64()
-		return reflect.ValueOf(float64(value)), nil
-	case reflect.String: // String
-		return reflect.ValueOf(value.string()), nil
-	case reflect.Invalid: // Invalid
-	case reflect.Complex64: // FIXME? Complex64
-	case reflect.Complex128: // FIXME? Complex128
-	case reflect.Chan: // FIXME? Chan
-	case reflect.Func: // FIXME? Func
-	case reflect.Ptr: // FIXME? Ptr
-	case reflect.UnsafePointer: // FIXME? UnsafePointer
-	default:
-		switch value.kind {
-		case valueObject:
-			object := value._object()
-			switch vl := object.value.(type) {
-			case *_goStructObject: // Struct
-				return reflect.ValueOf(vl.value.Interface()), nil
-			case *_goMapObject: // Map
-				return reflect.ValueOf(vl.value.Interface()), nil
-			case *_goArrayObject: // Array
-				return reflect.ValueOf(vl.value.Interface()), nil
-			case *_goSliceObject: // Slice
-				return reflect.ValueOf(vl.value.Interface()), nil
-			}
-			return reflect.ValueOf(value.exportNative()), nil
-		case valueEmpty, valueResult, valueReference:
-			// These are invalid, and should panic
-		default:
-			return reflect.ValueOf(value.value), nil
-		}
-	}
-
-	// FIXME Should this end up as a TypeError?
-	panic(fmt.Errorf("invalid conversion of %v (%v) to reflect.Kind: %v", value.kind, value, kind))
-}
-
-func stringToReflectValue(value string, kind reflect.Kind) (reflect.Value, error) {
-	switch kind {
-	case reflect.Bool:
-		value, err := strconv.ParseBool(value)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(value), nil
-	case reflect.Int:
-		value, err := strconv.ParseInt(value, 0, 0)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(int(value)), nil
-	case reflect.Int8:
-		value, err := strconv.ParseInt(value, 0, 8)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(int8(value)), nil
-	case reflect.Int16:
-		value, err := strconv.ParseInt(value, 0, 16)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(int16(value)), nil
-	case reflect.Int32:
-		value, err := strconv.ParseInt(value, 0, 32)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(int32(value)), nil
-	case reflect.Int64:
-		value, err := strconv.ParseInt(value, 0, 64)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(int64(value)), nil
-	case reflect.Uint:
-		value, err := strconv.ParseUint(value, 0, 0)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(uint(value)), nil
-	case reflect.Uint8:
-		value, err := strconv.ParseUint(value, 0, 8)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(uint8(value)), nil
-	case reflect.Uint16:
-		value, err := strconv.ParseUint(value, 0, 16)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(uint16(value)), nil
-	case reflect.Uint32:
-		value, err := strconv.ParseUint(value, 0, 32)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(uint32(value)), nil
-	case reflect.Uint64:
-		value, err := strconv.ParseUint(value, 0, 64)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(uint64(value)), nil
-	case reflect.Float32:
-		value, err := strconv.ParseFloat(value, 32)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(float32(value)), nil
-	case reflect.Float64:
-		value, err := strconv.ParseFloat(value, 64)
-		if err != nil {
-			return reflect.Value{}, err
-		}
-		return reflect.ValueOf(float64(value)), nil
-	case reflect.String:
-		return reflect.ValueOf(value), nil
-	}
-
-	// FIXME This should end up as a TypeError?
-	panic(fmt.Errorf("invalid conversion of %q to reflect.Kind: %v", value, kind))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_boolean.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/value_boolean.go
deleted file mode 100644
index 3040f4163..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_boolean.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-)
-
-func (value Value) bool() bool {
-	if value.kind == valueBoolean {
-		return value.value.(bool)
-	}
-	if value.IsUndefined() {
-		return false
-	}
-	if value.IsNull() {
-		return false
-	}
-	switch value := value.value.(type) {
-	case bool:
-		return value
-	case int, int8, int16, int32, int64:
-		return 0 != reflect.ValueOf(value).Int()
-	case uint, uint8, uint16, uint32, uint64:
-		return 0 != reflect.ValueOf(value).Uint()
-	case float32:
-		return 0 != value
-	case float64:
-		if math.IsNaN(value) || value == 0 {
-			return false
-		}
-		return true
-	case string:
-		return 0 != len(value)
-	}
-	if value.IsObject() {
-		return true
-	}
-	panic(fmt.Errorf("toBoolean(%T)", value.value))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_number.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/value_number.go
deleted file mode 100644
index 54996c729..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_number.go
+++ /dev/null
@@ -1,324 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var stringToNumberParseInteger = regexp.MustCompile(`^(?:0[xX])`)
-
-func parseNumber(value string) float64 {
-	value = strings.TrimSpace(value)
-
-	if value == "" {
-		return 0
-	}
-
-	parseFloat := false
-	if strings.IndexRune(value, '.') != -1 {
-		parseFloat = true
-	} else if stringToNumberParseInteger.MatchString(value) {
-		parseFloat = false
-	} else {
-		parseFloat = true
-	}
-
-	if parseFloat {
-		number, err := strconv.ParseFloat(value, 64)
-		if err != nil && err.(*strconv.NumError).Err != strconv.ErrRange {
-			return math.NaN()
-		}
-		return number
-	}
-
-	number, err := strconv.ParseInt(value, 0, 64)
-	if err != nil {
-		return math.NaN()
-	}
-	return float64(number)
-}
-
-func (value Value) float64() float64 {
-	switch value.kind {
-	case valueUndefined:
-		return math.NaN()
-	case valueNull:
-		return 0
-	}
-	switch value := value.value.(type) {
-	case bool:
-		if value {
-			return 1
-		}
-		return 0
-	case int:
-		return float64(value)
-	case int8:
-		return float64(value)
-	case int16:
-		return float64(value)
-	case int32:
-		return float64(value)
-	case int64:
-		return float64(value)
-	case uint:
-		return float64(value)
-	case uint8:
-		return float64(value)
-	case uint16:
-		return float64(value)
-	case uint32:
-		return float64(value)
-	case uint64:
-		return float64(value)
-	case float64:
-		return value
-	case string:
-		return parseNumber(value)
-	case *_object:
-		return value.DefaultValue(defaultValueHintNumber).float64()
-	}
-	panic(fmt.Errorf("toFloat(%T)", value.value))
-}
-
-const (
-	float_2_64   float64 = 18446744073709551616.0
-	float_2_63   float64 = 9223372036854775808.0
-	float_2_32   float64 = 4294967296.0
-	float_2_31   float64 = 2147483648.0
-	float_2_16   float64 = 65536.0
-	integer_2_32 int64   = 4294967296
-	integer_2_31 int64   = 2146483648
-	sqrt1_2      float64 = math.Sqrt2 / 2
-)
-
-const (
-	maxInt8   = math.MaxInt8
-	minInt8   = math.MinInt8
-	maxInt16  = math.MaxInt16
-	minInt16  = math.MinInt16
-	maxInt32  = math.MaxInt32
-	minInt32  = math.MinInt32
-	maxInt64  = math.MaxInt64
-	minInt64  = math.MinInt64
-	maxUint8  = math.MaxUint8
-	maxUint16 = math.MaxUint16
-	maxUint32 = math.MaxUint32
-	maxUint64 = math.MaxUint64
-	maxUint   = ^uint(0)
-	minUint   = 0
-	maxInt    = int(^uint(0) >> 1)
-	minInt    = -maxInt - 1
-
-	// int64
-	int64_maxInt    int64 = int64(maxInt)
-	int64_minInt    int64 = int64(minInt)
-	int64_maxInt8   int64 = math.MaxInt8
-	int64_minInt8   int64 = math.MinInt8
-	int64_maxInt16  int64 = math.MaxInt16
-	int64_minInt16  int64 = math.MinInt16
-	int64_maxInt32  int64 = math.MaxInt32
-	int64_minInt32  int64 = math.MinInt32
-	int64_maxUint8  int64 = math.MaxUint8
-	int64_maxUint16 int64 = math.MaxUint16
-	int64_maxUint32 int64 = math.MaxUint32
-
-	// float64
-	float_maxInt    float64 = float64(int(^uint(0) >> 1))
-	float_minInt    float64 = float64(int(-maxInt - 1))
-	float_minUint   float64 = float64(0)
-	float_maxUint   float64 = float64(uint(^uint(0)))
-	float_minUint64 float64 = float64(0)
-	float_maxUint64 float64 = math.MaxUint64
-	float_maxInt64  float64 = math.MaxInt64
-	float_minInt64  float64 = math.MinInt64
-)
-
-func toIntegerFloat(value Value) float64 {
-	float := value.float64()
-	if math.IsInf(float, 0) {
-	} else if math.IsNaN(float) {
-		float = 0
-	} else if float > 0 {
-		float = math.Floor(float)
-	} else {
-		float = math.Ceil(float)
-	}
-	return float
-}
-
-type _numberKind int
-
-const (
-	numberInteger  _numberKind = iota // 3.0 => 3.0
-	numberFloat                       // 3.14159 => 3.0, 1+2**63 > 2**63-1
-	numberInfinity                    // Infinity => 2**63-1
-	numberNaN                         // NaN => 0
-)
-
-type _number struct {
-	kind    _numberKind
-	int64   int64
-	float64 float64
-}
-
-// FIXME
-// http://www.goinggo.net/2013/08/gustavos-ieee-754-brain-teaser.html
-// http://bazaar.launchpad.net/~niemeyer/strepr/trunk/view/6/strepr.go#L160
-func (vl Value) number() (number _number) {
-	switch vl := vl.value.(type) {
-	case int8:
-		number.int64 = int64(vl)
-		return
-	case int16:
-		number.int64 = int64(vl)
-		return
-	case uint8:
-		number.int64 = int64(vl)
-		return
-	case uint16:
-		number.int64 = int64(vl)
-		return
-	case uint32:
-		number.int64 = int64(vl)
-		return
-	case int:
-		number.int64 = int64(vl)
-		return
-	case int64:
-		number.int64 = vl
-		return
-	}
-
-	float := vl.float64()
-	if float == 0 {
-		return
-	}
-
-	number.kind = numberFloat
-	number.float64 = float
-
-	if math.IsNaN(float) {
-		number.kind = numberNaN
-		return
-	}
-
-	if math.IsInf(float, 0) {
-		number.kind = numberInfinity
-	}
-
-	if float >= float_maxInt64 {
-		number.int64 = math.MaxInt64
-		return
-	}
-
-	if float <= float_minInt64 {
-		number.int64 = math.MinInt64
-		return
-	}
-
-	integer := float64(0)
-	if float > 0 {
-		integer = math.Floor(float)
-	} else {
-		integer = math.Ceil(float)
-	}
-
-	if float == integer {
-		number.kind = numberInteger
-	}
-	number.int64 = int64(float)
-	return
-}
-
-// ECMA 262: 9.5
-func toInt32(value Value) int32 {
-	{
-		switch value := value.value.(type) {
-		case int8:
-			return int32(value)
-		case int16:
-			return int32(value)
-		case int32:
-			return value
-		}
-	}
-	floatValue := value.float64()
-	if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
-		return 0
-	}
-	if floatValue == 0 { // This will work for +0 & -0
-		return 0
-	}
-	remainder := math.Mod(floatValue, float_2_32)
-	if remainder > 0 {
-		remainder = math.Floor(remainder)
-	} else {
-		remainder = math.Ceil(remainder) + float_2_32
-	}
-	if remainder > float_2_31 {
-		return int32(remainder - float_2_32)
-	}
-	return int32(remainder)
-}
-
-func toUint32(value Value) uint32 {
-	{
-		switch value := value.value.(type) {
-		case int8:
-			return uint32(value)
-		case int16:
-			return uint32(value)
-		case uint8:
-			return uint32(value)
-		case uint16:
-			return uint32(value)
-		case uint32:
-			return value
-		}
-	}
-	floatValue := value.float64()
-	if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
-		return 0
-	}
-	if floatValue == 0 {
-		return 0
-	}
-	remainder := math.Mod(floatValue, float_2_32)
-	if remainder > 0 {
-		remainder = math.Floor(remainder)
-	} else {
-		remainder = math.Ceil(remainder) + float_2_32
-	}
-	return uint32(remainder)
-}
-
-func toUint16(value Value) uint16 {
-	{
-		switch value := value.value.(type) {
-		case int8:
-			return uint16(value)
-		case uint8:
-			return uint16(value)
-		case uint16:
-			return value
-		}
-	}
-	floatValue := value.float64()
-	if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
-		return 0
-	}
-	if floatValue == 0 {
-		return 0
-	}
-	remainder := math.Mod(floatValue, float_2_16)
-	if remainder > 0 {
-		remainder = math.Floor(remainder)
-	} else {
-		remainder = math.Ceil(remainder) + float_2_16
-	}
-	return uint16(remainder)
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_primitive.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/value_primitive.go
deleted file mode 100644
index 11ed329d1..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_primitive.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package otto
-
-func toStringPrimitive(value Value) Value {
-	return _toPrimitive(value, defaultValueHintString)
-}
-
-func toNumberPrimitive(value Value) Value {
-	return _toPrimitive(value, defaultValueHintNumber)
-}
-
-func toPrimitive(value Value) Value {
-	return _toPrimitive(value, defaultValueNoHint)
-}
-
-func _toPrimitive(value Value, hint _defaultValueHint) Value {
-	switch value.kind {
-	case valueNull, valueUndefined, valueNumber, valueString, valueBoolean:
-		return value
-	case valueObject:
-		return value._object().DefaultValue(hint)
-	}
-	panic(hereBeDragons(value.kind, value))
-}
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_string.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/value_string.go
deleted file mode 100644
index 0fbfd6b25..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/value_string.go
+++ /dev/null
@@ -1,103 +0,0 @@
-package otto
-
-import (
-	"fmt"
-	"math"
-	"regexp"
-	"strconv"
-	"unicode/utf16"
-)
-
-var matchLeading0Exponent = regexp.MustCompile(`([eE][\+\-])0+([1-9])`) // 1e-07 => 1e-7
-
-// FIXME
-// https://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/conversions.cc?spec=svn18082&r=18082
-func floatToString(value float64, bitsize int) string {
-	// TODO Fit to ECMA-262 9.8.1 specification
-	if math.IsNaN(value) {
-		return "NaN"
-	} else if math.IsInf(value, 0) {
-		if math.Signbit(value) {
-			return "-Infinity"
-		}
-		return "Infinity"
-	}
-	exponent := math.Log10(math.Abs(value))
-	if exponent >= 21 || exponent < -6 {
-		return matchLeading0Exponent.ReplaceAllString(strconv.FormatFloat(value, 'g', -1, bitsize), "$1$2")
-	}
-	return strconv.FormatFloat(value, 'f', -1, bitsize)
-}
-
-func numberToStringRadix(value Value, radix int) string {
-	float := value.float64()
-	if math.IsNaN(float) {
-		return "NaN"
-	} else if math.IsInf(float, 1) {
-		return "Infinity"
-	} else if math.IsInf(float, -1) {
-		return "-Infinity"
-	}
-	// FIXME This is very broken
-	// Need to do proper radix conversion for floats, ...
-	// This truncates large floats (so bad).
-	return strconv.FormatInt(int64(float), radix)
-}
-
-func (value Value) string() string {
-	if value.kind == valueString {
-		switch value := value.value.(type) {
-		case string:
-			return value
-		case []uint16:
-			return string(utf16.Decode(value))
-		}
-	}
-	if value.IsUndefined() {
-		return "undefined"
-	}
-	if value.IsNull() {
-		return "null"
-	}
-	switch value := value.value.(type) {
-	case bool:
-		return strconv.FormatBool(value)
-	case int:
-		return strconv.FormatInt(int64(value), 10)
-	case int8:
-		return strconv.FormatInt(int64(value), 10)
-	case int16:
-		return strconv.FormatInt(int64(value), 10)
-	case int32:
-		return strconv.FormatInt(int64(value), 10)
-	case int64:
-		return strconv.FormatInt(value, 10)
-	case uint:
-		return strconv.FormatUint(uint64(value), 10)
-	case uint8:
-		return strconv.FormatUint(uint64(value), 10)
-	case uint16:
-		return strconv.FormatUint(uint64(value), 10)
-	case uint32:
-		return strconv.FormatUint(uint64(value), 10)
-	case uint64:
-		return strconv.FormatUint(value, 10)
-	case float32:
-		if value == 0 {
-			return "0" // Take care not to return -0
-		}
-		return floatToString(float64(value), 32)
-	case float64:
-		if value == 0 {
-			return "0" // Take care not to return -0
-		}
-		return floatToString(value, 64)
-	case []uint16:
-		return string(utf16.Decode(value))
-	case string:
-		return value
-	case *_object:
-		return value.DefaultValue(defaultValueHintString).string()
-	}
-	panic(fmt.Errorf("%v.string( %T)", value.value, value.value))
-}