diff --git a/cmd/version.go b/cmd/version.go
index eaafbb7f517571cabaec6fb131919dd1ca703367..22da073609941cc1e9f3cf9269b9aad3264a0156 100644
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -18,8 +18,8 @@ package cmd
 import (
 	"fmt"
 
+	jsonnet "github.com/google/go-jsonnet"
 	"github.com/spf13/cobra"
-	jsonnet "github.com/strickyak/jsonnet_cgo"
 	"k8s.io/client-go/pkg/version"
 )
 
diff --git a/prototype/snippet/jsonnet/snippet.go b/prototype/snippet/jsonnet/snippet.go
index a4abda6d02e06e3c8a503daa64fca31401f8d289..8e672d1bc1ba3001a94d749de0a534fb017ae27c 100644
--- a/prototype/snippet/jsonnet/snippet.go
+++ b/prototype/snippet/jsonnet/snippet.go
@@ -72,20 +72,27 @@ func visit(node ast.Node, imports *[]ast.Import) error {
 	switch n := node.(type) {
 	case *ast.Import:
 		// Add parameter-type imports to the list of replacements.
-		if strings.HasPrefix(n.File, paramPrefix) {
-			param := strings.TrimPrefix(n.File, paramPrefix)
+		if strings.HasPrefix(n.File.Value, paramPrefix) {
+			param := strings.TrimPrefix(n.File.Value, paramPrefix)
 			if len(param) < 1 {
 				return errors.New("There must be a parameter following import param://")
 			}
 			*imports = append(*imports, *n)
 		}
 	case *ast.Apply:
-		for _, arg := range n.Arguments {
+		for _, arg := range n.Arguments.Positional {
 			err := visit(arg, imports)
 			if err != nil {
 				return err
 			}
 		}
+
+		for _, arg := range n.Arguments.Named {
+			err := visit(arg.Arg, imports)
+			if err != nil {
+				return err
+			}
+		}
 		return visit(n.Target, imports)
 	case *ast.ApplyBrace:
 		err := visit(n.Left, imports)
@@ -101,11 +108,9 @@ func visit(node ast.Node, imports *[]ast.Import) error {
 			}
 		}
 	case *ast.ArrayComp:
-		for _, spec := range n.Specs {
-			err := visitCompSpec(spec, imports)
-			if err != nil {
-				return err
-			}
+		err := visitCompSpec(n.Spec, imports)
+		if err != nil {
+			return err
 		}
 		return visit(n.Body, imports)
 	case *ast.Assert:
@@ -137,6 +142,13 @@ func visit(node ast.Node, imports *[]ast.Import) error {
 	case *ast.Error:
 		return visit(n.Expr, imports)
 	case *ast.Function:
+		for _, p := range n.Parameters.Optional {
+			err := visit(p.DefaultArg, imports)
+			if err != nil {
+				return err
+			}
+		}
+
 		return visit(n.Body, imports)
 	case *ast.Index:
 		err := visit(n.Target, imports)
@@ -193,22 +205,10 @@ func visit(node ast.Node, imports *[]ast.Import) error {
 				return err
 			}
 		}
-		for _, spec := range n.Specs {
-			err := visitCompSpec(spec, imports)
-			if err != nil {
-				return err
-			}
-		}
-	case *ast.ObjectComprehensionSimple:
-		err := visit(n.Field, imports)
+		err := visitCompSpec(n.Spec, imports)
 		if err != nil {
 			return err
 		}
-		err = visit(n.Value, imports)
-		if err != nil {
-			return err
-		}
-		return visit(n.Array, imports)
 	case *ast.SuperIndex:
 		return visit(n.Index, imports)
 	case *ast.InSuper:
@@ -235,11 +235,40 @@ func visit(node ast.Node, imports *[]ast.Import) error {
 	return nil
 }
 
-func visitCompSpec(node ast.CompSpec, imports *[]ast.Import) error {
+func visitCompSpec(node ast.ForSpec, imports *[]ast.Import) error {
+	if node.Outer != nil {
+		err := visitCompSpec(*node.Outer, imports)
+		if err != nil {
+			return err
+		}
+	}
+
+	for _, ifspec := range node.Conditions {
+		err := visit(ifspec.Expr, imports)
+		if err != nil {
+			return err
+		}
+	}
 	return visit(node.Expr, imports)
 }
 
 func visitObjectField(node ast.ObjectField, imports *[]ast.Import) error {
+	if node.Method != nil {
+		err := visit(node.Method, imports)
+		if err != nil {
+			return err
+		}
+	}
+
+	if node.Params != nil {
+		for _, p := range node.Params.Optional {
+			err := visit(p.DefaultArg, imports)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
 	err := visit(node.Expr1, imports)
 	if err != nil {
 		return err
@@ -260,6 +289,12 @@ func visitDesugaredObjectField(node ast.DesugaredObjectField, imports *[]ast.Imp
 }
 
 func visitLocalBind(node ast.LocalBind, imports *[]ast.Import) error {
+	if node.Fun != nil {
+		err := visit(node.Fun, imports)
+		if err != nil {
+			return err
+		}
+	}
 	return visit(node.Body, imports)
 }
 
@@ -280,7 +315,7 @@ func replace(jsonnet string, imports []ast.Import) string {
 	})
 
 	for _, im := range imports {
-		param := paramReplacementPrefix + strings.TrimPrefix(im.File, paramPrefix) + paramReplacementSuffix
+		param := paramReplacementPrefix + strings.TrimPrefix(im.File.Value, paramPrefix) + paramReplacementSuffix
 
 		lineStart := im.Loc().Begin.Line
 		lineEnd := im.Loc().End.Line
diff --git a/template/expander.go b/template/expander.go
index 961a5274af775a3d744d8463f88b303ba6772e51..93ea47b666b7683e1422df61da6293fbd30c1a44 100644
--- a/template/expander.go
+++ b/template/expander.go
@@ -8,9 +8,9 @@ import (
 
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 
+	jsonnet "github.com/google/go-jsonnet"
 	"github.com/ksonnet/ksonnet/utils"
 	log "github.com/sirupsen/logrus"
-	jsonnet "github.com/strickyak/jsonnet_cgo"
 )
 
 type Expander struct {
@@ -31,7 +31,6 @@ func (spec *Expander) Expand(paths []string) ([]*unstructured.Unstructured, erro
 	if err != nil {
 		return nil, err
 	}
-	defer vm.Destroy()
 
 	res := []*unstructured.Unstructured{}
 	for _, path := range paths {
@@ -47,18 +46,23 @@ func (spec *Expander) Expand(paths []string) ([]*unstructured.Unstructured, erro
 // JsonnetVM constructs a new jsonnet.VM, according to command line
 // flags
 func (spec *Expander) jsonnetVM() (*jsonnet.VM, error) {
-	vm := jsonnet.Make()
+	vm := jsonnet.MakeVM()
+	importer := jsonnet.FileImporter{
+		JPaths: []string{},
+	}
 
 	for _, p := range spec.EnvJPath {
 		log.Debugln("Adding jsonnet search path", p)
-		vm.JpathAdd(p)
+		importer.JPaths = append(importer.JPaths, p)
 	}
 
 	for _, p := range spec.FlagJpath {
 		log.Debugln("Adding jsonnet search path", p)
-		vm.JpathAdd(p)
+		importer.JPaths = append(importer.JPaths, p)
 	}
 
+	vm.Importer(&importer)
+
 	for _, extvar := range spec.ExtVars {
 		kv := strings.SplitN(extvar, "=", 2)
 		switch len(kv) {
@@ -92,12 +96,12 @@ func (spec *Expander) jsonnetVM() (*jsonnet.VM, error) {
 		case 1:
 			v, present := os.LookupEnv(kv[0])
 			if present {
-				vm.TlaVar(kv[0], v)
+				vm.TLAVar(kv[0], v)
 			} else {
 				return nil, fmt.Errorf("Missing environment variable: %s", kv[0])
 			}
 		case 2:
-			vm.TlaVar(kv[0], kv[1])
+			vm.TLAVar(kv[0], kv[1])
 		}
 	}
 
@@ -110,7 +114,7 @@ func (spec *Expander) jsonnetVM() (*jsonnet.VM, error) {
 		if err != nil {
 			return nil, err
 		}
-		vm.TlaVar(kv[0], string(v))
+		vm.TLAVar(kv[0], string(v))
 	}
 
 	for _, extcode := range spec.ExtCodes {
diff --git a/utils/acquire.go b/utils/acquire.go
index 7d983feec766dabdaab606257cf348e29ed5bc7f..dd93e1f761e6002e75bd3dc2780d56a39f317d9a 100644
--- a/utils/acquire.go
+++ b/utils/acquire.go
@@ -24,8 +24,8 @@ import (
 	"os"
 	"path/filepath"
 
+	jsonnet "github.com/google/go-jsonnet"
 	log "github.com/sirupsen/logrus"
-	jsonnet "github.com/strickyak/jsonnet_cgo"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/yaml"
@@ -126,7 +126,12 @@ func jsonWalk(obj interface{}) ([]interface{}, error) {
 }
 
 func jsonnetReader(vm *jsonnet.VM, path string) ([]runtime.Object, error) {
-	jsonstr, err := vm.EvaluateFile(path)
+	jsonnetBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	jsonstr, err := vm.EvaluateSnippet(path, string(jsonnetBytes))
 	if err != nil {
 		return nil, err
 	}
diff --git a/utils/nativefuncs.go b/utils/nativefuncs.go
index 30fe7cc8ab6df2030e318643a2a7156f357ac95b..4db4a67c7e35ca25e33f5ba3bd76a0426d319796 100644
--- a/utils/nativefuncs.go
+++ b/utils/nativefuncs.go
@@ -24,7 +24,8 @@ import (
 
 	goyaml "github.com/ghodss/yaml"
 
-	jsonnet "github.com/strickyak/jsonnet_cgo"
+	jsonnet "github.com/google/go-jsonnet"
+	"github.com/google/go-jsonnet/ast"
 	"k8s.io/apimachinery/pkg/util/yaml"
 )
 
@@ -48,61 +49,110 @@ func RegisterNativeFuncs(vm *jsonnet.VM, resolver Resolver) {
 	// "*FromJson" functions will be replaced by regular native
 	// version when libjsonnet is able to support this.
 
-	vm.NativeCallback("parseJson", []string{"json"}, func(data []byte) (res interface{}, err error) {
-		err = json.Unmarshal(data, &res)
-		return
-	})
-
-	vm.NativeCallback("parseYaml", []string{"yaml"}, func(data []byte) ([]interface{}, error) {
-		ret := []interface{}{}
-		d := yaml.NewYAMLToJSONDecoder(bytes.NewReader(data))
-		for {
-			var doc interface{}
-			if err := d.Decode(&doc); err != nil {
-				if err == io.EOF {
-					break
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "parseJson",
+			Params: ast.Identifiers{"json"},
+			Func: func(dataString []interface{}) (res interface{}, err error) {
+				data := []byte(dataString[0].(string))
+				err = json.Unmarshal(data, &res)
+				return
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "parseYaml",
+			Params: ast.Identifiers{"yaml"},
+			Func: func(dataString []interface{}) (interface{}, error) {
+				data := []byte(dataString[0].(string))
+				ret := []interface{}{}
+				d := yaml.NewYAMLToJSONDecoder(bytes.NewReader(data))
+				for {
+					var doc interface{}
+					if err := d.Decode(&doc); err != nil {
+						if err == io.EOF {
+							break
+						}
+						return nil, err
+					}
+					ret = append(ret, doc)
 				}
-				return nil, err
-			}
-			ret = append(ret, doc)
-		}
-		return ret, nil
-	})
-
-	vm.NativeCallback("manifestJsonFromJson", []string{"json", "indent"}, func(data []byte, indent int) (string, error) {
-		data = bytes.TrimSpace(data)
-		buf := bytes.Buffer{}
-		if err := json.Indent(&buf, data, "", strings.Repeat(" ", indent)); err != nil {
-			return "", err
-		}
-		buf.WriteString("\n")
-		return buf.String(), nil
-	})
-
-	vm.NativeCallback("manifestYamlFromJson", []string{"json"}, func(data []byte) (string, error) {
-		var input interface{}
-		if err := json.Unmarshal(data, &input); err != nil {
-			return "", err
-		}
-		output, err := goyaml.Marshal(input)
-		return string(output), err
-	})
-
-	vm.NativeCallback("resolveImage", []string{"image"}, func(image string) (string, error) {
-		return resolveImage(resolver, image)
-	})
-
-	vm.NativeCallback("escapeStringRegex", []string{"str"}, func(s string) (string, error) {
-		return regexp.QuoteMeta(s), nil
-	})
-
-	vm.NativeCallback("regexMatch", []string{"regex", "string"}, regexp.MatchString)
-
-	vm.NativeCallback("regexSubst", []string{"regex", "src", "repl"}, func(regex, src, repl string) (string, error) {
-		r, err := regexp.Compile(regex)
-		if err != nil {
-			return "", err
-		}
-		return r.ReplaceAllString(src, repl), nil
-	})
+				return ret, nil
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "manifestJsonFromJson",
+			Params: ast.Identifiers{"json", "indent"},
+			Func: func(data []interface{}) (interface{}, error) {
+				indent := int(data[1].(float64))
+				dataBytes := []byte(data[0].(string))
+				dataBytes = bytes.TrimSpace(dataBytes)
+				buf := bytes.Buffer{}
+				if err := json.Indent(&buf, dataBytes, "", strings.Repeat(" ", indent)); err != nil {
+					return "", err
+				}
+				buf.WriteString("\n")
+				return buf.String(), nil
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "manifestYamlFromJson",
+			Params: ast.Identifiers{"json"},
+			Func: func(data []interface{}) (interface{}, error) {
+				var input interface{}
+				dataBytes := []byte(data[0].(string))
+				if err := json.Unmarshal(dataBytes, &input); err != nil {
+					return "", err
+				}
+				output, err := goyaml.Marshal(input)
+				return string(output), err
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "resolveImage",
+			Params: ast.Identifiers{"image"},
+			Func: func(image []interface{}) (interface{}, error) {
+				return resolveImage(resolver, image[0].(string))
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "escapeStringRegex",
+			Params: ast.Identifiers{"str"},
+			Func: func(s []interface{}) (interface{}, error) {
+				return regexp.QuoteMeta(s[0].(string)), nil
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "regexMatch",
+			Params: ast.Identifiers{"regex", "string"},
+			Func: func(s []interface{}) (interface{}, error) {
+				return regexp.MatchString(s[0].(string), s[1].(string))
+			},
+		})
+
+	vm.NativeFunction(
+		&jsonnet.NativeFunction{
+			Name:   "regexSubst",
+			Params: ast.Identifiers{"regex", "src", "repl"},
+			Func: func(data []interface{}) (interface{}, error) {
+				regex, src, repl := data[0].(string), data[1].(string), data[2].(string)
+
+				r, err := regexp.Compile(regex)
+				if err != nil {
+					return "", err
+				}
+				return r.ReplaceAllString(src, repl), nil
+			},
+		})
 }
diff --git a/utils/nativefuncs_test.go b/utils/nativefuncs_test.go
index 8e6d7a97439d704129c0bf354b5ebcf6c37bac03..624850129c9647d2c15b7e342b942e70b177cc71 100644
--- a/utils/nativefuncs_test.go
+++ b/utils/nativefuncs_test.go
@@ -18,7 +18,7 @@ package utils
 import (
 	"testing"
 
-	jsonnet "github.com/strickyak/jsonnet_cgo"
+	jsonnet "github.com/google/go-jsonnet"
 )
 
 // check there is no err, and a == b.
@@ -31,8 +31,7 @@ func check(t *testing.T, err error, actual, expected string) {
 }
 
 func TestParseJson(t *testing.T) {
-	vm := jsonnet.Make()
-	defer vm.Destroy()
+	vm := jsonnet.MakeVM()
 	RegisterNativeFuncs(vm, NewIdentityResolver())
 
 	_, err := vm.EvaluateSnippet("failtest", `std.native("parseJson")("barf{")`)
@@ -41,17 +40,16 @@ func TestParseJson(t *testing.T) {
 	}
 
 	x, err := vm.EvaluateSnippet("test", `std.native("parseJson")("null")`)
-	check(t, err, x, "null\n")
+	check(t, err, x, "null")
 
 	x, err = vm.EvaluateSnippet("test", `
     local a = std.native("parseJson")('{"foo": 3, "bar": 4}');
     a.foo + a.bar`)
-	check(t, err, x, "7\n")
+	check(t, err, x, "7")
 }
 
 func TestParseYaml(t *testing.T) {
-	vm := jsonnet.Make()
-	defer vm.Destroy()
+	vm := jsonnet.MakeVM()
 	RegisterNativeFuncs(vm, NewIdentityResolver())
 
 	_, err := vm.EvaluateSnippet("failtest", `std.native("parseYaml")("[barf")`)
@@ -60,22 +58,21 @@ func TestParseYaml(t *testing.T) {
 	}
 
 	x, err := vm.EvaluateSnippet("test", `std.native("parseYaml")("")`)
-	check(t, err, x, "[ ]\n")
+	check(t, err, x, "[ ]")
 
 	x, err = vm.EvaluateSnippet("test", `
     local a = std.native("parseYaml")("foo:\n- 3\n- 4\n")[0];
     a.foo[0] + a.foo[1]`)
-	check(t, err, x, "7\n")
+	check(t, err, x, "7")
 
 	x, err = vm.EvaluateSnippet("test", `
     local a = std.native("parseYaml")("---\nhello\n---\nworld");
     a[0] + a[1]`)
-	check(t, err, x, "\"helloworld\"\n")
+	check(t, err, x, "\"helloworld\"")
 }
 
 func TestRegexMatch(t *testing.T) {
-	vm := jsonnet.Make()
-	defer vm.Destroy()
+	vm := jsonnet.MakeVM()
 	RegisterNativeFuncs(vm, NewIdentityResolver())
 
 	_, err := vm.EvaluateSnippet("failtest", `std.native("regexMatch")("[f", "foo")`)
@@ -84,15 +81,14 @@ func TestRegexMatch(t *testing.T) {
 	}
 
 	x, err := vm.EvaluateSnippet("test", `std.native("regexMatch")("foo.*", "seafood")`)
-	check(t, err, x, "true\n")
+	check(t, err, x, "true")
 
 	x, err = vm.EvaluateSnippet("test", `std.native("regexMatch")("bar.*", "seafood")`)
-	check(t, err, x, "false\n")
+	check(t, err, x, "false")
 }
 
 func TestRegexSubst(t *testing.T) {
-	vm := jsonnet.Make()
-	defer vm.Destroy()
+	vm := jsonnet.MakeVM()
 	RegisterNativeFuncs(vm, NewIdentityResolver())
 
 	_, err := vm.EvaluateSnippet("failtest", `std.native("regexSubst")("[f",s "foo", "bar")`)
@@ -101,8 +97,8 @@ func TestRegexSubst(t *testing.T) {
 	}
 
 	x, err := vm.EvaluateSnippet("test", `std.native("regexSubst")("a(x*)b", "-ab-axxb-", "T")`)
-	check(t, err, x, "\"-T-T-\"\n")
+	check(t, err, x, "\"-T-T-\"")
 
 	x, err = vm.EvaluateSnippet("test", `std.native("regexSubst")("a(x*)b", "-ab-axxb-", "${1}W")`)
-	check(t, err, x, "\"-W-xxW-\"\n")
+	check(t, err, x, "\"-W-xxW-\"")
 }
diff --git a/vendor/github.com/clipperhouse/set/setwriter.go b/vendor/github.com/clipperhouse/set/setwriter.go
new file mode 100644
index 0000000000000000000000000000000000000000..4485f4df6f23f8e6665e70be56766d89fd56477f
--- /dev/null
+++ b/vendor/github.com/clipperhouse/set/setwriter.go
@@ -0,0 +1,59 @@
+package set
+
+import (
+	"io"
+
+	"github.com/clipperhouse/typewriter"
+)
+
+func init() {
+	err := typewriter.Register(NewSetWriter())
+	if err != nil {
+		panic(err)
+	}
+}
+
+type SetWriter struct{}
+
+func NewSetWriter() *SetWriter {
+	return &SetWriter{}
+}
+
+func (sw *SetWriter) Name() string {
+	return "set"
+}
+
+func (sw *SetWriter) Imports(t typewriter.Type) (result []typewriter.ImportSpec) {
+	// none
+	return result
+}
+
+func (sw *SetWriter) Write(w io.Writer, t typewriter.Type) error {
+	tag, found := t.FindTag(sw)
+
+	if !found {
+		// nothing to be done
+		return nil
+	}
+
+	license := `// Set is a modification of https://github.com/deckarep/golang-set
+// The MIT License (MIT)
+// Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+`
+
+	if _, err := w.Write([]byte(license)); err != nil {
+		return err
+	}
+
+	tmpl, err := templates.ByTag(t, tag)
+
+	if err != nil {
+		return err
+	}
+
+	if err := tmpl.Execute(w, t); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/clipperhouse/set/templates.go b/vendor/github.com/clipperhouse/set/templates.go
new file mode 100644
index 0000000000000000000000000000000000000000..707d502b04fb30d159ae4eabfa23ed36fc4ea32e
--- /dev/null
+++ b/vendor/github.com/clipperhouse/set/templates.go
@@ -0,0 +1,176 @@
+package set
+
+import "github.com/clipperhouse/typewriter"
+
+var templates = typewriter.TemplateSlice{
+	set,
+}
+
+var set = &typewriter.Template{
+	Name: "Set",
+	Text: `
+// {{.Name}}Set is the primary type that represents a set
+type {{.Name}}Set map[{{.Pointer}}{{.Name}}]struct{}
+
+// New{{.Name}}Set creates and returns a reference to an empty set.
+func New{{.Name}}Set(a ...{{.Pointer}}{{.Name}}) {{.Name}}Set {
+	s := make({{.Name}}Set)
+	for _, i := range a {
+		s.Add(i)
+	}
+	return s
+}
+
+// ToSlice returns the elements of the current set as a slice
+func (set {{.Name}}Set) ToSlice() []{{.Pointer}}{{.Name}} {
+	var s []{{.Pointer}}{{.Name}}
+	for v := range set {
+		s = append(s, v)
+	}
+	return s
+}
+
+// Add adds an item to the current set if it doesn't already exist in the set.
+func (set {{.Name}}Set) Add(i {{.Pointer}}{{.Name}}) bool {
+	_, found := set[i]
+	set[i] = struct{}{}
+	return !found //False if it existed already
+}
+
+// Contains determines if a given item is already in the set.
+func (set {{.Name}}Set) Contains(i {{.Pointer}}{{.Name}}) bool {
+	_, found := set[i]
+	return found
+}
+
+// ContainsAll determines if the given items are all in the set
+func (set {{.Name}}Set) ContainsAll(i ...{{.Pointer}}{{.Name}}) bool {
+	for _, v := range i {
+		if !set.Contains(v) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsSubset determines if every item in the other set is in this set.
+func (set {{.Name}}Set) IsSubset(other {{.Name}}Set) bool {
+	for elem := range set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsSuperset determines if every item of this set is in the other set.
+func (set {{.Name}}Set) IsSuperset(other {{.Name}}Set) bool {
+	return other.IsSubset(set)
+}
+
+// Union returns a new set with all items in both sets.
+func (set {{.Name}}Set) Union(other {{.Name}}Set) {{.Name}}Set {
+	unionedSet := New{{.Name}}Set()
+
+	for elem := range set {
+		unionedSet.Add(elem)
+	}
+	for elem := range other {
+		unionedSet.Add(elem)
+	}
+	return unionedSet
+}
+
+// Intersect returns a new set with items that exist only in both sets.
+func (set {{.Name}}Set) Intersect(other {{.Name}}Set) {{.Name}}Set {
+	intersection := New{{.Name}}Set()
+	// loop over smaller set
+	if set.Cardinality() < other.Cardinality() {
+		for elem := range set {
+			if other.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	} else {
+		for elem := range other {
+			if set.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	}
+	return intersection
+}
+
+// Difference returns a new set with items in the current set but not in the other set
+func (set {{.Name}}Set) Difference(other {{.Name}}Set) {{.Name}}Set {
+	differencedSet := New{{.Name}}Set()
+	for elem := range set {
+		if !other.Contains(elem) {
+			differencedSet.Add(elem)
+		}
+	}
+	return differencedSet
+}
+
+// SymmetricDifference returns a new set with items in the current set or the other set but not in both.
+func (set {{.Name}}Set) SymmetricDifference(other {{.Name}}Set) {{.Name}}Set {
+	aDiff := set.Difference(other)
+	bDiff := other.Difference(set)
+	return aDiff.Union(bDiff)
+}
+
+// Clear clears the entire set to be the empty set.
+func (set *{{.Name}}Set) Clear() {
+	*set = make({{.Name}}Set)
+}
+
+// Remove allows the removal of a single item in the set.
+func (set {{.Name}}Set) Remove(i {{.Pointer}}{{.Name}}) {
+	delete(set, i)
+}
+
+// Cardinality returns how many items are currently in the set.
+func (set {{.Name}}Set) Cardinality() int {
+	return len(set)
+}
+
+// Iter returns a channel of type {{.Pointer}}{{.Name}} that you can range over.
+func (set {{.Name}}Set) Iter() <-chan {{.Pointer}}{{.Name}} {
+	ch := make(chan {{.Pointer}}{{.Name}})
+	go func() {
+		for elem := range set {
+			ch <- elem
+		}
+		close(ch)
+	}()
+
+	return ch
+}
+
+// Equal determines if two sets are equal to each other.
+// If they both are the same size and have the same items they are considered equal.
+// Order of items is not relevent for sets to be equal.
+func (set {{.Name}}Set) Equal(other {{.Name}}Set) bool {
+	if set.Cardinality() != other.Cardinality() {
+		return false
+	}
+	for elem := range set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+// Clone returns a clone of the set.
+// Does NOT clone the underlying elements.
+func (set {{.Name}}Set) Clone() {{.Name}}Set {
+	clonedSet := New{{.Name}}Set()
+	for elem := range set {
+		clonedSet.Add(elem)
+	}
+	return clonedSet
+}
+`,
+	TypeConstraint: typewriter.Constraint{Comparable: true},
+}
diff --git a/vendor/github.com/clipperhouse/slice/README.md b/vendor/github.com/clipperhouse/slice/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f3bd8f5722dce486f50705eae00068687618153a
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/README.md
@@ -0,0 +1,5 @@
+### [Details and docs...](https://clipperhouse.github.io/gen/slice/)
+
+This package is a typewriter for use with [gen](https://github.com/clipperhouse/gen), a type-driven code generation tool for Go.
+
+The slice typewriter offers LINQ-like methods for working with slices, such as filtering and sorting. See the docs above for details.
diff --git a/vendor/github.com/clipperhouse/slice/aggregate.go b/vendor/github.com/clipperhouse/slice/aggregate.go
new file mode 100644
index 0000000000000000000000000000000000000000..419dd05b05d692633f24115fc466b2d66a07e908
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/aggregate.go
@@ -0,0 +1,20 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var aggregateT = &typewriter.Template{
+	Name: "Aggregate",
+	Text: `
+// Aggregate{{.TypeParameter.LongName}} iterates over {{.SliceName}}, operating on each element while maintaining ‘state’. See: http://clipperhouse.github.io/gen/#Aggregate
+func (rcv {{.SliceName}}) Aggregate{{.TypeParameter.LongName}}(fn func({{.TypeParameter}}, {{.Type}}) {{.TypeParameter}}) (result {{.TypeParameter}}) {
+	for _, v := range rcv {
+		result = fn(result, v)
+	}
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, but no constraints on that type
+		{},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/all.go b/vendor/github.com/clipperhouse/slice/all.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f919b901968fce23c3fed4b14289cd644bbb7f2
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/all.go
@@ -0,0 +1,17 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var all = &typewriter.Template{
+	Name: "All",
+	Text: `
+// All verifies that all elements of {{.SliceName}} return true for the passed func. See: http://clipperhouse.github.io/gen/#All
+func (rcv {{.SliceName}}) All(fn func({{.Type}}) bool) bool {
+	for _, v := range rcv {
+		if !fn(v) {
+			return false
+		}
+	}
+	return true
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/any.go b/vendor/github.com/clipperhouse/slice/any.go
new file mode 100644
index 0000000000000000000000000000000000000000..380628f29c69eea87990bcf476cc79efc8464c11
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/any.go
@@ -0,0 +1,17 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var any = &typewriter.Template{
+	Name: "Any",
+	Text: `
+// Any verifies that one or more elements of {{.SliceName}} return true for the passed func. See: http://clipperhouse.github.io/gen/#Any
+func (rcv {{.SliceName}}) Any(fn func({{.Type}}) bool) bool {
+	for _, v := range rcv {
+		if fn(v) {
+			return true
+		}
+	}
+	return false
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/average.go b/vendor/github.com/clipperhouse/slice/average.go
new file mode 100644
index 0000000000000000000000000000000000000000..52fe56bbbe9017d916648ce7a5ba77b7bf41ad60
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/average.go
@@ -0,0 +1,47 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var average = &typewriter.Template{
+	Name: "Average",
+	Text: `
+// Average sums {{.SliceName}} over all elements and divides by len({{.SliceName}}). See: http://clipperhouse.github.io/gen/#Average
+func (rcv {{.SliceName}}) Average() ({{.Type}}, error) {
+	var result {{.Type}}
+
+	l := len(rcv)
+	if l == 0 {
+		return result, errors.New("cannot determine Average of zero-length {{.SliceName}}")
+	}
+	for _, v := range rcv {
+		result += v
+	}
+	result = result / {{.Type}}(l)
+	return result, nil
+}
+`,
+	TypeConstraint: typewriter.Constraint{Numeric: true},
+}
+
+var averageT = &typewriter.Template{
+	Name: "Average",
+	Text: `
+// Average{{.TypeParameter.LongName}} sums {{.TypeParameter}} over all elements and divides by len({{.SliceName}}). See: http://clipperhouse.github.io/gen/#Average
+func (rcv {{.SliceName}}) Average{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) (result {{.TypeParameter}}, err error) {
+	l := len(rcv)
+	if l == 0 {
+		err = errors.New("cannot determine Average[{{.TypeParameter}}] of zero-length {{.SliceName}}")
+		return
+	}
+	for _, v := range rcv {
+		result += fn(v)
+	}
+	result = result / {{.TypeParameter}}(l)
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, and it must be numeric
+		{Numeric: true},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/count.go b/vendor/github.com/clipperhouse/slice/count.go
new file mode 100644
index 0000000000000000000000000000000000000000..f5df103b41e3e4353435ab9385920f0f9089f336
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/count.go
@@ -0,0 +1,17 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var count = &typewriter.Template{
+	Name: "Count",
+	Text: `
+// Count gives the number elements of {{.SliceName}} that return true for the passed func. See: http://clipperhouse.github.io/gen/#Count
+func (rcv {{.SliceName}}) Count(fn func({{.Type}}) bool) (result int) {
+	for _, v := range rcv {
+		if fn(v) {
+			result++
+		}
+	}
+	return
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/distinct.go b/vendor/github.com/clipperhouse/slice/distinct.go
new file mode 100644
index 0000000000000000000000000000000000000000..22c6f133627da9eb2ae3716cd48d496629431431
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/distinct.go
@@ -0,0 +1,21 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var distinct = &typewriter.Template{
+	Name: "Distinct",
+	Text: `
+// Distinct returns a new {{.SliceName}} whose elements are unique. See: http://clipperhouse.github.io/gen/#Distinct
+func (rcv {{.SliceName}}) Distinct() (result {{.SliceName}}) {
+	appended := make(map[{{.Type}}]bool)
+	for _, v := range rcv {
+		if !appended[v] {
+			result = append(result, v)
+			appended[v] = true
+		}
+	}
+	return result
+}
+`,
+	TypeConstraint: typewriter.Constraint{Comparable: true},
+}
diff --git a/vendor/github.com/clipperhouse/slice/distinctby.go b/vendor/github.com/clipperhouse/slice/distinctby.go
new file mode 100644
index 0000000000000000000000000000000000000000..4eb7b75cc2dd13b604ed561ce9bafecb44185124
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/distinctby.go
@@ -0,0 +1,21 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var distinctBy = &typewriter.Template{
+	Name: "DistinctBy",
+	Text: `
+// DistinctBy returns a new {{.SliceName}} whose elements are unique, where equality is defined by a passed func. See: http://clipperhouse.github.io/gen/#DistinctBy
+func (rcv {{.SliceName}}) DistinctBy(equal func({{.Type}}, {{.Type}}) bool) (result {{.SliceName}}) {
+Outer:
+	for _, v := range rcv {
+		for _, r := range result {
+			if equal(v, r) {
+				continue Outer
+			}
+		}
+		result = append(result, v)
+	}
+	return result
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/each.go b/vendor/github.com/clipperhouse/slice/each.go
new file mode 100644
index 0000000000000000000000000000000000000000..c0c5f0ffd8c2c47339d0c946b0fe1f7af0417ccc
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/each.go
@@ -0,0 +1,14 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var each = &typewriter.Template{
+	Name: "Each",
+	Text: `
+// Each iterates over {{.SliceName}} and executes the passed func against each element. See: http://clipperhouse.github.io/gen/#Each
+func (rcv {{.SliceName}}) Each(fn func({{.Type}})) {
+	for _, v := range rcv {
+		fn(v)
+	}
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/first.go b/vendor/github.com/clipperhouse/slice/first.go
new file mode 100644
index 0000000000000000000000000000000000000000..e6df37597c702dff8713902dd5152b99a6514441
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/first.go
@@ -0,0 +1,19 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var first = &typewriter.Template{
+	Name: "First",
+	Text: `
+// First returns the first element that returns true for the passed func. Returns error if no elements return true. See: http://clipperhouse.github.io/gen/#First
+func (rcv {{.SliceName}}) First(fn func({{.Type}}) bool) (result {{.Type}}, err error) {
+	for _, v := range rcv {
+		if fn(v) {
+			result = v
+			return
+		}
+	}
+	err = errors.New("no {{.SliceName}} elements return true for passed func")
+	return
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/groupby.go b/vendor/github.com/clipperhouse/slice/groupby.go
new file mode 100644
index 0000000000000000000000000000000000000000..cb47f1a40ccb9c2f8e8d64874f3ba6e181719e26
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/groupby.go
@@ -0,0 +1,22 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var groupByT = &typewriter.Template{
+	Name: "GroupBy",
+	Text: `
+// GroupBy{{.TypeParameter.LongName}} groups elements into a map keyed by {{.TypeParameter}}. See: http://clipperhouse.github.io/gen/#GroupBy
+func (rcv {{.SliceName}}) GroupBy{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) map[{{.TypeParameter}}]{{.SliceName}} {
+	result := make(map[{{.TypeParameter}}]{{.SliceName}})
+	for _, v := range rcv {
+		key := fn(v)
+		result[key] = append(result[key], v)
+	}
+	return result
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, and it must be comparable
+		{Comparable: true},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/max.go b/vendor/github.com/clipperhouse/slice/max.go
new file mode 100644
index 0000000000000000000000000000000000000000..7be599c2931a0f43fed2e5e0b3cf8156176360fc
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/max.go
@@ -0,0 +1,53 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var max = &typewriter.Template{
+	Name: "Max",
+	Text: `
+	// Max returns the maximum value of {{.SliceName}}. In the case of multiple items being equally maximal, the first such element is returned. Returns error if no elements. See: http://clipperhouse.github.io/gen/#Max
+	func (rcv {{.SliceName}}) Max() (result {{.Type}}, err error) {
+		l := len(rcv)
+		if l == 0 {
+			err = errors.New("cannot determine the Max of an empty slice")
+			return
+		}
+		result = rcv[0]
+		for _, v := range rcv {
+			if v > result {
+				result = v
+			}
+		}
+		return
+	}
+	`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
+
+var maxT = &typewriter.Template{
+	Name: "Max",
+	Text: `
+// Max{{.TypeParameter.LongName}} selects the largest value of {{.TypeParameter}} in {{.SliceName}}. Returns error on {{.SliceName}} with no elements. See: http://clipperhouse.github.io/gen/#MaxCustom
+func (rcv {{.SliceName}}) Max{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) (result {{.TypeParameter}}, err error) {
+	l := len(rcv)
+	if l == 0 {
+		err = errors.New("cannot determine Max of zero-length {{.SliceName}}")
+		return
+	}
+	result = fn(rcv[0])
+	if l > 1 {
+		for _, v := range rcv[1:] {
+			f := fn(v)
+			if f > result {
+				result = f
+			}
+		}
+	}
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, and it must be ordered
+		{Ordered: true},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/maxby.go b/vendor/github.com/clipperhouse/slice/maxby.go
new file mode 100644
index 0000000000000000000000000000000000000000..62cab61067135deb57af5b377b01d17f697af320
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/maxby.go
@@ -0,0 +1,24 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var maxBy = &typewriter.Template{
+	Name: "MaxBy",
+	Text: `
+// MaxBy returns an element of {{.SliceName}} containing the maximum value, when compared to other elements using a passed func defining ‘less’. In the case of multiple items being equally maximal, the last such element is returned. Returns error if no elements. See: http://clipperhouse.github.io/gen/#MaxBy
+func (rcv {{.SliceName}}) MaxBy(less func({{.Type}}, {{.Type}}) bool) (result {{.Type}}, err error) {
+	l := len(rcv)
+	if l == 0 {
+		err = errors.New("cannot determine the MaxBy of an empty slice")
+		return
+	}
+	m := 0
+	for i := 1; i < l; i++ {
+		if rcv[i] != rcv[m] && !less(rcv[i], rcv[m]) {
+			m = i
+		}
+	}
+	result = rcv[m]
+	return
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/min.go b/vendor/github.com/clipperhouse/slice/min.go
new file mode 100644
index 0000000000000000000000000000000000000000..3b9b29ffbb91879dd1ebd1f37d3d8a6fa6b17f9e
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/min.go
@@ -0,0 +1,53 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var min = &typewriter.Template{
+	Name: "Min",
+	Text: `
+	// Min returns the minimum value of {{.SliceName}}. In the case of multiple items being equally minimal, the first such element is returned. Returns error if no elements. See: http://clipperhouse.github.io/gen/#Min
+	func (rcv {{.SliceName}}) Min() (result {{.Type}}, err error) {
+		l := len(rcv)
+		if l == 0 {
+			err = errors.New("cannot determine the Min of an empty slice")
+			return
+		}
+		result = rcv[0]
+		for _, v := range rcv {
+			if v < result {
+				result = v
+			}
+		}
+		return
+	}
+	`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
+
+var minT = &typewriter.Template{
+	Name: "Min",
+	Text: `
+// Min{{.TypeParameter.LongName}} selects the least value of {{.TypeParameter}} in {{.SliceName}}. Returns error on {{.SliceName}} with no elements. See: http://clipperhouse.github.io/gen/#MinCustom
+func (rcv {{.SliceName}}) Min{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) (result {{.TypeParameter}}, err error) {
+	l := len(rcv)
+	if l == 0 {
+		err = errors.New("cannot determine Min of zero-length {{.SliceName}}")
+		return
+	}
+	result = fn(rcv[0])
+	if l > 1 {
+		for _, v := range rcv[1:] {
+			f := fn(v)
+			if f < result {
+				result = f
+			}
+		}
+	}
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, and it must be ordered
+		{Ordered: true},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/minby.go b/vendor/github.com/clipperhouse/slice/minby.go
new file mode 100644
index 0000000000000000000000000000000000000000..8223669847bf62d7cbf82de31f52be2994fdd670
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/minby.go
@@ -0,0 +1,24 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var minBy = &typewriter.Template{
+	Name: "MinBy",
+	Text: `
+// MinBy returns an element of {{.SliceName}} containing the minimum value, when compared to other elements using a passed func defining ‘less’. In the case of multiple items being equally minimal, the first such element is returned. Returns error if no elements. See: http://clipperhouse.github.io/gen/#MinBy
+func (rcv {{.SliceName}}) MinBy(less func({{.Type}}, {{.Type}}) bool) (result {{.Type}}, err error) {
+	l := len(rcv)
+	if l == 0 {
+		err = errors.New("cannot determine the Min of an empty slice")
+		return
+	}
+	m := 0
+	for i := 1; i < l; i++ {
+		if less(rcv[i], rcv[m]) {
+			m = i
+		}
+	}
+	result = rcv[m]
+	return
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/select.go b/vendor/github.com/clipperhouse/slice/select.go
new file mode 100644
index 0000000000000000000000000000000000000000..876f786956d78c2ccde6fae40f5e49410c3df04d
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/select.go
@@ -0,0 +1,20 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var selectT = &typewriter.Template{
+	Name: "Select",
+	Text: `
+// Select{{.TypeParameter.LongName}} projects a slice of {{.TypeParameter}} from {{.SliceName}}, typically called a map in other frameworks. See: http://clipperhouse.github.io/gen/#Select
+func (rcv {{.SliceName}}) Select{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) (result []{{.TypeParameter}}) {
+	for _, v := range rcv {
+		result = append(result, fn(v))
+	}
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, but no constraints on that type
+		{},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/shuffle.go b/vendor/github.com/clipperhouse/slice/shuffle.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab00189eb903d0b9ec477478519360d82ba606d8
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/shuffle.go
@@ -0,0 +1,19 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var shuffle = &typewriter.Template{
+	Name: "Shuffle",
+	Text: `
+// Shuffle returns a shuffled copy of {{.SliceName}}, using a version of the Fisher-Yates shuffle. See: http://clipperhouse.github.io/gen/#Shuffle
+func (rcv {{.SliceName}}) Shuffle() {{.SliceName}} {
+    numItems := len(rcv)
+    result := make({{.SliceName}}, numItems)
+    copy(result, rcv)
+    for i := 0; i < numItems; i++ {
+        r := i + rand.Intn(numItems-i)
+        result[r], result[i] = result[i], result[r]
+    }
+    return result
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/single.go b/vendor/github.com/clipperhouse/slice/single.go
new file mode 100644
index 0000000000000000000000000000000000000000..ffce5311f346387877ac025477f539c7393ede28
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/single.go
@@ -0,0 +1,29 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var single = &typewriter.Template{
+	Name: "Single",
+	Text: `
+// Single returns exactly one element of {{.SliceName}} that returns true for the passed func. Returns error if no or multiple elements return true. See: http://clipperhouse.github.io/gen/#Single
+func (rcv {{.SliceName}}) Single(fn func({{.Type}}) bool) (result {{.Type}}, err error) {
+	var candidate {{.Type}}
+	found := false
+	for _, v := range rcv {
+		if fn(v) {
+			if found {
+				err = errors.New("multiple {{.SliceName}} elements return true for passed func")
+				return
+			}
+			candidate = v
+			found = true
+		}
+	}
+	if found {
+		result = candidate
+	} else {
+		err = errors.New("no {{.SliceName}} elements return true for passed func")
+	}
+	return
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/slice.go b/vendor/github.com/clipperhouse/slice/slice.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a941c0ca31c5eb4582dec32e6309f370b78f100
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/slice.go
@@ -0,0 +1,10 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var slice = &typewriter.Template{
+	Name: "slice",
+	Text: `// {{.SliceName}} is a slice of type {{.Type}}. Use it where you would use []{{.Type}}.
+type {{.SliceName}} []{{.Type}}
+`,
+}
diff --git a/vendor/github.com/clipperhouse/slice/slicewriter.go b/vendor/github.com/clipperhouse/slice/slicewriter.go
new file mode 100644
index 0000000000000000000000000000000000000000..9b10028d1cdf716353fa7d546c7a95ebf6b5a0a9
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/slicewriter.go
@@ -0,0 +1,139 @@
+package slice
+
+import (
+	"io"
+	"regexp"
+	"strings"
+
+	"github.com/clipperhouse/typewriter"
+)
+
+func init() {
+	err := typewriter.Register(NewSliceWriter())
+	if err != nil {
+		panic(err)
+	}
+}
+
+func SliceName(typ typewriter.Type) string {
+	return typ.Name + "Slice"
+}
+
+type SliceWriter struct{}
+
+func NewSliceWriter() *SliceWriter {
+	return &SliceWriter{}
+}
+
+func (sw *SliceWriter) Name() string {
+	return "slice"
+}
+
+func (sw *SliceWriter) Imports(typ typewriter.Type) (result []typewriter.ImportSpec) {
+	// typewriter uses golang.org/x/tools/imports, depend on that
+	return
+}
+
+func (sw *SliceWriter) Write(w io.Writer, typ typewriter.Type) error {
+	tag, found := typ.FindTag(sw)
+
+	if !found {
+		return nil
+	}
+
+	if includeSortImplementation(tag.Values) {
+		s := `// Sort implementation is a modification of http://golang.org/pkg/sort/#Sort
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found at http://golang.org/LICENSE.
+
+`
+		w.Write([]byte(s))
+	}
+
+	// start with the slice template
+	tmpl, err := templates.ByTag(typ, tag)
+
+	if err != nil {
+		return err
+	}
+
+	m := model{
+		Type:      typ,
+		SliceName: SliceName(typ),
+	}
+
+	if err := tmpl.Execute(w, m); err != nil {
+		return err
+	}
+
+	for _, v := range tag.Values {
+		var tp typewriter.Type
+
+		if len(v.TypeParameters) > 0 {
+			tp = v.TypeParameters[0]
+		}
+
+		m := model{
+			Type:          typ,
+			SliceName:     SliceName(typ),
+			TypeParameter: tp,
+			TagValue:      v,
+		}
+
+		tmpl, err := templates.ByTagValue(typ, v)
+
+		if err != nil {
+			return err
+		}
+
+		if err := tmpl.Execute(w, m); err != nil {
+			return err
+		}
+	}
+
+	if includeSortInterface(tag.Values) {
+		tmpl, err := sortInterface.Parse()
+
+		if err != nil {
+			return err
+		}
+
+		if err := tmpl.Execute(w, m); err != nil {
+			return err
+		}
+	}
+
+	if includeSortImplementation(tag.Values) {
+		tmpl, err := sortImplementation.Parse()
+
+		if err != nil {
+			return err
+		}
+
+		if err := tmpl.Execute(w, m); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func includeSortImplementation(values []typewriter.TagValue) bool {
+	for _, v := range values {
+		if strings.HasPrefix(v.Name, "SortBy") {
+			return true
+		}
+	}
+	return false
+}
+
+func includeSortInterface(values []typewriter.TagValue) bool {
+	reg := regexp.MustCompile(`^Sort(Desc)?$`)
+	for _, v := range values {
+		if reg.MatchString(v.Name) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/github.com/clipperhouse/slice/sort.go b/vendor/github.com/clipperhouse/slice/sort.go
new file mode 100644
index 0000000000000000000000000000000000000000..7d8946b5aac1f6fcfa6d6c5b7eac665ec762a5e8
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/sort.go
@@ -0,0 +1,53 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var sort = &typewriter.Template{
+	Name: "Sort",
+	Text: `
+// Sort returns a new ordered {{.SliceName}}. See: http://clipperhouse.github.io/gen/#Sort
+func (rcv {{.SliceName}}) Sort() {{.SliceName}} {
+	result := make({{.SliceName}}, len(rcv))
+	copy(result, rcv)
+	sort.Sort(result)
+	return result
+}
+`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
+
+var isSorted = &typewriter.Template{
+	Name: "IsSorted",
+	Text: `
+// IsSorted reports whether {{.SliceName}} is sorted. See: http://clipperhouse.github.io/gen/#Sort
+func (rcv {{.SliceName}}) IsSorted() bool {
+	return sort.IsSorted(rcv)
+}
+`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
+
+var sortDesc = &typewriter.Template{
+	Name: "SortDesc",
+	Text: `
+// SortDesc returns a new reverse-ordered {{.SliceName}}. See: http://clipperhouse.github.io/gen/#Sort
+func (rcv {{.SliceName}}) SortDesc() {{.SliceName}} {
+	result := make({{.SliceName}}, len(rcv))
+	copy(result, rcv)
+	sort.Sort(sort.Reverse(result))
+	return result
+}
+`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
+
+var isSortedDesc = &typewriter.Template{
+	Name: "IsSortedDesc",
+	Text: `
+// IsSortedDesc reports whether {{.SliceName}} is reverse-sorted. See: http://clipperhouse.github.io/gen/#Sort
+func (rcv {{.SliceName}}) IsSortedDesc() bool {
+	return sort.IsSorted(sort.Reverse(rcv))
+}
+`,
+	TypeConstraint: typewriter.Constraint{Ordered: true},
+}
diff --git a/vendor/github.com/clipperhouse/slice/sortby.go b/vendor/github.com/clipperhouse/slice/sortby.go
new file mode 100644
index 0000000000000000000000000000000000000000..437beb212b2fddc4933642205f23e24bcf1bfb5d
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/sortby.go
@@ -0,0 +1,61 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var sortBy = &typewriter.Template{
+	Name: "SortBy",
+	Text: `
+// SortBy returns a new ordered {{.SliceName}}, determined by a func defining ‘less’. See: http://clipperhouse.github.io/gen/#SortBy
+func (rcv {{.SliceName}}) SortBy(less func({{.Type}}, {{.Type}}) bool) {{.SliceName}} {
+	result := make({{.SliceName}}, len(rcv))
+	copy(result, rcv)
+	// Switch to heapsort if depth of 2*ceil(lg(n+1)) is reached.
+	n := len(result)
+	maxDepth := 0
+	for i := n; i > 0; i >>= 1 {
+		maxDepth++
+	}
+	maxDepth *= 2
+	quickSort{{.SliceName}}(result, less, 0, n, maxDepth)
+	return result
+}
+`}
+
+var isSortedBy = &typewriter.Template{
+	Name: "IsSortedBy",
+	Text: `
+// IsSortedBy reports whether an instance of {{.SliceName}} is sorted, using the pass func to define ‘less’. See: http://clipperhouse.github.io/gen/#SortBy
+func (rcv {{.SliceName}}) IsSortedBy(less func({{.Type}}, {{.Type}}) bool) bool {
+	n := len(rcv)
+	for i := n - 1; i > 0; i-- {
+		if less(rcv[i], rcv[i-1]) {
+			return false
+		}
+	}
+	return true
+}
+`}
+
+var sortByDesc = &typewriter.Template{
+	Name: "SortByDesc",
+	Text: `
+// SortByDesc returns a new, descending-ordered {{.SliceName}}, determined by a func defining ‘less’. See: http://clipperhouse.github.io/gen/#SortBy
+func (rcv {{.SliceName}}) SortByDesc(less func({{.Type}}, {{.Type}}) bool) {{.SliceName}} {
+	greater := func(a, b {{.Type}}) bool {
+		return less(b, a)
+	}
+	return rcv.SortBy(greater)
+}
+`}
+
+var isSortedByDesc = &typewriter.Template{
+	Name: "IsSortedByDesc",
+	Text: `
+// IsSortedDesc reports whether an instance of {{.SliceName}} is sorted in descending order, using the pass func to define ‘less’. See: http://clipperhouse.github.io/gen/#SortBy
+func (rcv {{.SliceName}}) IsSortedByDesc(less func({{.Type}}, {{.Type}}) bool) bool {
+	greater := func(a, b {{.Type}}) bool {
+		return less(b, a)
+	}
+	return rcv.IsSortedBy(greater)
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/sortimplementation.go b/vendor/github.com/clipperhouse/slice/sortimplementation.go
new file mode 100644
index 0000000000000000000000000000000000000000..1b2bf77f0760a8952fc2f1dd4b1b9598b06679b4
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/sortimplementation.go
@@ -0,0 +1,180 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var sortImplementation = &typewriter.Template{
+	Name: "sortImplementation",
+	Text: `
+// Sort implementation based on http://golang.org/pkg/sort/#Sort, see top of this file
+
+func swap{{.SliceName}}(rcv {{.SliceName}}, a, b int) {
+	rcv[a], rcv[b] = rcv[b], rcv[a]
+}
+
+// Insertion sort
+func insertionSort{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, a, b int) {
+	for i := a + 1; i < b; i++ {
+		for j := i; j > a && less(rcv[j], rcv[j-1]); j-- {
+			swap{{.SliceName}}(rcv, j, j-1)
+		}
+	}
+}
+
+// siftDown implements the heap property on rcv[lo, hi).
+// first is an offset into the array where the root of the heap lies.
+func siftDown{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, lo, hi, first int) {
+	root := lo
+	for {
+		child := 2*root + 1
+		if child >= hi {
+			break
+		}
+		if child+1 < hi && less(rcv[first+child], rcv[first+child+1]) {
+			child++
+		}
+		if !less(rcv[first+root], rcv[first+child]) {
+			return
+		}
+		swap{{.SliceName}}(rcv, first+root, first+child)
+		root = child
+	}
+}
+
+func heapSort{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, a, b int) {
+	first := a
+	lo := 0
+	hi := b - a
+
+	// Build heap with greatest element at top.
+	for i := (hi - 1) / 2; i >= 0; i-- {
+		siftDown{{.SliceName}}(rcv, less, i, hi, first)
+	}
+
+	// Pop elements, largest first, into end of rcv.
+	for i := hi - 1; i >= 0; i-- {
+		swap{{.SliceName}}(rcv, first, first+i)
+		siftDown{{.SliceName}}(rcv, less, lo, i, first)
+	}
+}
+
+// Quicksort, following Bentley and McIlroy,
+// Engineering a Sort Function, SP&E November 1993.
+
+// medianOfThree moves the median of the three values rcv[a], rcv[b], rcv[c] into rcv[a].
+func medianOfThree{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, a, b, c int) {
+	m0 := b
+	m1 := a
+	m2 := c
+	// bubble sort on 3 elements
+	if less(rcv[m1], rcv[m0]) {
+		swap{{.SliceName}}(rcv, m1, m0)
+	}
+	if less(rcv[m2], rcv[m1]) {
+		swap{{.SliceName}}(rcv, m2, m1)
+	}
+	if less(rcv[m1], rcv[m0]) {
+		swap{{.SliceName}}(rcv, m1, m0)
+	}
+	// now rcv[m0] <= rcv[m1] <= rcv[m2]
+}
+
+func swapRange{{.SliceName}}(rcv {{.SliceName}}, a, b, n int) {
+	for i := 0; i < n; i++ {
+		swap{{.SliceName}}(rcv, a+i, b+i)
+	}
+}
+
+func doPivot{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, lo, hi int) (midlo, midhi int) {
+	m := lo + (hi-lo)/2 // Written like this to avoid integer overflow.
+	if hi-lo > 40 {
+		// Tukey's Ninther, median of three medians of three.
+		s := (hi - lo) / 8
+		medianOfThree{{.SliceName}}(rcv, less, lo, lo+s, lo+2*s)
+		medianOfThree{{.SliceName}}(rcv, less, m, m-s, m+s)
+		medianOfThree{{.SliceName}}(rcv, less, hi-1, hi-1-s, hi-1-2*s)
+	}
+	medianOfThree{{.SliceName}}(rcv, less, lo, m, hi-1)
+
+	// Invariants are:
+	//	rcv[lo] = pivot (set up by ChoosePivot)
+	//	rcv[lo <= i < a] = pivot
+	//	rcv[a <= i < b] < pivot
+	//	rcv[b <= i < c] is unexamined
+	//	rcv[c <= i < d] > pivot
+	//	rcv[d <= i < hi] = pivot
+	//
+	// Once b meets c, can swap the "= pivot" sections
+	// into the middle of the slice.
+	pivot := lo
+	a, b, c, d := lo+1, lo+1, hi, hi
+	for {
+		for b < c {
+			if less(rcv[b], rcv[pivot]) { // rcv[b] < pivot
+				b++
+			} else if !less(rcv[pivot], rcv[b]) { // rcv[b] = pivot
+				swap{{.SliceName}}(rcv, a, b)
+				a++
+				b++
+			} else {
+				break
+			}
+		}
+		for b < c {
+			if less(rcv[pivot], rcv[c-1]) { // rcv[c-1] > pivot
+				c--
+			} else if !less(rcv[c-1], rcv[pivot]) { // rcv[c-1] = pivot
+				swap{{.SliceName}}(rcv, c-1, d-1)
+				c--
+				d--
+			} else {
+				break
+			}
+		}
+		if b >= c {
+			break
+		}
+		// rcv[b] > pivot; rcv[c-1] < pivot
+		swap{{.SliceName}}(rcv, b, c-1)
+		b++
+		c--
+	}
+
+	min := func(a, b int) int {
+		if a < b {
+			return a
+		}
+		return b
+	}
+
+	n := min(b-a, a-lo)
+	swapRange{{.SliceName}}(rcv, lo, b-n, n)
+
+	n = min(hi-d, d-c)
+	swapRange{{.SliceName}}(rcv, c, hi-n, n)
+
+	return lo + b - a, hi - (d - c)
+}
+
+func quickSort{{.SliceName}}(rcv {{.SliceName}}, less func({{.Type}}, {{.Type}}) bool, a, b, maxDepth int) {
+	for b-a > 7 {
+		if maxDepth == 0 {
+			heapSort{{.SliceName}}(rcv, less, a, b)
+			return
+		}
+		maxDepth--
+		mlo, mhi := doPivot{{.SliceName}}(rcv, less, a, b)
+		// Avoiding recursion on the larger subproblem guarantees
+		// a stack depth of at most lg(b-a).
+		if mlo-a < b-mhi {
+			quickSort{{.SliceName}}(rcv, less, a, mlo, maxDepth)
+			a = mhi // i.e., quickSort{{.SliceName}}(rcv, mhi, b)
+		} else {
+			quickSort{{.SliceName}}(rcv, less, mhi, b, maxDepth)
+			b = mlo // i.e., quickSort{{.SliceName}}(rcv, a, mlo)
+		}
+	}
+	if b-a > 1 {
+		insertionSort{{.SliceName}}(rcv, less, a, b)
+	}
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/sortinterface.go b/vendor/github.com/clipperhouse/slice/sortinterface.go
new file mode 100644
index 0000000000000000000000000000000000000000..a267df431fe343a3babd9e1a18c3fe784e9d1b1e
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/sortinterface.go
@@ -0,0 +1,17 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var sortInterface = &typewriter.Template{
+	Name: "sortInterface",
+	Text: `
+func (rcv {{.SliceName}}) Len() int {
+	return len(rcv)
+}
+func (rcv {{.SliceName}}) Less(i, j int) bool {
+	return rcv[i] < rcv[j]
+}
+func (rcv {{.SliceName}}) Swap(i, j int) {
+	rcv[i], rcv[j] = rcv[j], rcv[i]
+}
+`}
diff --git a/vendor/github.com/clipperhouse/slice/sum.go b/vendor/github.com/clipperhouse/slice/sum.go
new file mode 100644
index 0000000000000000000000000000000000000000..c20dace50936cfd7f052869e7b72075e147f5627
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/sum.go
@@ -0,0 +1,34 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var sum = &typewriter.Template{
+	Name: "Sum",
+	Text: `
+// Sum sums {{.Type}} elements in {{.SliceName}}. See: http://clipperhouse.github.io/gen/#Sum
+func (rcv {{.SliceName}}) Sum() (result {{.Type}}) {
+	for _, v := range rcv {
+		result += v
+	}
+	return
+}
+`,
+	TypeConstraint: typewriter.Constraint{Numeric: true},
+}
+
+var sumT = &typewriter.Template{
+	Name: "Sum",
+	Text: `
+// Sum{{.TypeParameter.LongName}} sums {{.Type}} over elements in {{.SliceName}}. See: http://clipperhouse.github.io/gen/#Sum
+func (rcv {{.SliceName}}) Sum{{.TypeParameter.LongName}}(fn func({{.Type}}) {{.TypeParameter}}) (result {{.TypeParameter}}) {
+	for _, v := range rcv {
+		result += fn(v)
+	}
+	return
+}
+`,
+	TypeParameterConstraints: []typewriter.Constraint{
+		// exactly one type parameter is required, and it must be numeric
+		{Numeric: true},
+	},
+}
diff --git a/vendor/github.com/clipperhouse/slice/templates.go b/vendor/github.com/clipperhouse/slice/templates.go
new file mode 100644
index 0000000000000000000000000000000000000000..0532c50801f254f10de7cf48b12407041dde7578
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/templates.go
@@ -0,0 +1,56 @@
+package slice
+
+import (
+	"github.com/clipperhouse/typewriter"
+)
+
+// a convenience for passing values into templates; in MVC it'd be called a view model
+type model struct {
+	Type      typewriter.Type
+	SliceName string
+	// these templates only ever happen to use one type parameter
+	TypeParameter typewriter.Type
+	typewriter.TagValue
+}
+
+var templates = typewriter.TemplateSlice{
+	slice,
+
+	aggregateT,
+	all,
+	any,
+	average,
+	averageT,
+	count,
+	distinct,
+	distinctBy,
+	each,
+	first,
+	groupByT,
+	max,
+	maxT,
+	maxBy,
+	min,
+	minT,
+	minBy,
+	selectT,
+	single,
+	sum,
+	sumT,
+	where,
+
+	sort,
+	isSorted,
+	sortDesc,
+	isSortedDesc,
+
+	sortBy,
+	isSortedBy,
+	sortByDesc,
+	isSortedByDesc,
+
+	sortImplementation,
+	sortInterface,
+
+    shuffle,
+}
diff --git a/vendor/github.com/clipperhouse/slice/where.go b/vendor/github.com/clipperhouse/slice/where.go
new file mode 100644
index 0000000000000000000000000000000000000000..b8dd3d7a727a022c18676500859ec9ab744b17a8
--- /dev/null
+++ b/vendor/github.com/clipperhouse/slice/where.go
@@ -0,0 +1,17 @@
+package slice
+
+import "github.com/clipperhouse/typewriter"
+
+var where = &typewriter.Template{
+	Name: "Where",
+	Text: `
+// Where returns a new {{.SliceName}} whose elements return true for func. See: http://clipperhouse.github.io/gen/#Where
+func (rcv {{.SliceName}}) Where(fn func({{.Type}}) bool) (result {{.SliceName}}) {
+	for _, v := range rcv {
+		if fn(v) {
+			result = append(result, v)
+		}
+	}
+	return result
+}
+`}
diff --git a/vendor/github.com/clipperhouse/stringer/README.md b/vendor/github.com/clipperhouse/stringer/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..da3b6e12a57010f52bcbcb4dac16ed2c3f327e92
--- /dev/null
+++ b/vendor/github.com/clipperhouse/stringer/README.md
@@ -0,0 +1,29 @@
+stringer
+========
+
+This is a typewriter package for use with [gen](https://github.com/clipperhouse/gen), a tool for type-driven code generation. It is a fork of Rob Pike’s [tool](https://godoc.org/golang.org/x/tools/cmd/stringer) of the same name, which generates readable strings for consts.
+
+It is one of gen’s built-in typewriters.
+
+To use it:
+
+```
+go get -u github.com/clipperhouse/gen
+```
+
+Then, mark up a type in your package, for example:
+
+```
+// +gen stringer
+type Pill int
+
+const (
+	Placebo Pill = iota
+	Aspirin
+	Ibuprofen
+	Paracetamol
+	Acetaminophen = Paracetamol
+)
+```
+
+...and run `gen` on your package. You should see a new file named `mytype_stringer.go`. See the [gen docs](https://clipperhouse.github.io/gen/) for more information.
diff --git a/vendor/github.com/clipperhouse/stringer/stringer.go b/vendor/github.com/clipperhouse/stringer/stringer.go
new file mode 100644
index 0000000000000000000000000000000000000000..8eafcdcf4f2a33ce089e661e699a05e18edcd113
--- /dev/null
+++ b/vendor/github.com/clipperhouse/stringer/stringer.go
@@ -0,0 +1,569 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Stringer is a tool to automate the creation of methods that satisfy the fmt.Stringer
+// interface. Given the name of a (signed or unsigned) integer type T that has constants
+// defined, stringer will create a new self-contained Go source file implementing
+//	func (t T) String() string
+// The file is created in the same package and directory as the package that defines T.
+// It has helpful defaults designed for use with go generate.
+//
+// Stringer works best with constants that are consecutive values such as created using iota,
+// but creates good code regardless. In the future it might also provide custom support for
+// constant sets that are bit patterns.
+//
+// For example, given this snippet,
+//
+//	package painkiller
+//
+//	type Pill int
+//
+//	const (
+//		Placebo Pill = iota
+//		Aspirin
+//		Ibuprofen
+//		Paracetamol
+//		Acetaminophen = Paracetamol
+//	)
+//
+// running this command
+//
+//	stringer -type=Pill
+//
+// in the same directory will create the file pill_string.go, in package painkiller,
+// containing a definition of
+//
+//	func (Pill) String() string
+//
+// That method will translate the value of a Pill constant to the string representation
+// of the respective constant name, so that the call fmt.Print(painkiller.Aspirin) will
+// print the string "Aspirin".
+//
+// Typically this process would be run using go generate, like this:
+//
+//	//go:generate stringer -type=Pill
+//
+// If multiple constants have the same value, the lexically first matching name will
+// be used (in the example, Acetaminophen will print as "Paracetamol").
+//
+// With no arguments, it processes the package in the current directory.
+// Otherwise, the arguments must name a single directory holding a Go package
+// or a set of Go source files that represent a single Go package.
+//
+// The -type flag accepts a comma-separated list of types so a single run can
+// generate methods for multiple types. The default output file is t_string.go,
+// where t is the lower-cased name of the first type listed. It can be overridden
+// with the -output flag.
+//
+package stringer
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/constant"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"log"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	_ "golang.org/x/tools/go/gcimporter15"
+)
+
+// Generator holds the state of the analysis. Primarily used to buffer
+// the output for format.Source.
+type Generator struct {
+	buf bytes.Buffer // Accumulated output.
+	pkg *Package     // Package we are scanning.
+}
+
+func (g *Generator) Printf(format string, args ...interface{}) {
+	fmt.Fprintf(&g.buf, format, args...)
+}
+
+// File holds a single parsed file and associated data.
+type File struct {
+	pkg  *Package  // Package to which this file belongs.
+	file *ast.File // Parsed AST.
+	// These fields are reset for each type being generated.
+	typeName string  // Name of the constant type.
+	values   []Value // Accumulator for constant values of that type.
+}
+
+type Package struct {
+	dir      string
+	name     string
+	defs     map[*ast.Ident]types.Object
+	files    []*File
+	typesPkg *types.Package
+}
+
+// parsePackageDir parses the package residing in the directory.
+func (g *Generator) parsePackageDir(directory string) error {
+	pkg, err := build.Default.ImportDir(directory, 0)
+	if err != nil {
+		return err
+	}
+	var names []string
+	names = append(names, pkg.GoFiles...)
+	names = append(names, pkg.CgoFiles...)
+	names = append(names, pkg.TestGoFiles...)
+	names = append(names, pkg.SFiles...)
+	names = prefixDirectory(directory, names)
+	return g.parsePackage(directory, names, nil)
+}
+
+// parsePackageFiles parses the package occupying the named files.
+func (g *Generator) parsePackageFiles(names []string) error {
+	return g.parsePackage(".", names, nil)
+}
+
+// prefixDirectory places the directory name on the beginning of each name in the list.
+func prefixDirectory(directory string, names []string) []string {
+	if directory == "." {
+		return names
+	}
+	ret := make([]string, len(names))
+	for i, name := range names {
+		ret[i] = filepath.Join(directory, name)
+	}
+	return ret
+}
+
+// parsePackage analyzes the single package constructed from the named files.
+// If text is non-nil, it is a string to be used instead of the content of the file,
+// to be used for testing. parsePackage exits if there is an error.
+func (g *Generator) parsePackage(directory string, names []string, text interface{}) error {
+	var files []*File
+	var astFiles []*ast.File
+	g.pkg = new(Package)
+	fs := token.NewFileSet()
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".go") {
+			continue
+		}
+		parsedFile, err := parser.ParseFile(fs, name, text, 0)
+		if err != nil {
+			return err
+		}
+		astFiles = append(astFiles, parsedFile)
+		files = append(files, &File{
+			file: parsedFile,
+			pkg:  g.pkg,
+		})
+	}
+	if len(astFiles) == 0 {
+		return fmt.Errorf("%s: no buildable Go files", directory)
+	}
+
+	g.pkg.name = astFiles[0].Name.Name
+	g.pkg.files = files
+	g.pkg.dir = directory
+
+	// Type check the package.
+	return g.pkg.check(fs, astFiles)
+}
+
+// check type-checks the package. The package must be OK to proceed.
+func (pkg *Package) check(fs *token.FileSet, astFiles []*ast.File) error {
+	pkg.defs = make(map[*ast.Ident]types.Object)
+	config := types.Config{FakeImportC: true}
+	info := &types.Info{
+		Defs: pkg.defs,
+	}
+	typesPkg, err := config.Check(pkg.dir, fs, astFiles, info)
+	if err != nil {
+		return err
+	}
+	pkg.typesPkg = typesPkg
+	return nil
+}
+
+// generate produces the String method for the named type.
+func (g *Generator) generate(typeName string) error {
+	values := make([]Value, 0, 100)
+
+	for _, file := range g.pkg.files {
+		// Set the state for this run of the walker.
+		file.typeName = typeName
+		file.values = nil
+		if file.file != nil {
+			var err error
+			// a closure to get errors back out of genDecl,
+			// while maintaining the func signature that
+			// ast.Inspect requires
+			f := func(node ast.Node) bool {
+				b, e := file.genDecl(node)
+				if e != nil {
+					err = e
+				}
+				return b
+			}
+			ast.Inspect(file.file, f)
+			if err != nil {
+				return err
+			}
+			values = append(values, file.values...)
+		}
+	}
+
+	if len(values) == 0 {
+		return fmt.Errorf("no values defined for type %s", typeName)
+	}
+	runs := splitIntoRuns(values)
+	// The decision of which pattern to use depends on the number of
+	// runs in the numbers. If there's only one, it's easy. For more than
+	// one, there's a tradeoff between complexity and size of the data
+	// and code vs. the simplicity of a map. A map takes more space,
+	// but so does the code. The decision here (crossover at 10) is
+	// arbitrary, but considers that for large numbers of runs the cost
+	// of the linear scan in the switch might become important, and
+	// rather than use yet another algorithm such as binary search,
+	// we punt and use a map. In any case, the likelihood of a map
+	// being necessary for any realistic example other than bitmasks
+	// is very low. And bitmasks probably deserve their own analysis,
+	// to be done some other day.
+	switch {
+	case len(runs) == 1:
+		g.buildOneRun(runs, typeName)
+	case len(runs) <= 10:
+		g.buildMultipleRuns(runs, typeName)
+	default:
+		g.buildMap(runs, typeName)
+	}
+
+	return nil
+}
+
+// splitIntoRuns breaks the values into runs of contiguous sequences.
+// For example, given 1,2,3,5,6,7 it returns {1,2,3},{5,6,7}.
+// The input slice is known to be non-empty.
+func splitIntoRuns(values []Value) [][]Value {
+	// We use stable sort so the lexically first name is chosen for equal elements.
+	sort.Stable(byValue(values))
+	// Remove duplicates. Stable sort has put the one we want to print first,
+	// so use that one. The String method won't care about which named constant
+	// was the argument, so the first name for the given value is the only one to keep.
+	// We need to do this because identical values would cause the switch or map
+	// to fail to compile.
+	j := 1
+	for i := 1; i < len(values); i++ {
+		if values[i].value != values[i-1].value {
+			values[j] = values[i]
+			j++
+		}
+	}
+	values = values[:j]
+	runs := make([][]Value, 0, 10)
+	for len(values) > 0 {
+		// One contiguous sequence per outer loop.
+		i := 1
+		for i < len(values) && values[i].value == values[i-1].value+1 {
+			i++
+		}
+		runs = append(runs, values[:i])
+		values = values[i:]
+	}
+	return runs
+}
+
+// format returns the gofmt-ed contents of the Generator's buffer.
+func (g *Generator) format() []byte {
+	src, err := format.Source(g.buf.Bytes())
+	if err != nil {
+		// Should never happen, but can arise when developing this code.
+		// The user can compile the output to see the error.
+		log.Printf("warning: internal error: invalid Go generated: %s", err)
+		log.Printf("warning: compile the package to analyze the error")
+		return g.buf.Bytes()
+	}
+	return src
+}
+
+// Value represents a declared constant.
+type Value struct {
+	name string // The name of the constant.
+	// The value is stored as a bit pattern alone. The boolean tells us
+	// whether to interpret it as an int64 or a uint64; the only place
+	// this matters is when sorting.
+	// Much of the time the str field is all we need; it is printed
+	// by Value.String.
+	value  uint64 // Will be converted to int64 when needed.
+	signed bool   // Whether the constant is a signed type.
+	str    string // The string representation given by the "go/exact" package.
+}
+
+func (v *Value) String() string {
+	return v.str
+}
+
+// byValue lets us sort the constants into increasing order.
+// We take care in the Less method to sort in signed or unsigned order,
+// as appropriate.
+type byValue []Value
+
+func (b byValue) Len() int      { return len(b) }
+func (b byValue) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b byValue) Less(i, j int) bool {
+	if b[i].signed {
+		return int64(b[i].value) < int64(b[j].value)
+	}
+	return b[i].value < b[j].value
+}
+
+// genDecl processes one declaration clause.
+func (f *File) genDecl(node ast.Node) (bool, error) {
+	decl, ok := node.(*ast.GenDecl)
+	if !ok || decl.Tok != token.CONST {
+		// We only care about const declarations.
+		return true, nil
+	}
+	// The name of the type of the constants we are declaring.
+	// Can change if this is a multi-element declaration.
+	typ := ""
+	// Loop over the elements of the declaration. Each element is a ValueSpec:
+	// a list of names possibly followed by a type, possibly followed by values.
+	// If the type and value are both missing, we carry down the type (and value,
+	// but the "go/types" package takes care of that).
+	for _, spec := range decl.Specs {
+		vspec := spec.(*ast.ValueSpec) // Guaranteed to succeed as this is CONST.
+		if vspec.Type == nil && len(vspec.Values) > 0 {
+			// "X = 1". With no type but a value, the constant is untyped.
+			// Skip this vspec and reset the remembered type.
+			typ = ""
+			continue
+		}
+		if vspec.Type != nil {
+			// "X T". We have a type. Remember it.
+			ident, ok := vspec.Type.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			typ = ident.Name
+		}
+		if typ != f.typeName {
+			// This is not the type we're looking for.
+			continue
+		}
+		// We now have a list of names (from one line of source code) all being
+		// declared with the desired type.
+		// Grab their names and actual values and store them in f.values.
+		for _, name := range vspec.Names {
+			if name.Name == "_" {
+				continue
+			}
+			// This dance lets the type checker find the values for us. It's a
+			// bit tricky: look up the object declared by the name, find its
+			// types.Const, and extract its value.
+			obj, ok := f.pkg.defs[name]
+			if !ok {
+				return false, fmt.Errorf("no value for constant %s", name)
+			}
+			info := obj.Type().Underlying().(*types.Basic).Info()
+			if info&types.IsInteger == 0 {
+				return false, fmt.Errorf("can't handle non-integer constant type %s", typ)
+			}
+			value := obj.(*types.Const).Val() // Guaranteed to succeed as this is CONST.
+			if value.Kind() != constant.Int {
+				return false, fmt.Errorf("can't happen: constant is not an integer %s", name)
+			}
+			i64, isInt := constant.Int64Val(value)
+			u64, isUint := constant.Uint64Val(value)
+			if !isInt && !isUint {
+				return false, fmt.Errorf("internal error: value of %s is not an integer: %s", name, value.String())
+			}
+			if !isInt {
+				u64 = uint64(i64)
+			}
+			v := Value{
+				name:   name.Name,
+				value:  u64,
+				signed: info&types.IsUnsigned == 0,
+				str:    value.String(),
+			}
+			f.values = append(f.values, v)
+		}
+	}
+	return false, nil
+}
+
+// Helpers
+
+// usize returns the number of bits of the smallest unsigned integer
+// type that will hold n. Used to create the smallest possible slice of
+// integers to use as indexes into the concatenated strings.
+func usize(n int) int {
+	switch {
+	case n < 1<<8:
+		return 8
+	case n < 1<<16:
+		return 16
+	default:
+		// 2^32 is enough constants for anyone.
+		return 32
+	}
+}
+
+// declareIndexAndNameVars declares the index slices and concatenated names
+// strings representing the runs of values.
+func (g *Generator) declareIndexAndNameVars(runs [][]Value, typeName string) {
+	var indexes, names []string
+	for i, run := range runs {
+		index, name := g.createIndexAndNameDecl(run, typeName, fmt.Sprintf("_%d", i))
+		indexes = append(indexes, index)
+		names = append(names, name)
+	}
+	g.Printf("const (\n")
+	for _, name := range names {
+		g.Printf("\t%s\n", name)
+	}
+	g.Printf(")\n\n")
+	g.Printf("var (")
+	for _, index := range indexes {
+		g.Printf("\t%s\n", index)
+	}
+	g.Printf(")\n\n")
+}
+
+// declareIndexAndNameVar is the single-run version of declareIndexAndNameVars
+func (g *Generator) declareIndexAndNameVar(run []Value, typeName string) {
+	index, name := g.createIndexAndNameDecl(run, typeName, "")
+	g.Printf("const %s\n", name)
+	g.Printf("var %s\n", index)
+}
+
+// createIndexAndNameDecl returns the pair of declarations for the run. The caller will add "const" and "var".
+func (g *Generator) createIndexAndNameDecl(run []Value, typeName string, suffix string) (string, string) {
+	b := new(bytes.Buffer)
+	indexes := make([]int, len(run))
+	for i := range run {
+		b.WriteString(run[i].name)
+		indexes[i] = b.Len()
+	}
+	nameConst := fmt.Sprintf("_%s_name%s = %q", typeName, suffix, b.String())
+	nameLen := b.Len()
+	b.Reset()
+	fmt.Fprintf(b, "_%s_index%s = [...]uint%d{0, ", typeName, suffix, usize(nameLen))
+	for i, v := range indexes {
+		if i > 0 {
+			fmt.Fprintf(b, ", ")
+		}
+		fmt.Fprintf(b, "%d", v)
+	}
+	fmt.Fprintf(b, "}")
+	return b.String(), nameConst
+}
+
+// declareNameVars declares the concatenated names string representing all the values in the runs.
+func (g *Generator) declareNameVars(runs [][]Value, typeName string, suffix string) {
+	g.Printf("const _%s_name%s = \"", typeName, suffix)
+	for _, run := range runs {
+		for i := range run {
+			g.Printf("%s", run[i].name)
+		}
+	}
+	g.Printf("\"\n")
+}
+
+// buildOneRun generates the variables and String method for a single run of contiguous values.
+func (g *Generator) buildOneRun(runs [][]Value, typeName string) {
+	values := runs[0]
+	g.Printf("\n")
+	g.declareIndexAndNameVar(values, typeName)
+	// The generated code is simple enough to write as a Printf format.
+	lessThanZero := ""
+	if values[0].signed {
+		lessThanZero = "i < 0 || "
+	}
+	if values[0].value == 0 { // Signed or unsigned, 0 is still 0.
+		g.Printf(stringOneRun, typeName, usize(len(values)), lessThanZero)
+	} else {
+		g.Printf(stringOneRunWithOffset, typeName, values[0].String(), usize(len(values)), lessThanZero)
+	}
+}
+
+// Arguments to format are:
+//	[1]: type name
+//	[2]: size of index element (8 for uint8 etc.)
+//	[3]: less than zero check (for signed types)
+const stringOneRun = `func (i %[1]s) String() string {
+	if %[3]si+1 >= %[1]s(len(_%[1]s_index)) {
+		return fmt.Sprintf("%[1]s(%%d)", i)
+	}
+	return _%[1]s_name[_%[1]s_index[i]:_%[1]s_index[i+1]]
+}
+`
+
+// Arguments to format are:
+//	[1]: type name
+//	[2]: lowest defined value for type, as a string
+//	[3]: size of index element (8 for uint8 etc.)
+//	[4]: less than zero check (for signed types)
+/*
+ */
+const stringOneRunWithOffset = `func (i %[1]s) String() string {
+	i -= %[2]s
+	if %[4]si+1 >= %[1]s(len(_%[1]s_index)) {
+		return fmt.Sprintf("%[1]s(%%d)", i + %[2]s)
+	}
+	return _%[1]s_name[_%[1]s_index[i] : _%[1]s_index[i+1]]
+}
+`
+
+// buildMultipleRuns generates the variables and String method for multiple runs of contiguous values.
+// For this pattern, a single Printf format won't do.
+func (g *Generator) buildMultipleRuns(runs [][]Value, typeName string) {
+	g.Printf("\n")
+	g.declareIndexAndNameVars(runs, typeName)
+	g.Printf("func (i %s) String() string {\n", typeName)
+	g.Printf("\tswitch {\n")
+	for i, values := range runs {
+		if len(values) == 1 {
+			g.Printf("\tcase i == %s:\n", &values[0])
+			g.Printf("\t\treturn _%s_name_%d\n", typeName, i)
+			continue
+		}
+		g.Printf("\tcase %s <= i && i <= %s:\n", &values[0], &values[len(values)-1])
+		if values[0].value != 0 {
+			g.Printf("\t\ti -= %s\n", &values[0])
+		}
+		g.Printf("\t\treturn _%s_name_%d[_%s_index_%d[i]:_%s_index_%d[i+1]]\n",
+			typeName, i, typeName, i, typeName, i)
+	}
+	g.Printf("\tdefault:\n")
+	g.Printf("\t\treturn fmt.Sprintf(\"%s(%%d)\", i)\n", typeName)
+	g.Printf("\t}\n")
+	g.Printf("}\n")
+}
+
+// buildMap handles the case where the space is so sparse a map is a reasonable fallback.
+// It's a rare situation but has simple code.
+func (g *Generator) buildMap(runs [][]Value, typeName string) {
+	g.Printf("\n")
+	g.declareNameVars(runs, typeName, "")
+	g.Printf("\nvar _%s_map = map[%s]string{\n", typeName, typeName)
+	n := 0
+	for _, values := range runs {
+		for _, value := range values {
+			g.Printf("\t%s: _%s_name[%d:%d],\n", &value, typeName, n, n+len(value.name))
+			n += len(value.name)
+		}
+	}
+	g.Printf("}\n\n")
+	g.Printf(stringMap, typeName)
+}
+
+// Argument to format is the type name.
+const stringMap = `func (i %[1]s) String() string {
+	if str, ok := _%[1]s_map[i]; ok {
+		return str
+	}
+	return fmt.Sprintf("%[1]s(%%d)", i)
+}
+`
diff --git a/vendor/github.com/clipperhouse/stringer/stringerwriter.go b/vendor/github.com/clipperhouse/stringer/stringerwriter.go
new file mode 100644
index 0000000000000000000000000000000000000000..b2815e48865568a930b631386df34c9dc06d3b92
--- /dev/null
+++ b/vendor/github.com/clipperhouse/stringer/stringerwriter.go
@@ -0,0 +1,47 @@
+package stringer
+
+import (
+	"io"
+
+	"github.com/clipperhouse/typewriter"
+)
+
+func init() {
+	typewriter.Register(&StringerWriter{})
+}
+
+type StringerWriter struct {
+	g Generator
+}
+
+func (sw *StringerWriter) Name() string {
+	return "stringer"
+}
+
+func (sw *StringerWriter) Imports(t typewriter.Type) []typewriter.ImportSpec {
+	return []typewriter.ImportSpec{
+		{Path: "fmt"},
+	}
+}
+
+func (sw *StringerWriter) Write(w io.Writer, t typewriter.Type) error {
+	_, found := t.FindTag(sw)
+
+	if !found {
+		return nil
+	}
+
+	if err := sw.g.parsePackageDir("./"); err != nil {
+		return err
+	}
+
+	if err := sw.g.generate(t.Name); err != nil {
+		return err
+	}
+
+	if _, err := io.Copy(w, &sw.g.buf); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/LICENSE b/vendor/github.com/clipperhouse/typewriter/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..c12290a0cfa26666baa2a720cccbd7f37f7c40e3
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/LICENSE
@@ -0,0 +1,89 @@
+Copyright (c) 2014 Matt Sherman. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Matt Sherman nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+Portions of this software are derived from Go source, under the following license:
+
+---
+
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Portions of this software are derived from https://github.com/deckarep/golang-set
+
+---
+
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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.
\ No newline at end of file
diff --git a/vendor/github.com/clipperhouse/typewriter/README.md b/vendor/github.com/clipperhouse/typewriter/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c81ab3e12cd7eef9098dc0f43ce90db4b950915
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/README.md
@@ -0,0 +1,25 @@
+##What’s this?
+
+Typewriter is a package to enable pluggable, type-driven codegen for Go. The envisioned use case is for generics-like functionality. This package forms the underpinning of [gen](https://github.com/clipperhouse/gen).
+
+Usage is analogous to how codecs work with Go’s [image](http://golang.org/pkg/image/) package, or database drivers in the [sql](http://golang.org/pkg/database/sql/) package.
+
+    import (
+        // main package
+    	“github.com/clipperhouse/typewriter”
+    	
+    	// any number of typewriters 
+    	_ “github.com/clipperhouse/set”
+    	_ “github.com/clipperhouse/linkedlist”
+    )
+    
+    func main() {
+    	app, err := typewriter.NewApp(”+gen”)
+    	if err != nil {
+    		panic(err)
+    	}
+    
+    	app.WriteAll()
+    }
+
+Individual typewriters register themselves to the “parent” package via their init() functions. Have a look at one of the above typewriters to get an idea.
diff --git a/vendor/github.com/clipperhouse/typewriter/_gen.go b/vendor/github.com/clipperhouse/typewriter/_gen.go
new file mode 100644
index 0000000000000000000000000000000000000000..a065e55470cafc6b264e1944218d1f5d815ef2d5
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/_gen.go
@@ -0,0 +1,7 @@
+package main
+
+import (
+	_ "github.com/clipperhouse/slice"
+	_ "github.com/clipperhouse/set"
+	_ "github.com/clipperhouse/stringer"
+)
diff --git a/vendor/github.com/clipperhouse/typewriter/app.go b/vendor/github.com/clipperhouse/typewriter/app.go
new file mode 100644
index 0000000000000000000000000000000000000000..41d0958b48fcab9dbb32b8098af625cf9bcdaa7f
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/app.go
@@ -0,0 +1,195 @@
+package typewriter
+
+import (
+	"bytes"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+
+	"golang.org/x/tools/imports"
+)
+
+// App is the high-level construct for package-level code generation. Typical usage is along the lines of:
+//	app, err := typewriter.NewApp()
+//	err := app.WriteAll()
+//
+// +test foo:"Bar" baz:"qux[struct{}],thing"
+type App struct {
+	// All typewriter.Package found in the current directory.
+	Packages []*Package
+	// All typewriter.Interface's registered on init.
+	TypeWriters []Interface
+	Directive   string
+}
+
+// NewApp parses the current directory, enumerating registered TypeWriters and collecting Types and their related information.
+func NewApp(directive string) (*App, error) {
+	return DefaultConfig.NewApp(directive)
+}
+
+func (conf *Config) NewApp(directive string) (*App, error) {
+	a := &App{
+		Directive:   directive,
+		TypeWriters: typeWriters,
+	}
+
+	pkgs, err := getPackages(directive, conf)
+
+	a.Packages = pkgs
+	return a, err
+}
+
+// NewAppFiltered parses the current directory, collecting Types and their related information. Pass a filter to limit which files are operated on.
+func NewAppFiltered(directive string, filter func(os.FileInfo) bool) (*App, error) {
+	conf := &Config{
+		Filter: filter,
+	}
+	return conf.NewApp(directive)
+}
+
+// Individual TypeWriters register on init, keyed by name
+var typeWriters []Interface
+
+// Register allows template packages to make themselves known to a 'parent' package, usually in the init() func.
+// Comparable to the approach taken by stdlib's image package for registration of image types (eg image/png).
+// Your program will do something like:
+//	import (
+//		"github.com/clipperhouse/typewriter"
+//		_ "github.com/clipperhouse/slice"
+//	)
+func Register(tw Interface) error {
+	for _, v := range typeWriters {
+		if v.Name() == tw.Name() {
+			return fmt.Errorf("A TypeWriter by the name %s has already been registered", tw.Name())
+		}
+	}
+	typeWriters = append(typeWriters, tw)
+	return nil
+}
+
+// WriteAll writes the generated code for all Types and TypeWriters in the App to respective files.
+func (a *App) WriteAll() ([]string, error) {
+	var written []string
+
+	// one buffer for each file, keyed by file name
+	buffers := make(map[string]*bytes.Buffer)
+
+	// write the generated code for each Type & TypeWriter into memory
+	for _, p := range a.Packages {
+		for _, t := range p.Types {
+			for _, tw := range a.TypeWriters {
+				var b bytes.Buffer
+				n, err := write(&b, a, p, t, tw)
+
+				if err != nil {
+					return written, err
+				}
+
+				// don't generate a file if no bytes were written by WriteHeader or WriteBody
+				if n == 0 {
+					continue
+				}
+
+				// append _test to file name if the source type is in a _test.go file
+				f := strings.ToLower(fmt.Sprintf("%s_%s%s.go", t.Name, tw.Name(), t.test))
+
+				buffers[f] = &b
+			}
+		}
+	}
+
+	// validate generated ast's before committing to files
+	for f, b := range buffers {
+		if _, err := parser.ParseFile(token.NewFileSet(), f, b.String(), 0); err != nil {
+			// TODO: prompt to write (ignored) _file on error? parsing errors are meaningless without.
+			return written, err
+		}
+	}
+
+	// format, remove unused imports, and commit to files
+	for f, b := range buffers {
+		src, err := imports.Process(f, b.Bytes(), nil)
+
+		// shouldn't be an error if the ast parsing above succeeded
+		if err != nil {
+			return written, err
+		}
+
+		if err := writeFile(f, src); err != nil {
+			return written, err
+		}
+
+		written = append(written, f)
+	}
+
+	return written, nil
+}
+
+var twoLines = bytes.Repeat([]byte{'\n'}, 2)
+
+func write(w *bytes.Buffer, a *App, p *Package, t Type, tw Interface) (n int, err error) {
+	// start with byline at top, give future readers some background
+	// on where the file came from
+	bylineFmt := `// Generated by: %s
+// TypeWriter: %s
+// Directive: %s on %s`
+
+	caller := filepath.Base(os.Args[0])
+	byline := fmt.Sprintf(bylineFmt, caller, tw.Name(), a.Directive, t.String())
+	w.Write([]byte(byline))
+	w.Write(twoLines)
+
+	// add a package declaration
+	pkg := fmt.Sprintf("package %s", p.Name())
+	w.Write([]byte(pkg))
+	w.Write(twoLines)
+
+	if err := importsTmpl.Execute(w, tw.Imports(t)); err != nil {
+		return n, err
+	}
+
+	c := countingWriter{0, w}
+	err = tw.Write(&c, t)
+	n += c.n
+
+	return n, err
+}
+
+func writeFile(filename string, byts []byte) error {
+	w, err := os.Create(filename)
+
+	if err != nil {
+		return err
+	}
+
+	defer w.Close()
+
+	w.Write(byts)
+
+	return nil
+}
+
+var importsTmpl = template.Must(template.New("imports").Parse(`{{if gt (len .) 0}}
+import ({{range .}}
+	{{.Name}} "{{.Path}}"{{end}}
+)
+{{end}}
+`))
+
+// a writer that knows how much writing it did
+// https://groups.google.com/forum/#!topic/golang-nuts/VQLtfRGqK8Q
+type countingWriter struct {
+	n int
+	w io.Writer
+}
+
+func (c *countingWriter) Write(p []byte) (n int, err error) {
+	n, err = c.w.Write(p)
+	c.n += n
+	return
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/config.go b/vendor/github.com/clipperhouse/typewriter/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..970bb63d5dfeda2832adae9d14200766ad507889
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/config.go
@@ -0,0 +1,10 @@
+package typewriter
+
+import "os"
+
+type Config struct {
+	Filter                func(os.FileInfo) bool
+	IgnoreTypeCheckErrors bool
+}
+
+var DefaultConfig = &Config{}
diff --git a/vendor/github.com/clipperhouse/typewriter/constraint.go b/vendor/github.com/clipperhouse/typewriter/constraint.go
new file mode 100644
index 0000000000000000000000000000000000000000..0bfbd8209a7de9b3623ea34e04605425c97c0946
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/constraint.go
@@ -0,0 +1,29 @@
+package typewriter
+
+import "fmt"
+
+// Constraint describes type requirements.
+type Constraint struct {
+	// A numeric type is one that supports arithmetic operations.
+	Numeric bool
+	// A comparable type is one that supports the == operator. Map keys must be comparable, for example.
+	Comparable bool
+	// An ordered type is one where greater-than and less-than are supported
+	Ordered bool
+}
+
+func (c Constraint) TryType(t Type) error {
+	if c.Comparable && !t.comparable {
+		return fmt.Errorf("%s must be comparable (i.e. support == and !=)", t)
+	}
+
+	if c.Numeric && !t.numeric {
+		return fmt.Errorf("%s must be numeric", t)
+	}
+
+	if c.Ordered && !t.ordered {
+		return fmt.Errorf("%s must be ordered (i.e. support > and <)", t)
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/importspec.go b/vendor/github.com/clipperhouse/typewriter/importspec.go
new file mode 100644
index 0000000000000000000000000000000000000000..2a8729d655a542a304a840d6d22d5149234bc8fc
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/importspec.go
@@ -0,0 +1,9 @@
+package typewriter
+
+// ImportSpec describes the name and path of an import.
+// The name is often omitted.
+//
+// +gen set
+type ImportSpec struct {
+	Name, Path string
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/importspec_set.go b/vendor/github.com/clipperhouse/typewriter/importspec_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..e82746197109e6bfaeb082a71f721bcdb473c687
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/importspec_set.go
@@ -0,0 +1,172 @@
+// Generated by: main
+// TypeWriter: set
+// Directive: +gen on ImportSpec
+
+package typewriter
+
+// Set is a modification of https://github.com/deckarep/golang-set
+// The MIT License (MIT)
+// Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+// The primary type that represents a set
+type ImportSpecSet map[ImportSpec]struct{}
+
+// Creates and returns a reference to an empty set.
+func NewImportSpecSet(a ...ImportSpec) ImportSpecSet {
+	s := make(ImportSpecSet)
+	for _, i := range a {
+		s.Add(i)
+	}
+	return s
+}
+
+// ToSlice returns the elements of the current set as a slice
+func (set ImportSpecSet) ToSlice() []ImportSpec {
+	var s []ImportSpec
+	for v := range set {
+		s = append(s, v)
+	}
+	return s
+}
+
+// Adds an item to the current set if it doesn't already exist in the set.
+func (set ImportSpecSet) Add(i ImportSpec) bool {
+	_, found := set[i]
+	set[i] = struct{}{}
+	return !found //False if it existed already
+}
+
+// Determines if a given item is already in the set.
+func (set ImportSpecSet) Contains(i ImportSpec) bool {
+	_, found := set[i]
+	return found
+}
+
+// Determines if the given items are all in the set
+func (set ImportSpecSet) ContainsAll(i ...ImportSpec) bool {
+	for _, v := range i {
+		if !set.Contains(v) {
+			return false
+		}
+	}
+	return true
+}
+
+// Determines if every item in the other set is in this set.
+func (set ImportSpecSet) IsSubset(other ImportSpecSet) bool {
+	for elem := range set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+// Determines if every item of this set is in the other set.
+func (set ImportSpecSet) IsSuperset(other ImportSpecSet) bool {
+	return other.IsSubset(set)
+}
+
+// Returns a new set with all items in both sets.
+func (set ImportSpecSet) Union(other ImportSpecSet) ImportSpecSet {
+	unionedSet := NewImportSpecSet()
+
+	for elem := range set {
+		unionedSet.Add(elem)
+	}
+	for elem := range other {
+		unionedSet.Add(elem)
+	}
+	return unionedSet
+}
+
+// Returns a new set with items that exist only in both sets.
+func (set ImportSpecSet) Intersect(other ImportSpecSet) ImportSpecSet {
+	intersection := NewImportSpecSet()
+	// loop over smaller set
+	if set.Cardinality() < other.Cardinality() {
+		for elem := range set {
+			if other.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	} else {
+		for elem := range other {
+			if set.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	}
+	return intersection
+}
+
+// Returns a new set with items in the current set but not in the other set
+func (set ImportSpecSet) Difference(other ImportSpecSet) ImportSpecSet {
+	differencedSet := NewImportSpecSet()
+	for elem := range set {
+		if !other.Contains(elem) {
+			differencedSet.Add(elem)
+		}
+	}
+	return differencedSet
+}
+
+// Returns a new set with items in the current set or the other set but not in both.
+func (set ImportSpecSet) SymmetricDifference(other ImportSpecSet) ImportSpecSet {
+	aDiff := set.Difference(other)
+	bDiff := other.Difference(set)
+	return aDiff.Union(bDiff)
+}
+
+// Clears the entire set to be the empty set.
+func (set *ImportSpecSet) Clear() {
+	*set = make(ImportSpecSet)
+}
+
+// Allows the removal of a single item in the set.
+func (set ImportSpecSet) Remove(i ImportSpec) {
+	delete(set, i)
+}
+
+// Cardinality returns how many items are currently in the set.
+func (set ImportSpecSet) Cardinality() int {
+	return len(set)
+}
+
+// Iter() returns a channel of type ImportSpec that you can range over.
+func (set ImportSpecSet) Iter() <-chan ImportSpec {
+	ch := make(chan ImportSpec)
+	go func() {
+		for elem := range set {
+			ch <- elem
+		}
+		close(ch)
+	}()
+
+	return ch
+}
+
+// Equal determines if two sets are equal to each other.
+// If they both are the same size and have the same items they are considered equal.
+// Order of items is not relevent for sets to be equal.
+func (set ImportSpecSet) Equal(other ImportSpecSet) bool {
+	if set.Cardinality() != other.Cardinality() {
+		return false
+	}
+	for elem := range set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+// Returns a clone of the set.
+// Does NOT clone the underlying elements.
+func (set ImportSpecSet) Clone() ImportSpecSet {
+	clonedSet := NewImportSpecSet()
+	for elem := range set {
+		clonedSet.Add(elem)
+	}
+	return clonedSet
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/interface.go b/vendor/github.com/clipperhouse/typewriter/interface.go
new file mode 100644
index 0000000000000000000000000000000000000000..8e1d1ce7093fe51efea179f82dd5a18ddd57e122
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/interface.go
@@ -0,0 +1,19 @@
+// The typewriter package provides a framework for type-driven code generation. It implements the core functionality of gen.
+//
+// This package is primarily of interest to those who wish to extend gen with third-party functionality.
+//
+// More docs are available at https://clipperhouse.github.io/gen/typewriters.
+package typewriter
+
+import (
+	"io"
+)
+
+// Interface is the interface to be implemented for code generation via gen
+type Interface interface {
+	Name() string
+	// Imports is a slice of imports required for the type; each will be written into the imports declaration.
+	Imports(t Type) []ImportSpec
+	// Write writes to the body of the generated code, following package declaration and imports.
+	Write(w io.Writer, t Type) error
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/itemtype_stringer.go b/vendor/github.com/clipperhouse/typewriter/itemtype_stringer.go
new file mode 100644
index 0000000000000000000000000000000000000000..f76d65435d8b7fab4ff868ced04aa4d6ac235281
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/itemtype_stringer.go
@@ -0,0 +1,20 @@
+// Generated by: main
+// TypeWriter: stringer
+// Directive: +gen on itemType
+
+package typewriter
+
+import (
+	"fmt"
+)
+
+const _itemType_name = "itemErroritemCommentPrefixitemDirectiveitemPointeritemTagitemColonQuoteitemMinusitemTagValueitemTypeParameteritemCloseQuoteitemEOF"
+
+var _itemType_index = [...]uint8{0, 9, 26, 39, 50, 57, 71, 80, 92, 109, 123, 130}
+
+func (i itemType) String() string {
+	if i < 0 || i+1 >= itemType(len(_itemType_index)) {
+		return fmt.Sprintf("itemType(%d)", i)
+	}
+	return _itemType_name[_itemType_index[i]:_itemType_index[i+1]]
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/lex.go b/vendor/github.com/clipperhouse/typewriter/lex.go
new file mode 100644
index 0000000000000000000000000000000000000000..86543c7139642c068b6f554428a5379e98ed97ac
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/lex.go
@@ -0,0 +1,343 @@
+// Derived from http://golang.org/pkg/text/template/parse/
+
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typewriter
+
+import (
+	"fmt"
+	"go/token"
+	"unicode"
+	"unicode/utf8"
+)
+
+// item represents a token or text string returned from the scanner.
+type item struct {
+	typ itemType  // The type of this item.
+	pos token.Pos // The starting position, in bytes, of this item in the input string.
+	val string    // The value of this item.
+}
+
+// itemType identifies the type of lex items.
+// +gen stringer
+type itemType int
+
+const (
+	itemError itemType = iota // error occurred; value is text of error
+	itemCommentPrefix
+	itemDirective
+	itemPointer
+	itemTag
+	itemColonQuote
+	itemMinus
+	itemTagValue
+	itemTypeParameter
+	itemCloseQuote
+	itemEOF
+)
+
+const eof = -1
+
+// stateFn represents the state of the scanner as a function that returns the next state.
+type stateFn func(*lexer) stateFn
+
+// lexer holds the state of the scanner.
+type lexer struct {
+	input        string    // the string being scanned
+	state        stateFn   // the next lexing function to enter
+	pos          token.Pos // current position in the input
+	start        token.Pos // start position of this item
+	width        int       // width of last rune read from input
+	lastPos      token.Pos // position of most recent item returned by nextItem
+	items        chan item // channel of scanned items
+	bracketDepth int
+}
+
+// next returns the next rune in the input.
+func (l *lexer) next() rune {
+	if int(l.pos) >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
+	l.width = w
+	l.pos += token.Pos(l.width)
+	return r
+}
+
+// peek returns but does not consume the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per call of next.
+func (l *lexer) backup() {
+	l.pos -= token.Pos(l.width)
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items <- item{t, l.start, l.input[l.start:l.pos]}
+	l.start = l.pos
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// errorf returns an error token and terminates the scan by passing
+// back a nil pointer that will be the next state, terminating l.nextItem.
+func (l *lexer) errorf(format string, args ...interface{}) stateFn {
+	l.items <- item{itemError, l.pos, fmt.Sprintf(format, args...)}
+	return nil
+}
+
+// nextItem returns the next item from the input.
+func (l *lexer) nextItem() item {
+	item := <-l.items
+	l.lastPos = item.pos
+	return item
+}
+
+// lex creates a new scanner for the input string.
+func lex(input string) *lexer {
+	l := &lexer{
+		input: input,
+		items: make(chan item),
+	}
+	go l.run()
+	return l
+}
+
+// run runs the state machine for the lexer.
+func (l *lexer) run() {
+	for l.state = lexComment; l.state != nil; {
+		l.state = l.state(l)
+	}
+}
+
+// state functions
+
+func lexComment(l *lexer) stateFn {
+Loop:
+	for {
+		switch r := l.next(); {
+		case r == eof:
+			break Loop
+		case r == '/':
+			return lexCommentPrefix
+		case r == '+':
+			return lexDirective
+		case isSpace(r):
+			l.ignore()
+		case r == '*':
+			l.emit(itemPointer)
+			p := l.peek()
+			if !isSpace(p) && p != eof {
+				return l.errorf("pointer must be followed by a space or EOL")
+			}
+		case isIdentifierPrefix(r):
+			l.backup()
+			return lexTag
+		default:
+			return l.errorf("illegal leading character '%s' in tag name", string(r))
+		}
+	}
+	l.emit(itemEOF)
+	return nil
+}
+
+// lexTag scans the elements inside quotes
+func lexTag(l *lexer) stateFn {
+	for {
+		switch r := l.next(); {
+		case isIdentifierPrefix(r):
+			l.backup()
+			return lexIdentifier(l, itemTag)
+		case r == ':':
+			if n := l.next(); n != '"' {
+				return l.errorf(`expected " following :, got %q`, n)
+			}
+			l.emit(itemColonQuote)
+			return lexTagValues
+		case isSpace(r) || r == eof:
+			l.backup()
+			return lexComment
+		default:
+			return l.errorf("illegal character '%s' in tag name", string(r))
+		}
+	}
+}
+
+func lexTagValues(l *lexer) stateFn {
+	for {
+		switch r := l.next(); {
+		case r == '-':
+			l.emit(itemMinus)
+		case isIdentifierPrefix(r):
+			return lexIdentifier(l, itemTagValue)
+		case r == '[':
+			l.bracketDepth++
+			// parser has no use for bracket, only important as delimiter here
+			l.ignore()
+			return lexTypeParameters
+		case isSpace(r) || r == ',':
+			// parser has no use for comma, only important as delimiter here
+			l.ignore()
+		case r == '"':
+			// we're done
+			l.emit(itemCloseQuote)
+			return lexComment
+		case r == eof:
+			// we fell off the end without a close quote
+			return lexComment
+		default:
+			return l.errorf("illegal character '%s' in tag value", string(r))
+		}
+	}
+}
+
+func lexTypeParameters(l *lexer) stateFn {
+	for {
+		switch r := l.next(); {
+		case r == ']':
+			if l.bracketDepth == 0 {
+				// closing bracket of type parameter
+				return lexTagValues
+			}
+			return l.errorf("additional close bracket")
+		case isTypeDecl(r):
+			l.backup()
+			return lexTypeDeclaration
+		case isSpace(r) || r == ',':
+			l.ignore()
+		case r == '"':
+			// premature end
+			return l.errorf("expected close bracket")
+		default:
+			return l.errorf("illegal character '%s' in type parameter", string(r))
+		}
+	}
+}
+
+func lexTypeDeclaration(l *lexer) stateFn {
+Loop:
+	for {
+		switch r := l.next(); {
+		case r == ']':
+			l.bracketDepth--
+			if l.bracketDepth == 0 {
+				// closing bracket of type parameter
+				break Loop
+			}
+			// if bracket depth remains > 0, it's part of the type declaration eg []string
+			// absorb
+		case isTypeDecl(r):
+			// absorb
+			if r == '[' {
+				l.bracketDepth++
+			}
+		case isSpace(r) || r == ',':
+			// legal delimiters for multiple type parameters
+			break Loop
+		case r == '"':
+			// premature closing quote
+			break Loop
+		default:
+			// anything else is illegal
+			return l.errorf("illegal character '%c' in type declaration", r)
+		}
+	}
+
+	// once we get here, we've absorbed the delimiter; backup as not to emit it
+	l.backup()
+	l.emit(itemTypeParameter)
+	return lexTypeParameters
+}
+
+func lexCommentPrefix(l *lexer) stateFn {
+	for l.peek() == '/' {
+		l.next()
+	}
+	l.emit(itemCommentPrefix)
+	return lexComment
+}
+
+func lexDirective(l *lexer) stateFn {
+	for isAlphaNumeric(l.peek()) {
+		l.next()
+	}
+	l.emit(itemDirective)
+	return lexComment
+}
+
+// lexIdentifier scans an alphanumeric.
+func lexIdentifier(l *lexer, typ itemType) stateFn {
+Loop:
+	for {
+		switch r := l.next(); {
+		case isAlphaNumeric(r):
+			// absorb.
+		default:
+			if !isTerminator(r) {
+				return l.errorf("illegal character '%c' in identifier", r)
+			}
+			break Loop
+		}
+	}
+
+	// once we get here, we've absorbed the delimiter; backup as not to emit it
+	l.backup()
+	l.emit(typ)
+
+	switch typ {
+	case itemTag:
+		return lexTag
+	case itemTagValue:
+		return lexTagValues
+	default:
+		return l.errorf("unknown itemType %v", typ)
+	}
+}
+
+func isTerminator(r rune) bool {
+	if isSpace(r) || isEndOfLine(r) {
+		return true
+	}
+	switch r {
+	case eof, ':', ',', '"', '[', ']':
+		return true
+	}
+	return false
+}
+
+// isSpace reports whether r is a space character.
+func isSpace(r rune) bool {
+	return r == ' ' || r == '\t'
+}
+
+// isEndOfLine reports whether r is an end-of-line character.
+func isEndOfLine(r rune) bool {
+	return r == '\r' || r == '\n'
+}
+
+// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
+func isAlphaNumeric(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+// isIdentifierPrefix reports whether r is an alphabetic or underscore, per http://golang.org/ref/spec#Identifiers
+func isIdentifierPrefix(r rune) bool {
+	return r == '_' || unicode.IsLetter(r)
+}
+
+// isTypeDecl reports whether r a character legal in a type declaration, eg map[*Thing]interface{}
+// brackets are a special case, handled in lexTypeParameter
+func isTypeDecl(r rune) bool {
+	return r == '*' || r == '{' || r == '}' || r == '[' || r == ']' || isAlphaNumeric(r)
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/package.go b/vendor/github.com/clipperhouse/typewriter/package.go
new file mode 100644
index 0000000000000000000000000000000000000000..99818946f3100cd0324463798e1c8111310684cf
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/package.go
@@ -0,0 +1,121 @@
+package typewriter
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strings"
+
+	// gcimporter implements Import for gc-generated files
+	"go/importer"
+	"go/types"
+)
+
+type evaluator interface {
+	Eval(string) (Type, error)
+}
+
+func NewPackage(path, name string) *Package {
+	return &Package{
+		types.NewPackage(path, name),
+		token.NewFileSet(),
+		[]Type{},
+	}
+}
+
+type Package struct {
+	*types.Package
+	fset  *token.FileSet
+	Types []Type
+}
+
+type TypeCheckError struct {
+	err     error
+	ignored bool
+}
+
+func (t *TypeCheckError) Error() string {
+	var result string
+	if t.ignored {
+		result += "[ignored] "
+	}
+	return result + t.err.Error()
+}
+
+func (t *TypeCheckError) addPos(fset *token.FileSet, pos token.Pos) {
+	// some errors come with empty pos
+	err := strings.TrimLeft(t.err.Error(), ":- ")
+	// prepend position information (file name, line, column)
+	t.err = fmt.Errorf("%s: %s", fset.Position(pos), err)
+}
+
+func combine(ts []*TypeCheckError) error {
+	if len(ts) == 0 {
+		return nil
+	}
+
+	var errs []string
+	for _, t := range ts {
+		errs = append(errs, t.Error())
+	}
+	return fmt.Errorf(strings.Join(errs, "\n"))
+}
+
+func getPackage(fset *token.FileSet, a *ast.Package, conf *Config) (*Package, *TypeCheckError) {
+	// pull map into a slice
+	var files []*ast.File
+	for _, f := range a.Files {
+		files = append(files, f)
+	}
+
+	config := types.Config{
+		DisableUnusedImportCheck: true,
+		IgnoreFuncBodies:         true,
+		Importer:                 importer.Default(),
+	}
+
+	if conf.IgnoreTypeCheckErrors {
+		// no-op allows type checking to proceed in presence of errors
+		// https://godoc.org/golang.org/x/tools/go/types#Config
+		config.Error = func(err error) {}
+	}
+
+	typesPkg, err := config.Check(a.Name, fset, files, nil)
+
+	p := &Package{typesPkg, fset, []Type{}}
+
+	if err != nil {
+		return p, &TypeCheckError{err, conf.IgnoreTypeCheckErrors}
+	}
+
+	return p, nil
+}
+
+func (p *Package) Eval(name string) (Type, error) {
+	var result Type
+
+	t, err := types.Eval(p.fset, p.Package, token.NoPos, name)
+	if err != nil {
+		return result, err
+	}
+	if t.Type == nil {
+		err := fmt.Errorf("invalid type: %s", name)
+		return result, &TypeCheckError{err, false}
+	}
+
+	result = Type{
+		Pointer:    isPointer(t.Type),
+		Name:       strings.TrimLeft(name, Pointer(true).String()), // trims the * if it exists
+		comparable: isComparable(t.Type),
+		numeric:    isNumeric(t.Type),
+		ordered:    isOrdered(t.Type),
+		Type:       t.Type,
+	}
+
+	if isInvalid(t.Type) {
+		err := fmt.Errorf("invalid type: %s", name)
+		return result, &TypeCheckError{err, false}
+	}
+
+	return result, nil
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/parse.go b/vendor/github.com/clipperhouse/typewriter/parse.go
new file mode 100644
index 0000000000000000000000000000000000000000..189adbc12fed42e99efd1da31463996cd2717528
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/parse.go
@@ -0,0 +1,380 @@
+package typewriter
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+)
+
+// unlike the go build tool, the parser does not ignore . and _ files
+var ignored = func(f os.FileInfo) bool {
+	return !strings.HasPrefix(f.Name(), "_") && !strings.HasPrefix(f.Name(), ".")
+}
+
+func getPackages(directive string, conf *Config) ([]*Package, error) {
+	// wrap filter with default filter
+	filt := func(f os.FileInfo) bool {
+		if conf.Filter != nil {
+			return ignored(f) && conf.Filter(f)
+		}
+		return ignored(f)
+	}
+
+	// get the AST
+	fset := token.NewFileSet()
+	astPkgs, err := parser.ParseDir(fset, "./", filt, parser.ParseComments)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var pkgs []*Package
+	var typeCheckErrors []*TypeCheckError
+
+	for _, a := range astPkgs {
+		pkg, err := getPackage(fset, a, conf)
+
+		if err != nil {
+			err.ignored = conf.IgnoreTypeCheckErrors
+			typeCheckErrors = append(typeCheckErrors, err)
+
+			// if we have type check errors, and are not ignoring them, bail
+			if err := combine(typeCheckErrors); err != nil && !conf.IgnoreTypeCheckErrors {
+				return pkgs, err
+			}
+		}
+
+		pkgs = append(pkgs, pkg)
+
+		specs := getTaggedComments(a, directive)
+
+		for s, c := range specs {
+			pointer, tags, err := parse(fset, c, directive)
+
+			if err != nil {
+				return nil, err
+			}
+
+			// evaluate the annotated type
+			typ, evalErr := pkg.Eval(pointer.String() + s.Name.Name)
+
+			if evalErr != nil {
+				// if we're not ignoring, can return immediately, normal behavior
+				if !conf.IgnoreTypeCheckErrors {
+					return pkgs, evalErr
+				}
+
+				// is it a TypeCheckError?
+				tc, isTypeCheckError := evalErr.(*TypeCheckError)
+
+				// if not a TypeCheckError, can return immediately, normal behavior
+				if !isTypeCheckError {
+					return pkgs, evalErr
+				}
+
+				tc.ignored = conf.IgnoreTypeCheckErrors
+				tc.addPos(fset, s.Pos())
+
+				typeCheckErrors = append(typeCheckErrors, tc)
+			}
+
+			// evaluate type parameters
+			for _, tag := range tags {
+				for i, val := range tag.Values {
+					for _, item := range val.typeParameters {
+						tp, evalErr := pkg.Eval(item.val)
+
+						if evalErr != nil {
+							// if we're not ignoring, can return immediately, normal behavior
+							if !conf.IgnoreTypeCheckErrors {
+								return pkgs, evalErr
+							}
+
+							// is it a TypeCheckError?
+							tc, isTypeCheckError := evalErr.(*TypeCheckError)
+
+							// if not a TypeCheckError, can return immediately, normal behavior
+							if !isTypeCheckError {
+								return pkgs, evalErr
+							}
+
+							tc.ignored = conf.IgnoreTypeCheckErrors
+							tc.addPos(fset, item.pos+c.Slash)
+
+							typeCheckErrors = append(typeCheckErrors, tc)
+						}
+
+						val.TypeParameters = append(val.TypeParameters, tp)
+					}
+					tag.Values[i] = val // mutate the original
+				}
+				typ.Tags = append(typ.Tags, tag)
+			}
+
+			typ.test = test(strings.HasSuffix(fset.Position(s.Pos()).Filename, "_test.go"))
+
+			pkg.Types = append(pkg.Types, typ)
+		}
+	}
+
+	// if we have type check errors, but are ignoring them, output as FYI
+	if err := combine(typeCheckErrors); err != nil && conf.IgnoreTypeCheckErrors {
+		fmt.Println(err)
+	}
+
+	return pkgs, nil
+}
+
+// getTaggedComments walks the AST and returns types which have directive comment
+// returns a map of TypeSpec to directive
+func getTaggedComments(pkg *ast.Package, directive string) map[*ast.TypeSpec]*ast.Comment {
+	specs := make(map[*ast.TypeSpec]*ast.Comment)
+
+	ast.Inspect(pkg, func(n ast.Node) bool {
+		g, ok := n.(*ast.GenDecl)
+
+		// is it a type?
+		// http://golang.org/pkg/go/ast/#GenDecl
+		if !ok || g.Tok != token.TYPE {
+			// never mind, move on
+			return true
+		}
+
+		if g.Lparen == 0 {
+			// not parenthesized, copy GenDecl.Doc into TypeSpec.Doc
+			g.Specs[0].(*ast.TypeSpec).Doc = g.Doc
+		}
+
+		for _, s := range g.Specs {
+			t := s.(*ast.TypeSpec)
+
+			if c := findAnnotation(t.Doc, directive); c != nil {
+				specs[t] = c
+			}
+		}
+
+		// no need to keep walking, we don't care about TypeSpec's children
+		return false
+	})
+
+	return specs
+}
+
+// findDirective return the first line of a doc which contains a directive
+// the directive and '//' are removed
+func findAnnotation(doc *ast.CommentGroup, directive string) *ast.Comment {
+	if doc == nil {
+		return nil
+	}
+
+	// check lines of doc for directive
+	for _, c := range doc.List {
+		l := c.Text
+		// does the line start with the directive?
+		t := strings.TrimLeft(l, "/ ")
+		if !strings.HasPrefix(t, directive) {
+			continue
+		}
+
+		// remove the directive from the line
+		t = strings.TrimPrefix(t, directive)
+
+		// must be eof or followed by a space
+		if len(t) > 0 && t[0] != ' ' {
+			continue
+		}
+
+		return c
+	}
+
+	return nil
+}
+
+type parsr struct {
+	lex       *lexer
+	token     [2]item // two-token lookahead for parser.
+	peekCount int
+	fset      *token.FileSet
+	offset    token.Pos
+}
+
+// next returns the next token.
+func (p *parsr) next() item {
+	if p.peekCount > 0 {
+		p.peekCount--
+	} else {
+		p.token[0] = p.lex.nextItem()
+	}
+	return p.token[p.peekCount]
+}
+
+// backup backs the input stream up one token.
+func (p *parsr) backup() {
+	p.peekCount++
+}
+
+// peek returns but does not consume the next token.
+func (p *parsr) peek() item {
+	if p.peekCount > 0 {
+		return p.token[p.peekCount-1]
+	}
+	p.peekCount = 1
+	p.token[0] = p.lex.nextItem()
+	return p.token[0]
+}
+
+func (p *parsr) errorf(item item, format string, args ...interface{}) error {
+	// some errors come with empty pos
+	format = strings.TrimLeft(format, ":- ")
+	// prepend position information (file name, line, column)
+	format = fmt.Sprintf("%s: %s", p.fset.Position(item.pos+p.offset), format)
+	return fmt.Errorf(format, args...)
+}
+
+func (p *parsr) unexpected(item item) error {
+	return p.errorf(item, "unexpected '%v'", item.val)
+}
+
+func parse(fset *token.FileSet, comment *ast.Comment, directive string) (Pointer, TagSlice, error) {
+	var pointer Pointer
+	var tags TagSlice
+	p := &parsr{
+		lex:    lex(comment.Text),
+		fset:   fset,
+		offset: comment.Slash,
+	}
+
+	// to ensure no duplicate tags
+	exists := make(map[string]struct{})
+
+Loop:
+	for {
+		item := p.next()
+		switch item.typ {
+		case itemEOF:
+			break Loop
+		case itemError:
+			err := p.errorf(item, item.val)
+			return false, nil, err
+		case itemCommentPrefix:
+			// don't care, move on
+			continue
+		case itemDirective:
+			// is it the directive we care about?
+			if item.val != directive {
+				return false, nil, nil
+			}
+			continue
+		case itemPointer:
+			// have we already seen a pointer?
+			if pointer {
+				err := p.errorf(item, "second pointer declaration")
+				return false, nil, err
+			}
+
+			// have we already seen tags? pointer must be first
+			if len(tags) > 0 {
+				err := p.errorf(item, "pointer declaration must precede tags")
+				return false, nil, err
+			}
+
+			pointer = true
+		case itemTag:
+			// we have an identifier, start a tag
+			tag := Tag{
+				Name: item.val,
+			}
+
+			// check for duplicate
+			if _, seen := exists[tag.Name]; seen {
+				err := p.errorf(item, "duplicate tag %q", tag.Name)
+				return pointer, nil, err
+			}
+
+			// mark tag as previously seen
+			exists[tag.Name] = struct{}{}
+
+			// tag has values
+			if p.peek().typ == itemColonQuote {
+				p.next() // absorb the colonQuote
+				negated, vals, err := parseTagValues(p)
+
+				if err != nil {
+					return false, nil, err
+				}
+
+				tag.Negated = negated
+				tag.Values = vals
+			}
+
+			tags = append(tags, tag)
+		default:
+			return false, nil, p.unexpected(item)
+		}
+	}
+
+	return pointer, tags, nil
+}
+
+func parseTagValues(p *parsr) (bool, []TagValue, error) {
+	var negated bool
+	var vals []TagValue
+
+	for {
+		item := p.next()
+
+		switch item.typ {
+		case itemError:
+			err := p.errorf(item, item.val)
+			return false, nil, err
+		case itemEOF:
+			// shouldn't happen within a tag
+			err := p.errorf(item, "expected a close quote")
+			return false, nil, err
+		case itemMinus:
+			if len(vals) > 0 {
+				err := p.errorf(item, "negation must precede tag values")
+				return false, nil, err
+			}
+			negated = true
+		case itemTagValue:
+			val := TagValue{
+				Name: item.val,
+			}
+
+			if p.peek().typ == itemTypeParameter {
+				tokens, err := parseTypeParameters(p)
+				if err != nil {
+					return false, nil, err
+				}
+				val.typeParameters = tokens
+			}
+
+			vals = append(vals, val)
+		case itemCloseQuote:
+			// we're done
+			return negated, vals, nil
+		default:
+			return false, nil, p.unexpected(item)
+		}
+	}
+}
+
+func parseTypeParameters(p *parsr) ([]item, error) {
+	var result []item
+
+	for {
+		item := p.next()
+
+		switch item.typ {
+		case itemTypeParameter:
+			result = append(result, item)
+		default:
+			p.backup()
+			return result, nil
+		}
+	}
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/predicates.go b/vendor/github.com/clipperhouse/typewriter/predicates.go
new file mode 100644
index 0000000000000000000000000000000000000000..7c1551cdc755efeab64b15ae46c2d65634b19542
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/predicates.go
@@ -0,0 +1,37 @@
+// From: https://code.google.com/p/go/source/browse/go/types/predicates.go?repo=tools
+
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements commonly used type predicates.
+
+package typewriter
+
+import (
+	"go/types"
+)
+
+func isComparable(typ types.Type) bool {
+	return types.Comparable(typ)
+}
+
+func isNumeric(typ types.Type) bool {
+	t, ok := typ.Underlying().(*types.Basic)
+	return ok && t.Info()&types.IsNumeric != 0
+}
+
+func isOrdered(typ types.Type) bool {
+	t, ok := typ.Underlying().(*types.Basic)
+	return ok && t.Info()&types.IsOrdered != 0
+}
+
+func isInvalid(typ types.Type) bool {
+	t, ok := typ.Underlying().(*types.Basic)
+	return ok && t.Kind() == types.Invalid
+}
+
+func isPointer(typ types.Type) Pointer {
+	_, ok := typ.Underlying().(*types.Pointer)
+	return Pointer(ok)
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/tag.go b/vendor/github.com/clipperhouse/typewriter/tag.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fe85d9caaca218332bcc813e227bf7cf3e0e2b2
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/tag.go
@@ -0,0 +1,14 @@
+package typewriter
+
+// +gen slice
+type Tag struct {
+	Name    string
+	Values  []TagValue
+	Negated bool
+}
+
+type TagValue struct {
+	Name           string
+	TypeParameters []Type
+	typeParameters []item
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/tag_slice.go b/vendor/github.com/clipperhouse/typewriter/tag_slice.go
new file mode 100644
index 0000000000000000000000000000000000000000..57708b82ab5f50ab9bfeb421a320adeebfb73c4f
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/tag_slice.go
@@ -0,0 +1,8 @@
+// Generated by: main
+// TypeWriter: slice
+// Directive: +gen on Tag
+
+package typewriter
+
+// TagSlice is a slice of type Tag. Use it where you would use []Tag.
+type TagSlice []Tag
diff --git a/vendor/github.com/clipperhouse/typewriter/template.go b/vendor/github.com/clipperhouse/typewriter/template.go
new file mode 100644
index 0000000000000000000000000000000000000000..e1fe81f29c0ef9dc9f870a5b84fb171320d3246f
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/template.go
@@ -0,0 +1,101 @@
+package typewriter
+
+import (
+	"fmt"
+	"strings"
+
+	"text/template"
+)
+
+// Template includes the text of a template as well as requirements for the types to which it can be applied.
+// +gen * slice:"Where"
+type Template struct {
+	Name, Text     string
+	FuncMap        map[string]interface{}
+	TypeConstraint Constraint
+	// Indicates both the number of required type parameters, and the constraints of each (if any)
+	TypeParameterConstraints []Constraint
+}
+
+// Parse parses (converts) a typewriter.Template to a *template.Template
+func (tmpl *Template) Parse() (*template.Template, error) {
+	return template.New(tmpl.Name).Funcs(tmpl.FuncMap).Parse(tmpl.Text)
+}
+
+// TryTypeAndValue verifies that a given Type and TagValue satisfy a Template's type constraints.
+func (tmpl *Template) TryTypeAndValue(t Type, v TagValue) error {
+	if err := tmpl.TypeConstraint.TryType(t); err != nil {
+		return fmt.Errorf("cannot apply %s to %s: %s", v.Name, t, err)
+	}
+
+	if len(tmpl.TypeParameterConstraints) != len(v.TypeParameters) {
+		return fmt.Errorf("%s requires %d type parameters", v.Name, len(v.TypeParameters))
+	}
+
+	for i := range v.TypeParameters {
+		c := tmpl.TypeParameterConstraints[i]
+		tp := v.TypeParameters[i]
+		if err := c.TryType(tp); err != nil {
+			return fmt.Errorf("cannot apply %s on %s: %s", v, t, err)
+		}
+	}
+
+	return nil
+}
+
+// Funcs assigns non standard functions used in the template
+func (ts TemplateSlice) Funcs(FuncMap map[string]interface{}) {
+	for _, tmpl := range ts {
+		tmpl.FuncMap = FuncMap
+	}
+}
+
+// ByTag attempts to locate a template which meets type constraints, and parses it.
+func (ts TemplateSlice) ByTag(t Type, tag Tag) (*template.Template, error) {
+	// templates which might work
+	candidates := ts.Where(func(tmpl *Template) bool {
+		return strings.EqualFold(tmpl.Name, tag.Name)
+	})
+
+	if len(candidates) == 0 {
+		err := fmt.Errorf("could not find template for %q", tag.Name)
+		return nil, err
+	}
+
+	// try to find one that meets type constraints
+	for _, tmpl := range candidates {
+		if err := tmpl.TypeConstraint.TryType(t); err == nil {
+			// eagerly return on success
+			return tmpl.Parse()
+		}
+	}
+
+	// send back the first error message; not great but OK most of the time
+	return nil, candidates[0].TypeConstraint.TryType(t)
+}
+
+// ByTagValue attempts to locate a template which meets type constraints, and parses it.
+func (ts TemplateSlice) ByTagValue(t Type, v TagValue) (*template.Template, error) {
+	// a bit of poor-man's type resolution here
+
+	// templates which might work
+	candidates := ts.Where(func(tmpl *Template) bool {
+		return strings.EqualFold(tmpl.Name, v.Name)
+	})
+
+	if len(candidates) == 0 {
+		err := fmt.Errorf("%s is unknown", v.Name)
+		return nil, err
+	}
+
+	// try to find one that meets type constraints
+	for _, tmpl := range candidates {
+		if err := tmpl.TryTypeAndValue(t, v); err == nil {
+			// eagerly return on success
+			return tmpl.Parse()
+		}
+	}
+
+	// send back the first error message; not great but OK most of the time
+	return nil, candidates[0].TryTypeAndValue(t, v)
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/template_slice.go b/vendor/github.com/clipperhouse/typewriter/template_slice.go
new file mode 100644
index 0000000000000000000000000000000000000000..cf0a8a19855c9349ce828128132a2e46dd9aa89b
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/template_slice.go
@@ -0,0 +1,18 @@
+// Generated by: main
+// TypeWriter: slice
+// Directive: +gen on *Template
+
+package typewriter
+
+// TemplateSlice is a slice of type *Template. Use it where you would use []*Template.
+type TemplateSlice []*Template
+
+// Where returns a new TemplateSlice whose elements return true for func. See: http://clipperhouse.github.io/gen/#Where
+func (rcv TemplateSlice) Where(fn func(*Template) bool) (result TemplateSlice) {
+	for _, v := range rcv {
+		if fn(v) {
+			result = append(result, v)
+		}
+	}
+	return result
+}
diff --git a/vendor/github.com/clipperhouse/typewriter/test.bat b/vendor/github.com/clipperhouse/typewriter/test.bat
new file mode 100644
index 0000000000000000000000000000000000000000..c9f805a5beaca7992cdee8f6b1b32be64cab34a0
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/test.bat
@@ -0,0 +1,4 @@
+@echo off
+go get
+go test -coverprofile=coverage.out
+go tool cover -html=coverage.out
diff --git a/vendor/github.com/clipperhouse/typewriter/test.sh b/vendor/github.com/clipperhouse/typewriter/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..92912d7e770b141825798719fc2f3f48b9bd769a
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/test.sh
@@ -0,0 +1,4 @@
+go get
+touch coverage.out
+go test -coverprofile=coverage.out
+go tool cover -html=coverage.out
diff --git a/vendor/github.com/clipperhouse/typewriter/type.go b/vendor/github.com/clipperhouse/typewriter/type.go
new file mode 100644
index 0000000000000000000000000000000000000000..41c71802142ffb9a77457d8743d820bf9dd1fe78
--- /dev/null
+++ b/vendor/github.com/clipperhouse/typewriter/type.go
@@ -0,0 +1,68 @@
+package typewriter
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"go/types"
+)
+
+type Type struct {
+	Pointer                      Pointer
+	Name                         string
+	Tags                         TagSlice
+	comparable, numeric, ordered bool
+	test                         test
+	types.Type
+}
+
+type test bool
+
+// a convenience for using bool in file name, see WriteAll
+func (t test) String() string {
+	if t {
+		return "_test"
+	}
+	return ""
+}
+
+func (t Type) String() (result string) {
+	return fmt.Sprintf("%s%s", t.Pointer.String(), t.Name)
+}
+
+// LongName provides a name that may be useful for generated names.
+// For example, map[string]Foo becomes MapStringFoo.
+func (t Type) LongName() string {
+	s := strings.Replace(t.String(), "[]", "Slice[]", -1) // hacktastic
+
+	r := regexp.MustCompile(`[\[\]{}*]`)
+	els := r.Split(s, -1)
+
+	var parts []string
+
+	for _, s := range els {
+		parts = append(parts, strings.Title(s))
+	}
+
+	return strings.Join(parts, "")
+}
+
+func (t Type) FindTag(tw Interface) (Tag, bool) {
+	for _, tag := range t.Tags {
+		if tag.Name == tw.Name() {
+			return tag, true
+		}
+	}
+	return Tag{}, false
+}
+
+// Pointer exists as a type to allow simple use as bool or as String, which returns *
+type Pointer bool
+
+func (p Pointer) String() string {
+	if p {
+		return "*"
+	}
+	return ""
+}
diff --git a/vendor/github.com/fatih/color/LICENSE.md b/vendor/github.com/fatih/color/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..25fdaf639dfc039992d059805e51377d3174ae87
--- /dev/null
+++ b/vendor/github.com/fatih/color/LICENSE.md
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Fatih Arslan
+
+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/vendor/github.com/fatih/color/README.md b/vendor/github.com/fatih/color/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3fc9544602852e448530161fcd9c424a550fcae5
--- /dev/null
+++ b/vendor/github.com/fatih/color/README.md
@@ -0,0 +1,179 @@
+# Color [![GoDoc](https://godoc.org/github.com/fatih/color?status.svg)](https://godoc.org/github.com/fatih/color) [![Build Status](https://img.shields.io/travis/fatih/color.svg?style=flat-square)](https://travis-ci.org/fatih/color)
+
+
+
+Color lets you use colorized outputs in terms of [ANSI Escape
+Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It
+has support for Windows too! The API can be used in several ways, pick one that
+suits you.
+
+
+![Color](https://i.imgur.com/c1JI0lA.png)
+
+
+## Install
+
+```bash
+go get github.com/fatih/color
+```
+
+Note that the `vendor` folder is here for stability. Remove the folder if you
+already have the dependencies in your GOPATH.
+
+## Examples
+
+### Standard colors
+
+```go
+// Print with default helper functions
+color.Cyan("Prints text in cyan.")
+
+// A newline will be appended automatically
+color.Blue("Prints %s in blue.", "text")
+
+// These are using the default foreground colors
+color.Red("We have red")
+color.Magenta("And many others ..")
+
+```
+
+### Mix and reuse colors
+
+```go
+// Create a new color object
+c := color.New(color.FgCyan).Add(color.Underline)
+c.Println("Prints cyan text with an underline.")
+
+// Or just add them to New()
+d := color.New(color.FgCyan, color.Bold)
+d.Printf("This prints bold cyan %s\n", "too!.")
+
+// Mix up foreground and background colors, create new mixes!
+red := color.New(color.FgRed)
+
+boldRed := red.Add(color.Bold)
+boldRed.Println("This will print text in bold red.")
+
+whiteBackground := red.Add(color.BgWhite)
+whiteBackground.Println("Red text with white background.")
+```
+
+### Use your own output (io.Writer)
+
+```go
+// Use your own io.Writer output
+color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
+
+blue := color.New(color.FgBlue)
+blue.Fprint(writer, "This will print text in blue.")
+```
+
+### Custom print functions (PrintFunc)
+
+```go
+// Create a custom print function for convenience
+red := color.New(color.FgRed).PrintfFunc()
+red("Warning")
+red("Error: %s", err)
+
+// Mix up multiple attributes
+notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
+notice("Don't forget this...")
+```
+
+### Custom fprint functions (FprintFunc)
+
+```go
+blue := color.New(FgBlue).FprintfFunc()
+blue(myWriter, "important notice: %s", stars)
+
+// Mix up with multiple attributes
+success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
+success(myWriter, "Don't forget this...")
+```
+
+### Insert into noncolor strings (SprintFunc)
+
+```go
+// Create SprintXxx functions to mix strings with other non-colorized strings:
+yellow := color.New(color.FgYellow).SprintFunc()
+red := color.New(color.FgRed).SprintFunc()
+fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error"))
+
+info := color.New(color.FgWhite, color.BgGreen).SprintFunc()
+fmt.Printf("This %s rocks!\n", info("package"))
+
+// Use helper functions
+fmt.Println("This", color.RedString("warning"), "should be not neglected.")
+fmt.Printf("%v %v\n", color.GreenString("Info:"), "an important message.")
+
+// Windows supported too! Just don't forget to change the output to color.Output
+fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
+```
+
+### Plug into existing code
+
+```go
+// Use handy standard colors
+color.Set(color.FgYellow)
+
+fmt.Println("Existing text will now be in yellow")
+fmt.Printf("This one %s\n", "too")
+
+color.Unset() // Don't forget to unset
+
+// You can mix up parameters
+color.Set(color.FgMagenta, color.Bold)
+defer color.Unset() // Use it in your function
+
+fmt.Println("All text will now be bold magenta.")
+```
+
+### Disable/Enable color
+ 
+There might be a case where you want to explicitly disable/enable color output. the 
+`go-isatty` package will automatically disable color output for non-tty output streams 
+(for example if the output were piped directly to `less`)
+
+`Color` has support to disable/enable colors both globally and for single color 
+definitions. For example suppose you have a CLI app and a `--no-color` bool flag. You 
+can easily disable the color output with:
+
+```go
+
+var flagNoColor = flag.Bool("no-color", false, "Disable color output")
+
+if *flagNoColor {
+	color.NoColor = true // disables colorized output
+}
+```
+
+It also has support for single color definitions (local). You can
+disable/enable color output on the fly:
+
+```go
+c := color.New(color.FgCyan)
+c.Println("Prints cyan text")
+
+c.DisableColor()
+c.Println("This is printed without any color")
+
+c.EnableColor()
+c.Println("This prints again cyan...")
+```
+
+## Todo
+
+* Save/Return previous values
+* Evaluate fmt.Formatter interface
+
+
+## Credits
+
+ * [Fatih Arslan](https://github.com/fatih)
+ * Windows support via @mattn: [colorable](https://github.com/mattn/go-colorable)
+
+## License
+
+The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details
+
diff --git a/vendor/github.com/fatih/color/color.go b/vendor/github.com/fatih/color/color.go
new file mode 100644
index 0000000000000000000000000000000000000000..b1f591d45f566b53d7a2e58bfbfd4363ce22e706
--- /dev/null
+++ b/vendor/github.com/fatih/color/color.go
@@ -0,0 +1,600 @@
+package color
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+)
+
+var (
+	// NoColor defines if the output is colorized or not. It's dynamically set to
+	// false or true based on the stdout's file descriptor referring to a terminal
+	// or not. This is a global option and affects all colors. For more control
+	// over each color block use the methods DisableColor() individually.
+	NoColor = os.Getenv("TERM") == "dumb" ||
+		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
+
+	// Output defines the standard output of the print functions. By default
+	// os.Stdout is used.
+	Output = colorable.NewColorableStdout()
+
+	// colorsCache is used to reduce the count of created Color objects and
+	// allows to reuse already created objects with required Attribute.
+	colorsCache   = make(map[Attribute]*Color)
+	colorsCacheMu sync.Mutex // protects colorsCache
+)
+
+// Color defines a custom color object which is defined by SGR parameters.
+type Color struct {
+	params  []Attribute
+	noColor *bool
+}
+
+// Attribute defines a single SGR Code
+type Attribute int
+
+const escape = "\x1b"
+
+// Base attributes
+const (
+	Reset Attribute = iota
+	Bold
+	Faint
+	Italic
+	Underline
+	BlinkSlow
+	BlinkRapid
+	ReverseVideo
+	Concealed
+	CrossedOut
+)
+
+// Foreground text colors
+const (
+	FgBlack Attribute = iota + 30
+	FgRed
+	FgGreen
+	FgYellow
+	FgBlue
+	FgMagenta
+	FgCyan
+	FgWhite
+)
+
+// Foreground Hi-Intensity text colors
+const (
+	FgHiBlack Attribute = iota + 90
+	FgHiRed
+	FgHiGreen
+	FgHiYellow
+	FgHiBlue
+	FgHiMagenta
+	FgHiCyan
+	FgHiWhite
+)
+
+// Background text colors
+const (
+	BgBlack Attribute = iota + 40
+	BgRed
+	BgGreen
+	BgYellow
+	BgBlue
+	BgMagenta
+	BgCyan
+	BgWhite
+)
+
+// Background Hi-Intensity text colors
+const (
+	BgHiBlack Attribute = iota + 100
+	BgHiRed
+	BgHiGreen
+	BgHiYellow
+	BgHiBlue
+	BgHiMagenta
+	BgHiCyan
+	BgHiWhite
+)
+
+// New returns a newly created color object.
+func New(value ...Attribute) *Color {
+	c := &Color{params: make([]Attribute, 0)}
+	c.Add(value...)
+	return c
+}
+
+// Set sets the given parameters immediately. It will change the color of
+// output with the given SGR parameters until color.Unset() is called.
+func Set(p ...Attribute) *Color {
+	c := New(p...)
+	c.Set()
+	return c
+}
+
+// Unset resets all escape attributes and clears the output. Usually should
+// be called after Set().
+func Unset() {
+	if NoColor {
+		return
+	}
+
+	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
+}
+
+// Set sets the SGR sequence.
+func (c *Color) Set() *Color {
+	if c.isNoColorSet() {
+		return c
+	}
+
+	fmt.Fprintf(Output, c.format())
+	return c
+}
+
+func (c *Color) unset() {
+	if c.isNoColorSet() {
+		return
+	}
+
+	Unset()
+}
+
+func (c *Color) setWriter(w io.Writer) *Color {
+	if c.isNoColorSet() {
+		return c
+	}
+
+	fmt.Fprintf(w, c.format())
+	return c
+}
+
+func (c *Color) unsetWriter(w io.Writer) {
+	if c.isNoColorSet() {
+		return
+	}
+
+	if NoColor {
+		return
+	}
+
+	fmt.Fprintf(w, "%s[%dm", escape, Reset)
+}
+
+// Add is used to chain SGR parameters. Use as many as parameters to combine
+// and create custom color objects. Example: Add(color.FgRed, color.Underline).
+func (c *Color) Add(value ...Attribute) *Color {
+	c.params = append(c.params, value...)
+	return c
+}
+
+func (c *Color) prepend(value Attribute) {
+	c.params = append(c.params, 0)
+	copy(c.params[1:], c.params[0:])
+	c.params[0] = value
+}
+
+// Fprint formats using the default formats for its operands and writes to w.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+// On Windows, users should wrap w with colorable.NewColorable() if w is of
+// type *os.File.
+func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	c.setWriter(w)
+	defer c.unsetWriter(w)
+
+	return fmt.Fprint(w, a...)
+}
+
+// Print formats using the default formats for its operands and writes to
+// standard output. Spaces are added between operands when neither is a
+// string. It returns the number of bytes written and any write error
+// encountered. This is the standard fmt.Print() method wrapped with the given
+// color.
+func (c *Color) Print(a ...interface{}) (n int, err error) {
+	c.Set()
+	defer c.unset()
+
+	return fmt.Fprint(Output, a...)
+}
+
+// Fprintf formats according to a format specifier and writes to w.
+// It returns the number of bytes written and any write error encountered.
+// On Windows, users should wrap w with colorable.NewColorable() if w is of
+// type *os.File.
+func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	c.setWriter(w)
+	defer c.unsetWriter(w)
+
+	return fmt.Fprintf(w, format, a...)
+}
+
+// Printf formats according to a format specifier and writes to standard output.
+// It returns the number of bytes written and any write error encountered.
+// This is the standard fmt.Printf() method wrapped with the given color.
+func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
+	c.Set()
+	defer c.unset()
+
+	return fmt.Fprintf(Output, format, a...)
+}
+
+// Fprintln formats using the default formats for its operands and writes to w.
+// Spaces are always added between operands and a newline is appended.
+// On Windows, users should wrap w with colorable.NewColorable() if w is of
+// type *os.File.
+func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	c.setWriter(w)
+	defer c.unsetWriter(w)
+
+	return fmt.Fprintln(w, a...)
+}
+
+// Println formats using the default formats for its operands and writes to
+// standard output. Spaces are always added between operands and a newline is
+// appended. It returns the number of bytes written and any write error
+// encountered. This is the standard fmt.Print() method wrapped with the given
+// color.
+func (c *Color) Println(a ...interface{}) (n int, err error) {
+	c.Set()
+	defer c.unset()
+
+	return fmt.Fprintln(Output, a...)
+}
+
+// Sprint is just like Print, but returns a string instead of printing it.
+func (c *Color) Sprint(a ...interface{}) string {
+	return c.wrap(fmt.Sprint(a...))
+}
+
+// Sprintln is just like Println, but returns a string instead of printing it.
+func (c *Color) Sprintln(a ...interface{}) string {
+	return c.wrap(fmt.Sprintln(a...))
+}
+
+// Sprintf is just like Printf, but returns a string instead of printing it.
+func (c *Color) Sprintf(format string, a ...interface{}) string {
+	return c.wrap(fmt.Sprintf(format, a...))
+}
+
+// FprintFunc returns a new function that prints the passed arguments as
+// colorized with color.Fprint().
+func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
+	return func(w io.Writer, a ...interface{}) {
+		c.Fprint(w, a...)
+	}
+}
+
+// PrintFunc returns a new function that prints the passed arguments as
+// colorized with color.Print().
+func (c *Color) PrintFunc() func(a ...interface{}) {
+	return func(a ...interface{}) {
+		c.Print(a...)
+	}
+}
+
+// FprintfFunc returns a new function that prints the passed arguments as
+// colorized with color.Fprintf().
+func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
+	return func(w io.Writer, format string, a ...interface{}) {
+		c.Fprintf(w, format, a...)
+	}
+}
+
+// PrintfFunc returns a new function that prints the passed arguments as
+// colorized with color.Printf().
+func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
+	return func(format string, a ...interface{}) {
+		c.Printf(format, a...)
+	}
+}
+
+// FprintlnFunc returns a new function that prints the passed arguments as
+// colorized with color.Fprintln().
+func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
+	return func(w io.Writer, a ...interface{}) {
+		c.Fprintln(w, a...)
+	}
+}
+
+// PrintlnFunc returns a new function that prints the passed arguments as
+// colorized with color.Println().
+func (c *Color) PrintlnFunc() func(a ...interface{}) {
+	return func(a ...interface{}) {
+		c.Println(a...)
+	}
+}
+
+// SprintFunc returns a new function that returns colorized strings for the
+// given arguments with fmt.Sprint(). Useful to put into or mix into other
+// string. Windows users should use this in conjunction with color.Output, example:
+//
+//	put := New(FgYellow).SprintFunc()
+//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
+func (c *Color) SprintFunc() func(a ...interface{}) string {
+	return func(a ...interface{}) string {
+		return c.wrap(fmt.Sprint(a...))
+	}
+}
+
+// SprintfFunc returns a new function that returns colorized strings for the
+// given arguments with fmt.Sprintf(). Useful to put into or mix into other
+// string. Windows users should use this in conjunction with color.Output.
+func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
+	return func(format string, a ...interface{}) string {
+		return c.wrap(fmt.Sprintf(format, a...))
+	}
+}
+
+// SprintlnFunc returns a new function that returns colorized strings for the
+// given arguments with fmt.Sprintln(). Useful to put into or mix into other
+// string. Windows users should use this in conjunction with color.Output.
+func (c *Color) SprintlnFunc() func(a ...interface{}) string {
+	return func(a ...interface{}) string {
+		return c.wrap(fmt.Sprintln(a...))
+	}
+}
+
+// sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
+// an example output might be: "1;36" -> bold cyan
+func (c *Color) sequence() string {
+	format := make([]string, len(c.params))
+	for i, v := range c.params {
+		format[i] = strconv.Itoa(int(v))
+	}
+
+	return strings.Join(format, ";")
+}
+
+// wrap wraps the s string with the colors attributes. The string is ready to
+// be printed.
+func (c *Color) wrap(s string) string {
+	if c.isNoColorSet() {
+		return s
+	}
+
+	return c.format() + s + c.unformat()
+}
+
+func (c *Color) format() string {
+	return fmt.Sprintf("%s[%sm", escape, c.sequence())
+}
+
+func (c *Color) unformat() string {
+	return fmt.Sprintf("%s[%dm", escape, Reset)
+}
+
+// DisableColor disables the color output. Useful to not change any existing
+// code and still being able to output. Can be used for flags like
+// "--no-color". To enable back use EnableColor() method.
+func (c *Color) DisableColor() {
+	c.noColor = boolPtr(true)
+}
+
+// EnableColor enables the color output. Use it in conjunction with
+// DisableColor(). Otherwise this method has no side effects.
+func (c *Color) EnableColor() {
+	c.noColor = boolPtr(false)
+}
+
+func (c *Color) isNoColorSet() bool {
+	// check first if we have user setted action
+	if c.noColor != nil {
+		return *c.noColor
+	}
+
+	// if not return the global option, which is disabled by default
+	return NoColor
+}
+
+// Equals returns a boolean value indicating whether two colors are equal.
+func (c *Color) Equals(c2 *Color) bool {
+	if len(c.params) != len(c2.params) {
+		return false
+	}
+
+	for _, attr := range c.params {
+		if !c2.attrExists(attr) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (c *Color) attrExists(a Attribute) bool {
+	for _, attr := range c.params {
+		if attr == a {
+			return true
+		}
+	}
+
+	return false
+}
+
+func boolPtr(v bool) *bool {
+	return &v
+}
+
+func getCachedColor(p Attribute) *Color {
+	colorsCacheMu.Lock()
+	defer colorsCacheMu.Unlock()
+
+	c, ok := colorsCache[p]
+	if !ok {
+		c = New(p)
+		colorsCache[p] = c
+	}
+
+	return c
+}
+
+func colorPrint(format string, p Attribute, a ...interface{}) {
+	c := getCachedColor(p)
+
+	if !strings.HasSuffix(format, "\n") {
+		format += "\n"
+	}
+
+	if len(a) == 0 {
+		c.Print(format)
+	} else {
+		c.Printf(format, a...)
+	}
+}
+
+func colorString(format string, p Attribute, a ...interface{}) string {
+	c := getCachedColor(p)
+
+	if len(a) == 0 {
+		return c.SprintFunc()(format)
+	}
+
+	return c.SprintfFunc()(format, a...)
+}
+
+// Black is a convenient helper function to print with black foreground. A
+// newline is appended to format by default.
+func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
+
+// Red is a convenient helper function to print with red foreground. A
+// newline is appended to format by default.
+func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
+
+// Green is a convenient helper function to print with green foreground. A
+// newline is appended to format by default.
+func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
+
+// Yellow is a convenient helper function to print with yellow foreground.
+// A newline is appended to format by default.
+func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
+
+// Blue is a convenient helper function to print with blue foreground. A
+// newline is appended to format by default.
+func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
+
+// Magenta is a convenient helper function to print with magenta foreground.
+// A newline is appended to format by default.
+func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
+
+// Cyan is a convenient helper function to print with cyan foreground. A
+// newline is appended to format by default.
+func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
+
+// White is a convenient helper function to print with white foreground. A
+// newline is appended to format by default.
+func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
+
+// BlackString is a convenient helper function to return a string with black
+// foreground.
+func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
+
+// RedString is a convenient helper function to return a string with red
+// foreground.
+func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
+
+// GreenString is a convenient helper function to return a string with green
+// foreground.
+func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
+
+// YellowString is a convenient helper function to return a string with yellow
+// foreground.
+func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
+
+// BlueString is a convenient helper function to return a string with blue
+// foreground.
+func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
+
+// MagentaString is a convenient helper function to return a string with magenta
+// foreground.
+func MagentaString(format string, a ...interface{}) string {
+	return colorString(format, FgMagenta, a...)
+}
+
+// CyanString is a convenient helper function to return a string with cyan
+// foreground.
+func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
+
+// WhiteString is a convenient helper function to return a string with white
+// foreground.
+func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
+
+// HiBlack is a convenient helper function to print with hi-intensity black foreground. A
+// newline is appended to format by default.
+func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
+
+// HiRed is a convenient helper function to print with hi-intensity red foreground. A
+// newline is appended to format by default.
+func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
+
+// HiGreen is a convenient helper function to print with hi-intensity green foreground. A
+// newline is appended to format by default.
+func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
+
+// HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
+// A newline is appended to format by default.
+func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
+
+// HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
+// newline is appended to format by default.
+func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
+
+// HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
+// A newline is appended to format by default.
+func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
+
+// HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
+// newline is appended to format by default.
+func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
+
+// HiWhite is a convenient helper function to print with hi-intensity white foreground. A
+// newline is appended to format by default.
+func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
+
+// HiBlackString is a convenient helper function to return a string with hi-intensity black
+// foreground.
+func HiBlackString(format string, a ...interface{}) string {
+	return colorString(format, FgHiBlack, a...)
+}
+
+// HiRedString is a convenient helper function to return a string with hi-intensity red
+// foreground.
+func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
+
+// HiGreenString is a convenient helper function to return a string with hi-intensity green
+// foreground.
+func HiGreenString(format string, a ...interface{}) string {
+	return colorString(format, FgHiGreen, a...)
+}
+
+// HiYellowString is a convenient helper function to return a string with hi-intensity yellow
+// foreground.
+func HiYellowString(format string, a ...interface{}) string {
+	return colorString(format, FgHiYellow, a...)
+}
+
+// HiBlueString is a convenient helper function to return a string with hi-intensity blue
+// foreground.
+func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
+
+// HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
+// foreground.
+func HiMagentaString(format string, a ...interface{}) string {
+	return colorString(format, FgHiMagenta, a...)
+}
+
+// HiCyanString is a convenient helper function to return a string with hi-intensity cyan
+// foreground.
+func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
+
+// HiWhiteString is a convenient helper function to return a string with hi-intensity white
+// foreground.
+func HiWhiteString(format string, a ...interface{}) string {
+	return colorString(format, FgHiWhite, a...)
+}
diff --git a/vendor/github.com/fatih/color/doc.go b/vendor/github.com/fatih/color/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..cf1e96500f4e2736f5c20123238ddc463885107a
--- /dev/null
+++ b/vendor/github.com/fatih/color/doc.go
@@ -0,0 +1,133 @@
+/*
+Package color is an ANSI color package to output colorized or SGR defined
+output to the standard output. The API can be used in several way, pick one
+that suits you.
+
+Use simple and default helper functions with predefined foreground colors:
+
+    color.Cyan("Prints text in cyan.")
+
+    // a newline will be appended automatically
+    color.Blue("Prints %s in blue.", "text")
+
+    // More default foreground colors..
+    color.Red("We have red")
+    color.Yellow("Yellow color too!")
+    color.Magenta("And many others ..")
+
+    // Hi-intensity colors
+    color.HiGreen("Bright green color.")
+    color.HiBlack("Bright black means gray..")
+    color.HiWhite("Shiny white color!")
+
+However there are times where custom color mixes are required. Below are some
+examples to create custom color objects and use the print functions of each
+separate color object.
+
+    // Create a new color object
+    c := color.New(color.FgCyan).Add(color.Underline)
+    c.Println("Prints cyan text with an underline.")
+
+    // Or just add them to New()
+    d := color.New(color.FgCyan, color.Bold)
+    d.Printf("This prints bold cyan %s\n", "too!.")
+
+
+    // Mix up foreground and background colors, create new mixes!
+    red := color.New(color.FgRed)
+
+    boldRed := red.Add(color.Bold)
+    boldRed.Println("This will print text in bold red.")
+
+    whiteBackground := red.Add(color.BgWhite)
+    whiteBackground.Println("Red text with White background.")
+
+    // Use your own io.Writer output
+    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
+
+    blue := color.New(color.FgBlue)
+    blue.Fprint(myWriter, "This will print text in blue.")
+
+You can create PrintXxx functions to simplify even more:
+
+    // Create a custom print function for convenient
+    red := color.New(color.FgRed).PrintfFunc()
+    red("warning")
+    red("error: %s", err)
+
+    // Mix up multiple attributes
+    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
+    notice("don't forget this...")
+
+You can also FprintXxx functions to pass your own io.Writer:
+
+    blue := color.New(FgBlue).FprintfFunc()
+    blue(myWriter, "important notice: %s", stars)
+
+    // Mix up with multiple attributes
+    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
+    success(myWriter, don't forget this...")
+
+
+Or create SprintXxx functions to mix strings with other non-colorized strings:
+
+    yellow := New(FgYellow).SprintFunc()
+    red := New(FgRed).SprintFunc()
+
+    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
+
+    info := New(FgWhite, BgGreen).SprintFunc()
+    fmt.Printf("this %s rocks!\n", info("package"))
+
+Windows support is enabled by default. All Print functions work as intended.
+However only for color.SprintXXX functions, user should use fmt.FprintXXX and
+set the output to color.Output:
+
+    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
+
+    info := New(FgWhite, BgGreen).SprintFunc()
+    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
+
+Using with existing code is possible. Just use the Set() method to set the
+standard output to the given parameters. That way a rewrite of an existing
+code is not required.
+
+    // Use handy standard colors.
+    color.Set(color.FgYellow)
+
+    fmt.Println("Existing text will be now in Yellow")
+    fmt.Printf("This one %s\n", "too")
+
+    color.Unset() // don't forget to unset
+
+    // You can mix up parameters
+    color.Set(color.FgMagenta, color.Bold)
+    defer color.Unset() // use it in your function
+
+    fmt.Println("All text will be now bold magenta.")
+
+There might be a case where you want to disable color output (for example to
+pipe the standard output of your app to somewhere else). `Color` has support to
+disable colors both globally and for single color definition. For example
+suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
+the color output with:
+
+    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
+
+    if *flagNoColor {
+    	color.NoColor = true // disables colorized output
+    }
+
+It also has support for single color definitions (local). You can
+disable/enable color output on the fly:
+
+     c := color.New(color.FgCyan)
+     c.Println("Prints cyan text")
+
+     c.DisableColor()
+     c.Println("This is printed without any color")
+
+     c.EnableColor()
+     c.Println("This prints again cyan...")
+*/
+package color
diff --git a/vendor/github.com/golang/protobuf/proto/Makefile b/vendor/github.com/golang/protobuf/proto/Makefile
deleted file mode 100644
index e2e0651a934d3ab8fe6393dfd2556bbc4bd0792e..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2010 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-install:
-	go install
-
-test: install generate-test-pbs
-	go test
-
-
-generate-test-pbs:
-	make install
-	make -C testdata
-	protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto
-	make
diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go
deleted file mode 100644
index e392575b353afa4f22f513d3f22ff64a8f5fdbf1..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/clone.go
+++ /dev/null
@@ -1,229 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer deep copy and merge.
-// TODO: RawMessage.
-
-package proto
-
-import (
-	"log"
-	"reflect"
-	"strings"
-)
-
-// Clone returns a deep copy of a protocol buffer.
-func Clone(pb Message) Message {
-	in := reflect.ValueOf(pb)
-	if in.IsNil() {
-		return pb
-	}
-
-	out := reflect.New(in.Type().Elem())
-	// out is empty so a merge is a deep copy.
-	mergeStruct(out.Elem(), in.Elem())
-	return out.Interface().(Message)
-}
-
-// Merge merges src into dst.
-// Required and optional fields that are set in src will be set to that value in dst.
-// Elements of repeated fields will be appended.
-// Merge panics if src and dst are not the same type, or if dst is nil.
-func Merge(dst, src Message) {
-	in := reflect.ValueOf(src)
-	out := reflect.ValueOf(dst)
-	if out.IsNil() {
-		panic("proto: nil destination")
-	}
-	if in.Type() != out.Type() {
-		// Explicit test prior to mergeStruct so that mistyped nils will fail
-		panic("proto: type mismatch")
-	}
-	if in.IsNil() {
-		// Merging nil into non-nil is a quiet no-op
-		return
-	}
-	mergeStruct(out.Elem(), in.Elem())
-}
-
-func mergeStruct(out, in reflect.Value) {
-	sprop := GetProperties(in.Type())
-	for i := 0; i < in.NumField(); i++ {
-		f := in.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
-	}
-
-	if emIn, ok := extendable(in.Addr().Interface()); ok {
-		emOut, _ := extendable(out.Addr().Interface())
-		mIn, muIn := emIn.extensionsRead()
-		if mIn != nil {
-			mOut := emOut.extensionsWrite()
-			muIn.Lock()
-			mergeExtension(mOut, mIn)
-			muIn.Unlock()
-		}
-	}
-
-	uf := in.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return
-	}
-	uin := uf.Bytes()
-	if len(uin) > 0 {
-		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
-	}
-}
-
-// mergeAny performs a merge between two values of the same type.
-// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
-// prop is set if this is a struct field (it may be nil).
-func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
-	if in.Type() == protoMessageType {
-		if !in.IsNil() {
-			if out.IsNil() {
-				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
-			} else {
-				Merge(out.Interface().(Message), in.Interface().(Message))
-			}
-		}
-		return
-	}
-	switch in.Kind() {
-	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-		reflect.String, reflect.Uint32, reflect.Uint64:
-		if !viaPtr && isProto3Zero(in) {
-			return
-		}
-		out.Set(in)
-	case reflect.Interface:
-		// Probably a oneof field; copy non-nil values.
-		if in.IsNil() {
-			return
-		}
-		// Allocate destination if it is not set, or set to a different type.
-		// Otherwise we will merge as normal.
-		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
-			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
-		}
-		mergeAny(out.Elem(), in.Elem(), false, nil)
-	case reflect.Map:
-		if in.Len() == 0 {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.MakeMap(in.Type()))
-		}
-		// For maps with value types of *T or []byte we need to deep copy each value.
-		elemKind := in.Type().Elem().Kind()
-		for _, key := range in.MapKeys() {
-			var val reflect.Value
-			switch elemKind {
-			case reflect.Ptr:
-				val = reflect.New(in.Type().Elem().Elem())
-				mergeAny(val, in.MapIndex(key), false, nil)
-			case reflect.Slice:
-				val = in.MapIndex(key)
-				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
-			default:
-				val = in.MapIndex(key)
-			}
-			out.SetMapIndex(key, val)
-		}
-	case reflect.Ptr:
-		if in.IsNil() {
-			return
-		}
-		if out.IsNil() {
-			out.Set(reflect.New(in.Elem().Type()))
-		}
-		mergeAny(out.Elem(), in.Elem(), true, nil)
-	case reflect.Slice:
-		if in.IsNil() {
-			return
-		}
-		if in.Type().Elem().Kind() == reflect.Uint8 {
-			// []byte is a scalar bytes field, not a repeated field.
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value, and should not
-			// be merged.
-			if prop != nil && prop.proto3 && in.Len() == 0 {
-				return
-			}
-
-			// Make a deep copy.
-			// Append to []byte{} instead of []byte(nil) so that we never end up
-			// with a nil result.
-			out.SetBytes(append([]byte{}, in.Bytes()...))
-			return
-		}
-		n := in.Len()
-		if out.IsNil() {
-			out.Set(reflect.MakeSlice(in.Type(), 0, n))
-		}
-		switch in.Type().Elem().Kind() {
-		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
-			reflect.String, reflect.Uint32, reflect.Uint64:
-			out.Set(reflect.AppendSlice(out, in))
-		default:
-			for i := 0; i < n; i++ {
-				x := reflect.Indirect(reflect.New(in.Type().Elem()))
-				mergeAny(x, in.Index(i), false, nil)
-				out.Set(reflect.Append(out, x))
-			}
-		}
-	case reflect.Struct:
-		mergeStruct(out, in)
-	default:
-		// unknown type, so not a protocol buffer
-		log.Printf("proto: don't know how to copy %v", in)
-	}
-}
-
-func mergeExtension(out, in map[int32]Extension) {
-	for extNum, eIn := range in {
-		eOut := Extension{desc: eIn.desc}
-		if eIn.value != nil {
-			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
-			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
-			eOut.value = v.Interface()
-		}
-		if eIn.enc != nil {
-			eOut.enc = make([]byte, len(eIn.enc))
-			copy(eOut.enc, eIn.enc)
-		}
-
-		out[extNum] = eOut
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
deleted file mode 100644
index aa207298f997665117f3ba88e65646f95c83f08a..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/decode.go
+++ /dev/null
@@ -1,970 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for decoding protocol buffer data to construct in-memory representations.
- */
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-)
-
-// errOverflow is returned when an integer is too large to be represented.
-var errOverflow = errors.New("proto: integer overflow")
-
-// ErrInternalBadWireType is returned by generated code when an incorrect
-// wire type is encountered. It does not get returned to user code.
-var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
-
-// The fundamental decoders that interpret bytes on the wire.
-// Those that take integer types all return uint64 and are
-// therefore of type valueDecoder.
-
-// DecodeVarint reads a varint-encoded integer from the slice.
-// It returns the integer and the number of bytes consumed, or
-// zero if there is not enough.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func DecodeVarint(buf []byte) (x uint64, n int) {
-	for shift := uint(0); shift < 64; shift += 7 {
-		if n >= len(buf) {
-			return 0, 0
-		}
-		b := uint64(buf[n])
-		n++
-		x |= (b & 0x7F) << shift
-		if (b & 0x80) == 0 {
-			return x, n
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	return 0, 0
-}
-
-func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
-	i := p.index
-	l := len(p.buf)
-
-	for shift := uint(0); shift < 64; shift += 7 {
-		if i >= l {
-			err = io.ErrUnexpectedEOF
-			return
-		}
-		b := p.buf[i]
-		i++
-		x |= (uint64(b) & 0x7F) << shift
-		if b < 0x80 {
-			p.index = i
-			return
-		}
-	}
-
-	// The number is too large to represent in a 64-bit value.
-	err = errOverflow
-	return
-}
-
-// DecodeVarint reads a varint-encoded integer from the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) DecodeVarint() (x uint64, err error) {
-	i := p.index
-	buf := p.buf
-
-	if i >= len(buf) {
-		return 0, io.ErrUnexpectedEOF
-	} else if buf[i] < 0x80 {
-		p.index++
-		return uint64(buf[i]), nil
-	} else if len(buf)-i < 10 {
-		return p.decodeVarintSlow()
-	}
-
-	var b uint64
-	// we already checked the first byte
-	x = uint64(buf[i]) - 0x80
-	i++
-
-	b = uint64(buf[i])
-	i++
-	x += b << 7
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 7
-
-	b = uint64(buf[i])
-	i++
-	x += b << 14
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 14
-
-	b = uint64(buf[i])
-	i++
-	x += b << 21
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 21
-
-	b = uint64(buf[i])
-	i++
-	x += b << 28
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 28
-
-	b = uint64(buf[i])
-	i++
-	x += b << 35
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 35
-
-	b = uint64(buf[i])
-	i++
-	x += b << 42
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 42
-
-	b = uint64(buf[i])
-	i++
-	x += b << 49
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 49
-
-	b = uint64(buf[i])
-	i++
-	x += b << 56
-	if b&0x80 == 0 {
-		goto done
-	}
-	x -= 0x80 << 56
-
-	b = uint64(buf[i])
-	i++
-	x += b << 63
-	if b&0x80 == 0 {
-		goto done
-	}
-	// x -= 0x80 << 63 // Always zero.
-
-	return 0, errOverflow
-
-done:
-	p.index = i
-	return x, nil
-}
-
-// DecodeFixed64 reads a 64-bit integer from the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) DecodeFixed64() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 8
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-8])
-	x |= uint64(p.buf[i-7]) << 8
-	x |= uint64(p.buf[i-6]) << 16
-	x |= uint64(p.buf[i-5]) << 24
-	x |= uint64(p.buf[i-4]) << 32
-	x |= uint64(p.buf[i-3]) << 40
-	x |= uint64(p.buf[i-2]) << 48
-	x |= uint64(p.buf[i-1]) << 56
-	return
-}
-
-// DecodeFixed32 reads a 32-bit integer from the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) DecodeFixed32() (x uint64, err error) {
-	// x, err already 0
-	i := p.index + 4
-	if i < 0 || i > len(p.buf) {
-		err = io.ErrUnexpectedEOF
-		return
-	}
-	p.index = i
-
-	x = uint64(p.buf[i-4])
-	x |= uint64(p.buf[i-3]) << 8
-	x |= uint64(p.buf[i-2]) << 16
-	x |= uint64(p.buf[i-1]) << 24
-	return
-}
-
-// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
-// from the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
-	return
-}
-
-// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
-// from  the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
-	x, err = p.DecodeVarint()
-	if err != nil {
-		return
-	}
-	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
-	return
-}
-
-// These are not ValueDecoders: they produce an array of bytes or a string.
-// bytes, embedded messages
-
-// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
-	n, err := p.DecodeVarint()
-	if err != nil {
-		return nil, err
-	}
-
-	nb := int(n)
-	if nb < 0 {
-		return nil, fmt.Errorf("proto: bad byte length %d", nb)
-	}
-	end := p.index + nb
-	if end < p.index || end > len(p.buf) {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	if !alloc {
-		// todo: check if can get more uses of alloc=false
-		buf = p.buf[p.index:end]
-		p.index += nb
-		return
-	}
-
-	buf = make([]byte, nb)
-	copy(buf, p.buf[p.index:])
-	p.index += nb
-	return
-}
-
-// DecodeStringBytes reads an encoded string from the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) DecodeStringBytes() (s string, err error) {
-	buf, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return
-	}
-	return string(buf), nil
-}
-
-// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
-// If the protocol buffer has extensions, and the field matches, add it as an extension.
-// Otherwise, if the XXX_unrecognized field exists, append the skipped data there.
-func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error {
-	oi := o.index
-
-	err := o.skip(t, tag, wire)
-	if err != nil {
-		return err
-	}
-
-	if !unrecField.IsValid() {
-		return nil
-	}
-
-	ptr := structPointer_Bytes(base, unrecField)
-
-	// Add the skipped field to struct field
-	obuf := o.buf
-
-	o.buf = *ptr
-	o.EncodeVarint(uint64(tag<<3 | wire))
-	*ptr = append(o.buf, obuf[oi:o.index]...)
-
-	o.buf = obuf
-
-	return nil
-}
-
-// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
-func (o *Buffer) skip(t reflect.Type, tag, wire int) error {
-
-	var u uint64
-	var err error
-
-	switch wire {
-	case WireVarint:
-		_, err = o.DecodeVarint()
-	case WireFixed64:
-		_, err = o.DecodeFixed64()
-	case WireBytes:
-		_, err = o.DecodeRawBytes(false)
-	case WireFixed32:
-		_, err = o.DecodeFixed32()
-	case WireStartGroup:
-		for {
-			u, err = o.DecodeVarint()
-			if err != nil {
-				break
-			}
-			fwire := int(u & 0x7)
-			if fwire == WireEndGroup {
-				break
-			}
-			ftag := int(u >> 3)
-			err = o.skip(t, ftag, fwire)
-			if err != nil {
-				break
-			}
-		}
-	default:
-		err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t)
-	}
-	return err
-}
-
-// Unmarshaler is the interface representing objects that can
-// unmarshal themselves.  The method should reset the receiver before
-// decoding starts.  The argument points to data that may be
-// overwritten, so implementations should not keep references to the
-// buffer.
-type Unmarshaler interface {
-	Unmarshal([]byte) error
-}
-
-// Unmarshal parses the protocol buffer representation in buf and places the
-// decoded result in pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// Unmarshal resets pb before starting to unmarshal, so any
-// existing data in pb is always removed. Use UnmarshalMerge
-// to preserve and append to existing data.
-func Unmarshal(buf []byte, pb Message) error {
-	pb.Reset()
-	return UnmarshalMerge(buf, pb)
-}
-
-// UnmarshalMerge parses the protocol buffer representation in buf and
-// writes the decoded result to pb.  If the struct underlying pb does not match
-// the data in buf, the results can be unpredictable.
-//
-// UnmarshalMerge merges into existing data in pb.
-// Most code should use Unmarshal instead.
-func UnmarshalMerge(buf []byte, pb Message) error {
-	// If the object can unmarshal itself, let it.
-	if u, ok := pb.(Unmarshaler); ok {
-		return u.Unmarshal(buf)
-	}
-	return NewBuffer(buf).Unmarshal(pb)
-}
-
-// DecodeMessage reads a count-delimited message from the Buffer.
-func (p *Buffer) DecodeMessage(pb Message) error {
-	enc, err := p.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-	return NewBuffer(enc).Unmarshal(pb)
-}
-
-// DecodeGroup reads a tag-delimited group from the Buffer.
-func (p *Buffer) DecodeGroup(pb Message) error {
-	typ, base, err := getbase(pb)
-	if err != nil {
-		return err
-	}
-	return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base)
-}
-
-// Unmarshal parses the protocol buffer representation in the
-// Buffer and places the decoded result in pb.  If the struct
-// underlying pb does not match the data in the buffer, the results can be
-// unpredictable.
-//
-// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
-func (p *Buffer) Unmarshal(pb Message) error {
-	// If the object can unmarshal itself, let it.
-	if u, ok := pb.(Unmarshaler); ok {
-		err := u.Unmarshal(p.buf[p.index:])
-		p.index = len(p.buf)
-		return err
-	}
-
-	typ, base, err := getbase(pb)
-	if err != nil {
-		return err
-	}
-
-	err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base)
-
-	if collectStats {
-		stats.Decode++
-	}
-
-	return err
-}
-
-// unmarshalType does the work of unmarshaling a structure.
-func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error {
-	var state errorState
-	required, reqFields := prop.reqCount, uint64(0)
-
-	var err error
-	for err == nil && o.index < len(o.buf) {
-		oi := o.index
-		var u uint64
-		u, err = o.DecodeVarint()
-		if err != nil {
-			break
-		}
-		wire := int(u & 0x7)
-		if wire == WireEndGroup {
-			if is_group {
-				if required > 0 {
-					// Not enough information to determine the exact field.
-					// (See below.)
-					return &RequiredNotSetError{"{Unknown}"}
-				}
-				return nil // input is satisfied
-			}
-			return fmt.Errorf("proto: %s: wiretype end group for non-group", st)
-		}
-		tag := int(u >> 3)
-		if tag <= 0 {
-			return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire)
-		}
-		fieldnum, ok := prop.decoderTags.get(tag)
-		if !ok {
-			// Maybe it's an extension?
-			if prop.extendable {
-				if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {
-					if err = o.skip(st, tag, wire); err == nil {
-						extmap := e.extensionsWrite()
-						ext := extmap[int32(tag)] // may be missing
-						ext.enc = append(ext.enc, o.buf[oi:o.index]...)
-						extmap[int32(tag)] = ext
-					}
-					continue
-				}
-			}
-			// Maybe it's a oneof?
-			if prop.oneofUnmarshaler != nil {
-				m := structPointer_Interface(base, st).(Message)
-				// First return value indicates whether tag is a oneof field.
-				ok, err = prop.oneofUnmarshaler(m, tag, wire, o)
-				if err == ErrInternalBadWireType {
-					// Map the error to something more descriptive.
-					// Do the formatting here to save generated code space.
-					err = fmt.Errorf("bad wiretype for oneof field in %T", m)
-				}
-				if ok {
-					continue
-				}
-			}
-			err = o.skipAndSave(st, tag, wire, base, prop.unrecField)
-			continue
-		}
-		p := prop.Prop[fieldnum]
-
-		if p.dec == nil {
-			fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name)
-			continue
-		}
-		dec := p.dec
-		if wire != WireStartGroup && wire != p.WireType {
-			if wire == WireBytes && p.packedDec != nil {
-				// a packable field
-				dec = p.packedDec
-			} else {
-				err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType)
-				continue
-			}
-		}
-		decErr := dec(o, p, base)
-		if decErr != nil && !state.shouldContinue(decErr, p) {
-			err = decErr
-		}
-		if err == nil && p.Required {
-			// Successfully decoded a required field.
-			if tag <= 64 {
-				// use bitmap for fields 1-64 to catch field reuse.
-				var mask uint64 = 1 << uint64(tag-1)
-				if reqFields&mask == 0 {
-					// new required field
-					reqFields |= mask
-					required--
-				}
-			} else {
-				// This is imprecise. It can be fooled by a required field
-				// with a tag > 64 that is encoded twice; that's very rare.
-				// A fully correct implementation would require allocating
-				// a data structure, which we would like to avoid.
-				required--
-			}
-		}
-	}
-	if err == nil {
-		if is_group {
-			return io.ErrUnexpectedEOF
-		}
-		if state.err != nil {
-			return state.err
-		}
-		if required > 0 {
-			// Not enough information to determine the exact field. If we use extra
-			// CPU, we could determine the field only if the missing required field
-			// has a tag <= 64 and we check reqFields.
-			return &RequiredNotSetError{"{Unknown}"}
-		}
-	}
-	return err
-}
-
-// Individual type decoders
-// For each,
-//	u is the decoded value,
-//	v is a pointer to the field (pointer) in the struct
-
-// Sizes of the pools to allocate inside the Buffer.
-// The goal is modest amortization and allocation
-// on at least 16-byte boundaries.
-const (
-	boolPoolSize   = 16
-	uint32PoolSize = 8
-	uint64PoolSize = 4
-)
-
-// Decode a bool.
-func (o *Buffer) dec_bool(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	if len(o.bools) == 0 {
-		o.bools = make([]bool, boolPoolSize)
-	}
-	o.bools[0] = u != 0
-	*structPointer_Bool(base, p.field) = &o.bools[0]
-	o.bools = o.bools[1:]
-	return nil
-}
-
-func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	*structPointer_BoolVal(base, p.field) = u != 0
-	return nil
-}
-
-// Decode an int32.
-func (o *Buffer) dec_int32(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	word32_Set(structPointer_Word32(base, p.field), o, uint32(u))
-	return nil
-}
-
-func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u))
-	return nil
-}
-
-// Decode an int64.
-func (o *Buffer) dec_int64(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	word64_Set(structPointer_Word64(base, p.field), o, u)
-	return nil
-}
-
-func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	word64Val_Set(structPointer_Word64Val(base, p.field), o, u)
-	return nil
-}
-
-// Decode a string.
-func (o *Buffer) dec_string(p *Properties, base structPointer) error {
-	s, err := o.DecodeStringBytes()
-	if err != nil {
-		return err
-	}
-	*structPointer_String(base, p.field) = &s
-	return nil
-}
-
-func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error {
-	s, err := o.DecodeStringBytes()
-	if err != nil {
-		return err
-	}
-	*structPointer_StringVal(base, p.field) = s
-	return nil
-}
-
-// Decode a slice of bytes ([]byte).
-func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error {
-	b, err := o.DecodeRawBytes(true)
-	if err != nil {
-		return err
-	}
-	*structPointer_Bytes(base, p.field) = b
-	return nil
-}
-
-// Decode a slice of bools ([]bool).
-func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	v := structPointer_BoolSlice(base, p.field)
-	*v = append(*v, u != 0)
-	return nil
-}
-
-// Decode a slice of bools ([]bool) in packed format.
-func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error {
-	v := structPointer_BoolSlice(base, p.field)
-
-	nn, err := o.DecodeVarint()
-	if err != nil {
-		return err
-	}
-	nb := int(nn) // number of bytes of encoded bools
-	fin := o.index + nb
-	if fin < o.index {
-		return errOverflow
-	}
-
-	y := *v
-	for o.index < fin {
-		u, err := p.valDec(o)
-		if err != nil {
-			return err
-		}
-		y = append(y, u != 0)
-	}
-
-	*v = y
-	return nil
-}
-
-// Decode a slice of int32s ([]int32).
-func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-	structPointer_Word32Slice(base, p.field).Append(uint32(u))
-	return nil
-}
-
-// Decode a slice of int32s ([]int32) in packed format.
-func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error {
-	v := structPointer_Word32Slice(base, p.field)
-
-	nn, err := o.DecodeVarint()
-	if err != nil {
-		return err
-	}
-	nb := int(nn) // number of bytes of encoded int32s
-
-	fin := o.index + nb
-	if fin < o.index {
-		return errOverflow
-	}
-	for o.index < fin {
-		u, err := p.valDec(o)
-		if err != nil {
-			return err
-		}
-		v.Append(uint32(u))
-	}
-	return nil
-}
-
-// Decode a slice of int64s ([]int64).
-func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error {
-	u, err := p.valDec(o)
-	if err != nil {
-		return err
-	}
-
-	structPointer_Word64Slice(base, p.field).Append(u)
-	return nil
-}
-
-// Decode a slice of int64s ([]int64) in packed format.
-func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error {
-	v := structPointer_Word64Slice(base, p.field)
-
-	nn, err := o.DecodeVarint()
-	if err != nil {
-		return err
-	}
-	nb := int(nn) // number of bytes of encoded int64s
-
-	fin := o.index + nb
-	if fin < o.index {
-		return errOverflow
-	}
-	for o.index < fin {
-		u, err := p.valDec(o)
-		if err != nil {
-			return err
-		}
-		v.Append(u)
-	}
-	return nil
-}
-
-// Decode a slice of strings ([]string).
-func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error {
-	s, err := o.DecodeStringBytes()
-	if err != nil {
-		return err
-	}
-	v := structPointer_StringSlice(base, p.field)
-	*v = append(*v, s)
-	return nil
-}
-
-// Decode a slice of slice of bytes ([][]byte).
-func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error {
-	b, err := o.DecodeRawBytes(true)
-	if err != nil {
-		return err
-	}
-	v := structPointer_BytesSlice(base, p.field)
-	*v = append(*v, b)
-	return nil
-}
-
-// Decode a map field.
-func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {
-	raw, err := o.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-	oi := o.index       // index at the end of this map entry
-	o.index -= len(raw) // move buffer back to start of map entry
-
-	mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V
-	if mptr.Elem().IsNil() {
-		mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem()))
-	}
-	v := mptr.Elem() // map[K]V
-
-	// Prepare addressable doubly-indirect placeholders for the key and value types.
-	// See enc_new_map for why.
-	keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K
-	keybase := toStructPointer(keyptr.Addr())                  // **K
-
-	var valbase structPointer
-	var valptr reflect.Value
-	switch p.mtype.Elem().Kind() {
-	case reflect.Slice:
-		// []byte
-		var dummy []byte
-		valptr = reflect.ValueOf(&dummy)  // *[]byte
-		valbase = toStructPointer(valptr) // *[]byte
-	case reflect.Ptr:
-		// message; valptr is **Msg; need to allocate the intermediate pointer
-		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
-		valptr.Set(reflect.New(valptr.Type().Elem()))
-		valbase = toStructPointer(valptr)
-	default:
-		// everything else
-		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
-		valbase = toStructPointer(valptr.Addr())                   // **V
-	}
-
-	// Decode.
-	// This parses a restricted wire format, namely the encoding of a message
-	// with two fields. See enc_new_map for the format.
-	for o.index < oi {
-		// tagcode for key and value properties are always a single byte
-		// because they have tags 1 and 2.
-		tagcode := o.buf[o.index]
-		o.index++
-		switch tagcode {
-		case p.mkeyprop.tagcode[0]:
-			if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil {
-				return err
-			}
-		case p.mvalprop.tagcode[0]:
-			if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil {
-				return err
-			}
-		default:
-			// TODO: Should we silently skip this instead?
-			return fmt.Errorf("proto: bad map data tag %d", raw[0])
-		}
-	}
-	keyelem, valelem := keyptr.Elem(), valptr.Elem()
-	if !keyelem.IsValid() {
-		keyelem = reflect.Zero(p.mtype.Key())
-	}
-	if !valelem.IsValid() {
-		valelem = reflect.Zero(p.mtype.Elem())
-	}
-
-	v.SetMapIndex(keyelem, valelem)
-	return nil
-}
-
-// Decode a group.
-func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error {
-	bas := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(bas) {
-		// allocate new nested message
-		bas = toStructPointer(reflect.New(p.stype))
-		structPointer_SetStructPointer(base, p.field, bas)
-	}
-	return o.unmarshalType(p.stype, p.sprop, true, bas)
-}
-
-// Decode an embedded message.
-func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) {
-	raw, e := o.DecodeRawBytes(false)
-	if e != nil {
-		return e
-	}
-
-	bas := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(bas) {
-		// allocate new nested message
-		bas = toStructPointer(reflect.New(p.stype))
-		structPointer_SetStructPointer(base, p.field, bas)
-	}
-
-	// If the object can unmarshal itself, let it.
-	if p.isUnmarshaler {
-		iv := structPointer_Interface(bas, p.stype)
-		return iv.(Unmarshaler).Unmarshal(raw)
-	}
-
-	obuf := o.buf
-	oi := o.index
-	o.buf = raw
-	o.index = 0
-
-	err = o.unmarshalType(p.stype, p.sprop, false, bas)
-	o.buf = obuf
-	o.index = oi
-
-	return err
-}
-
-// Decode a slice of embedded messages.
-func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error {
-	return o.dec_slice_struct(p, false, base)
-}
-
-// Decode a slice of embedded groups.
-func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error {
-	return o.dec_slice_struct(p, true, base)
-}
-
-// Decode a slice of structs ([]*struct).
-func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error {
-	v := reflect.New(p.stype)
-	bas := toStructPointer(v)
-	structPointer_StructPointerSlice(base, p.field).Append(bas)
-
-	if is_group {
-		err := o.unmarshalType(p.stype, p.sprop, is_group, bas)
-		return err
-	}
-
-	raw, err := o.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-
-	// If the object can unmarshal itself, let it.
-	if p.isUnmarshaler {
-		iv := v.Interface()
-		return iv.(Unmarshaler).Unmarshal(raw)
-	}
-
-	obuf := o.buf
-	oi := o.index
-	o.buf = raw
-	o.index = 0
-
-	err = o.unmarshalType(p.stype, p.sprop, is_group, bas)
-
-	o.buf = obuf
-	o.index = oi
-
-	return err
-}
diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go
deleted file mode 100644
index 8b84d1b22d4c0933820cb4872e29c918e5429be2..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/encode.go
+++ /dev/null
@@ -1,1362 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"sort"
-)
-
-// RequiredNotSetError is the error returned if Marshal is called with
-// a protocol buffer struct whose required fields have not
-// all been initialized. It is also the error returned if Unmarshal is
-// called with an encoded protocol buffer that does not include all the
-// required fields.
-//
-// When printed, RequiredNotSetError reports the first unset required field in a
-// message. If the field cannot be precisely determined, it is reported as
-// "{Unknown}".
-type RequiredNotSetError struct {
-	field string
-}
-
-func (e *RequiredNotSetError) Error() string {
-	return fmt.Sprintf("proto: required field %q not set", e.field)
-}
-
-var (
-	// errRepeatedHasNil is the error returned if Marshal is called with
-	// a struct with a repeated field containing a nil element.
-	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
-
-	// errOneofHasNil is the error returned if Marshal is called with
-	// a struct with a oneof field containing a nil element.
-	errOneofHasNil = errors.New("proto: oneof field has nil value")
-
-	// ErrNil is the error returned if Marshal is called with nil.
-	ErrNil = errors.New("proto: Marshal called with nil")
-
-	// ErrTooLarge is the error returned if Marshal is called with a
-	// message that encodes to >2GB.
-	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
-)
-
-// The fundamental encoders that put bytes on the wire.
-// Those that take integer types all accept uint64 and are
-// therefore of type valueEncoder.
-
-const maxVarintBytes = 10 // maximum length of a varint
-
-// maxMarshalSize is the largest allowed size of an encoded protobuf,
-// since C++ and Java use signed int32s for the size.
-const maxMarshalSize = 1<<31 - 1
-
-// EncodeVarint returns the varint encoding of x.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-// Not used by the package itself, but helpful to clients
-// wishing to use the same encoding.
-func EncodeVarint(x uint64) []byte {
-	var buf [maxVarintBytes]byte
-	var n int
-	for n = 0; x > 127; n++ {
-		buf[n] = 0x80 | uint8(x&0x7F)
-		x >>= 7
-	}
-	buf[n] = uint8(x)
-	n++
-	return buf[0:n]
-}
-
-// EncodeVarint writes a varint-encoded integer to the Buffer.
-// This is the format for the
-// int32, int64, uint32, uint64, bool, and enum
-// protocol buffer types.
-func (p *Buffer) EncodeVarint(x uint64) error {
-	for x >= 1<<7 {
-		p.buf = append(p.buf, uint8(x&0x7f|0x80))
-		x >>= 7
-	}
-	p.buf = append(p.buf, uint8(x))
-	return nil
-}
-
-// SizeVarint returns the varint encoding size of an integer.
-func SizeVarint(x uint64) int {
-	return sizeVarint(x)
-}
-
-func sizeVarint(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
-}
-
-// EncodeFixed64 writes a 64-bit integer to the Buffer.
-// This is the format for the
-// fixed64, sfixed64, and double protocol buffer types.
-func (p *Buffer) EncodeFixed64(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24),
-		uint8(x>>32),
-		uint8(x>>40),
-		uint8(x>>48),
-		uint8(x>>56))
-	return nil
-}
-
-func sizeFixed64(x uint64) int {
-	return 8
-}
-
-// EncodeFixed32 writes a 32-bit integer to the Buffer.
-// This is the format for the
-// fixed32, sfixed32, and float protocol buffer types.
-func (p *Buffer) EncodeFixed32(x uint64) error {
-	p.buf = append(p.buf,
-		uint8(x),
-		uint8(x>>8),
-		uint8(x>>16),
-		uint8(x>>24))
-	return nil
-}
-
-func sizeFixed32(x uint64) int {
-	return 4
-}
-
-// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
-// to the Buffer.
-// This is the format used for the sint64 protocol buffer type.
-func (p *Buffer) EncodeZigzag64(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint((x << 1) ^ uint64((int64(x) >> 63)))
-}
-
-func sizeZigzag64(x uint64) int {
-	return sizeVarint((x << 1) ^ uint64((int64(x) >> 63)))
-}
-
-// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
-// to the Buffer.
-// This is the format used for the sint32 protocol buffer type.
-func (p *Buffer) EncodeZigzag32(x uint64) error {
-	// use signed number to get arithmetic right shift.
-	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
-}
-
-func sizeZigzag32(x uint64) int {
-	return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
-}
-
-// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
-// This is the format used for the bytes protocol buffer
-// type and for embedded messages.
-func (p *Buffer) EncodeRawBytes(b []byte) error {
-	p.EncodeVarint(uint64(len(b)))
-	p.buf = append(p.buf, b...)
-	return nil
-}
-
-func sizeRawBytes(b []byte) int {
-	return sizeVarint(uint64(len(b))) +
-		len(b)
-}
-
-// EncodeStringBytes writes an encoded string to the Buffer.
-// This is the format used for the proto2 string type.
-func (p *Buffer) EncodeStringBytes(s string) error {
-	p.EncodeVarint(uint64(len(s)))
-	p.buf = append(p.buf, s...)
-	return nil
-}
-
-func sizeStringBytes(s string) int {
-	return sizeVarint(uint64(len(s))) +
-		len(s)
-}
-
-// Marshaler is the interface representing objects that can marshal themselves.
-type Marshaler interface {
-	Marshal() ([]byte, error)
-}
-
-// Marshal takes the protocol buffer
-// and encodes it into the wire format, returning the data.
-func Marshal(pb Message) ([]byte, error) {
-	// Can the object marshal itself?
-	if m, ok := pb.(Marshaler); ok {
-		return m.Marshal()
-	}
-	p := NewBuffer(nil)
-	err := p.Marshal(pb)
-	if p.buf == nil && err == nil {
-		// Return a non-nil slice on success.
-		return []byte{}, nil
-	}
-	return p.buf, err
-}
-
-// EncodeMessage writes the protocol buffer to the Buffer,
-// prefixed by a varint-encoded length.
-func (p *Buffer) EncodeMessage(pb Message) error {
-	t, base, err := getbase(pb)
-	if structPointer_IsNil(base) {
-		return ErrNil
-	}
-	if err == nil {
-		var state errorState
-		err = p.enc_len_struct(GetProperties(t.Elem()), base, &state)
-	}
-	return err
-}
-
-// Marshal takes the protocol buffer
-// and encodes it into the wire format, writing the result to the
-// Buffer.
-func (p *Buffer) Marshal(pb Message) error {
-	// Can the object marshal itself?
-	if m, ok := pb.(Marshaler); ok {
-		data, err := m.Marshal()
-		p.buf = append(p.buf, data...)
-		return err
-	}
-
-	t, base, err := getbase(pb)
-	if structPointer_IsNil(base) {
-		return ErrNil
-	}
-	if err == nil {
-		err = p.enc_struct(GetProperties(t.Elem()), base)
-	}
-
-	if collectStats {
-		(stats).Encode++ // Parens are to work around a goimports bug.
-	}
-
-	if len(p.buf) > maxMarshalSize {
-		return ErrTooLarge
-	}
-	return err
-}
-
-// Size returns the encoded size of a protocol buffer.
-func Size(pb Message) (n int) {
-	// Can the object marshal itself?  If so, Size is slow.
-	// TODO: add Size to Marshaler, or add a Sizer interface.
-	if m, ok := pb.(Marshaler); ok {
-		b, _ := m.Marshal()
-		return len(b)
-	}
-
-	t, base, err := getbase(pb)
-	if structPointer_IsNil(base) {
-		return 0
-	}
-	if err == nil {
-		n = size_struct(GetProperties(t.Elem()), base)
-	}
-
-	if collectStats {
-		(stats).Size++ // Parens are to work around a goimports bug.
-	}
-
-	return
-}
-
-// Individual type encoders.
-
-// Encode a bool.
-func (o *Buffer) enc_bool(p *Properties, base structPointer) error {
-	v := *structPointer_Bool(base, p.field)
-	if v == nil {
-		return ErrNil
-	}
-	x := 0
-	if *v {
-		x = 1
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, uint64(x))
-	return nil
-}
-
-func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {
-	v := *structPointer_BoolVal(base, p.field)
-	if !v {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, 1)
-	return nil
-}
-
-func size_bool(p *Properties, base structPointer) int {
-	v := *structPointer_Bool(base, p.field)
-	if v == nil {
-		return 0
-	}
-	return len(p.tagcode) + 1 // each bool takes exactly one byte
-}
-
-func size_proto3_bool(p *Properties, base structPointer) int {
-	v := *structPointer_BoolVal(base, p.field)
-	if !v && !p.oneof {
-		return 0
-	}
-	return len(p.tagcode) + 1 // each bool takes exactly one byte
-}
-
-// Encode an int32.
-func (o *Buffer) enc_int32(p *Properties, base structPointer) error {
-	v := structPointer_Word32(base, p.field)
-	if word32_IsNil(v) {
-		return ErrNil
-	}
-	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, uint64(x))
-	return nil
-}
-
-func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {
-	v := structPointer_Word32Val(base, p.field)
-	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
-	if x == 0 {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, uint64(x))
-	return nil
-}
-
-func size_int32(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word32(base, p.field)
-	if word32_IsNil(v) {
-		return 0
-	}
-	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
-	n += len(p.tagcode)
-	n += p.valSize(uint64(x))
-	return
-}
-
-func size_proto3_int32(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word32Val(base, p.field)
-	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
-	if x == 0 && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += p.valSize(uint64(x))
-	return
-}
-
-// Encode a uint32.
-// Exactly the same as int32, except for no sign extension.
-func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {
-	v := structPointer_Word32(base, p.field)
-	if word32_IsNil(v) {
-		return ErrNil
-	}
-	x := word32_Get(v)
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, uint64(x))
-	return nil
-}
-
-func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {
-	v := structPointer_Word32Val(base, p.field)
-	x := word32Val_Get(v)
-	if x == 0 {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, uint64(x))
-	return nil
-}
-
-func size_uint32(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word32(base, p.field)
-	if word32_IsNil(v) {
-		return 0
-	}
-	x := word32_Get(v)
-	n += len(p.tagcode)
-	n += p.valSize(uint64(x))
-	return
-}
-
-func size_proto3_uint32(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word32Val(base, p.field)
-	x := word32Val_Get(v)
-	if x == 0 && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += p.valSize(uint64(x))
-	return
-}
-
-// Encode an int64.
-func (o *Buffer) enc_int64(p *Properties, base structPointer) error {
-	v := structPointer_Word64(base, p.field)
-	if word64_IsNil(v) {
-		return ErrNil
-	}
-	x := word64_Get(v)
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, x)
-	return nil
-}
-
-func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {
-	v := structPointer_Word64Val(base, p.field)
-	x := word64Val_Get(v)
-	if x == 0 {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	p.valEnc(o, x)
-	return nil
-}
-
-func size_int64(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word64(base, p.field)
-	if word64_IsNil(v) {
-		return 0
-	}
-	x := word64_Get(v)
-	n += len(p.tagcode)
-	n += p.valSize(x)
-	return
-}
-
-func size_proto3_int64(p *Properties, base structPointer) (n int) {
-	v := structPointer_Word64Val(base, p.field)
-	x := word64Val_Get(v)
-	if x == 0 && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += p.valSize(x)
-	return
-}
-
-// Encode a string.
-func (o *Buffer) enc_string(p *Properties, base structPointer) error {
-	v := *structPointer_String(base, p.field)
-	if v == nil {
-		return ErrNil
-	}
-	x := *v
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeStringBytes(x)
-	return nil
-}
-
-func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {
-	v := *structPointer_StringVal(base, p.field)
-	if v == "" {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeStringBytes(v)
-	return nil
-}
-
-func size_string(p *Properties, base structPointer) (n int) {
-	v := *structPointer_String(base, p.field)
-	if v == nil {
-		return 0
-	}
-	x := *v
-	n += len(p.tagcode)
-	n += sizeStringBytes(x)
-	return
-}
-
-func size_proto3_string(p *Properties, base structPointer) (n int) {
-	v := *structPointer_StringVal(base, p.field)
-	if v == "" && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += sizeStringBytes(v)
-	return
-}
-
-// All protocol buffer fields are nillable, but be careful.
-func isNil(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return v.IsNil()
-	}
-	return false
-}
-
-// Encode a message struct.
-func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {
-	var state errorState
-	structp := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(structp) {
-		return ErrNil
-	}
-
-	// Can the object marshal itself?
-	if p.isMarshaler {
-		m := structPointer_Interface(structp, p.stype).(Marshaler)
-		data, err := m.Marshal()
-		if err != nil && !state.shouldContinue(err, nil) {
-			return err
-		}
-		o.buf = append(o.buf, p.tagcode...)
-		o.EncodeRawBytes(data)
-		return state.err
-	}
-
-	o.buf = append(o.buf, p.tagcode...)
-	return o.enc_len_struct(p.sprop, structp, &state)
-}
-
-func size_struct_message(p *Properties, base structPointer) int {
-	structp := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(structp) {
-		return 0
-	}
-
-	// Can the object marshal itself?
-	if p.isMarshaler {
-		m := structPointer_Interface(structp, p.stype).(Marshaler)
-		data, _ := m.Marshal()
-		n0 := len(p.tagcode)
-		n1 := sizeRawBytes(data)
-		return n0 + n1
-	}
-
-	n0 := len(p.tagcode)
-	n1 := size_struct(p.sprop, structp)
-	n2 := sizeVarint(uint64(n1)) // size of encoded length
-	return n0 + n1 + n2
-}
-
-// Encode a group struct.
-func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {
-	var state errorState
-	b := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(b) {
-		return ErrNil
-	}
-
-	o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
-	err := o.enc_struct(p.sprop, b)
-	if err != nil && !state.shouldContinue(err, nil) {
-		return err
-	}
-	o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
-	return state.err
-}
-
-func size_struct_group(p *Properties, base structPointer) (n int) {
-	b := structPointer_GetStructPointer(base, p.field)
-	if structPointer_IsNil(b) {
-		return 0
-	}
-
-	n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))
-	n += size_struct(p.sprop, b)
-	n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))
-	return
-}
-
-// Encode a slice of bools ([]bool).
-func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {
-	s := *structPointer_BoolSlice(base, p.field)
-	l := len(s)
-	if l == 0 {
-		return ErrNil
-	}
-	for _, x := range s {
-		o.buf = append(o.buf, p.tagcode...)
-		v := uint64(0)
-		if x {
-			v = 1
-		}
-		p.valEnc(o, v)
-	}
-	return nil
-}
-
-func size_slice_bool(p *Properties, base structPointer) int {
-	s := *structPointer_BoolSlice(base, p.field)
-	l := len(s)
-	if l == 0 {
-		return 0
-	}
-	return l * (len(p.tagcode) + 1) // each bool takes exactly one byte
-}
-
-// Encode a slice of bools ([]bool) in packed format.
-func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {
-	s := *structPointer_BoolSlice(base, p.field)
-	l := len(s)
-	if l == 0 {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeVarint(uint64(l)) // each bool takes exactly one byte
-	for _, x := range s {
-		v := uint64(0)
-		if x {
-			v = 1
-		}
-		p.valEnc(o, v)
-	}
-	return nil
-}
-
-func size_slice_packed_bool(p *Properties, base structPointer) (n int) {
-	s := *structPointer_BoolSlice(base, p.field)
-	l := len(s)
-	if l == 0 {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += sizeVarint(uint64(l))
-	n += l // each bool takes exactly one byte
-	return
-}
-
-// Encode a slice of bytes ([]byte).
-func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {
-	s := *structPointer_Bytes(base, p.field)
-	if s == nil {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeRawBytes(s)
-	return nil
-}
-
-func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {
-	s := *structPointer_Bytes(base, p.field)
-	if len(s) == 0 {
-		return ErrNil
-	}
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeRawBytes(s)
-	return nil
-}
-
-func size_slice_byte(p *Properties, base structPointer) (n int) {
-	s := *structPointer_Bytes(base, p.field)
-	if s == nil && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += sizeRawBytes(s)
-	return
-}
-
-func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {
-	s := *structPointer_Bytes(base, p.field)
-	if len(s) == 0 && !p.oneof {
-		return 0
-	}
-	n += len(p.tagcode)
-	n += sizeRawBytes(s)
-	return
-}
-
-// Encode a slice of int32s ([]int32).
-func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	for i := 0; i < l; i++ {
-		o.buf = append(o.buf, p.tagcode...)
-		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
-		p.valEnc(o, uint64(x))
-	}
-	return nil
-}
-
-func size_slice_int32(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	for i := 0; i < l; i++ {
-		n += len(p.tagcode)
-		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
-		n += p.valSize(uint64(x))
-	}
-	return
-}
-
-// Encode a slice of int32s ([]int32) in packed format.
-func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	// TODO: Reuse a Buffer.
-	buf := NewBuffer(nil)
-	for i := 0; i < l; i++ {
-		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
-		p.valEnc(buf, uint64(x))
-	}
-
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeVarint(uint64(len(buf.buf)))
-	o.buf = append(o.buf, buf.buf...)
-	return nil
-}
-
-func size_slice_packed_int32(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	var bufSize int
-	for i := 0; i < l; i++ {
-		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
-		bufSize += p.valSize(uint64(x))
-	}
-
-	n += len(p.tagcode)
-	n += sizeVarint(uint64(bufSize))
-	n += bufSize
-	return
-}
-
-// Encode a slice of uint32s ([]uint32).
-// Exactly the same as int32, except for no sign extension.
-func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	for i := 0; i < l; i++ {
-		o.buf = append(o.buf, p.tagcode...)
-		x := s.Index(i)
-		p.valEnc(o, uint64(x))
-	}
-	return nil
-}
-
-func size_slice_uint32(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	for i := 0; i < l; i++ {
-		n += len(p.tagcode)
-		x := s.Index(i)
-		n += p.valSize(uint64(x))
-	}
-	return
-}
-
-// Encode a slice of uint32s ([]uint32) in packed format.
-// Exactly the same as int32, except for no sign extension.
-func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	// TODO: Reuse a Buffer.
-	buf := NewBuffer(nil)
-	for i := 0; i < l; i++ {
-		p.valEnc(buf, uint64(s.Index(i)))
-	}
-
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeVarint(uint64(len(buf.buf)))
-	o.buf = append(o.buf, buf.buf...)
-	return nil
-}
-
-func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word32Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	var bufSize int
-	for i := 0; i < l; i++ {
-		bufSize += p.valSize(uint64(s.Index(i)))
-	}
-
-	n += len(p.tagcode)
-	n += sizeVarint(uint64(bufSize))
-	n += bufSize
-	return
-}
-
-// Encode a slice of int64s ([]int64).
-func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {
-	s := structPointer_Word64Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	for i := 0; i < l; i++ {
-		o.buf = append(o.buf, p.tagcode...)
-		p.valEnc(o, s.Index(i))
-	}
-	return nil
-}
-
-func size_slice_int64(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word64Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	for i := 0; i < l; i++ {
-		n += len(p.tagcode)
-		n += p.valSize(s.Index(i))
-	}
-	return
-}
-
-// Encode a slice of int64s ([]int64) in packed format.
-func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {
-	s := structPointer_Word64Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return ErrNil
-	}
-	// TODO: Reuse a Buffer.
-	buf := NewBuffer(nil)
-	for i := 0; i < l; i++ {
-		p.valEnc(buf, s.Index(i))
-	}
-
-	o.buf = append(o.buf, p.tagcode...)
-	o.EncodeVarint(uint64(len(buf.buf)))
-	o.buf = append(o.buf, buf.buf...)
-	return nil
-}
-
-func size_slice_packed_int64(p *Properties, base structPointer) (n int) {
-	s := structPointer_Word64Slice(base, p.field)
-	l := s.Len()
-	if l == 0 {
-		return 0
-	}
-	var bufSize int
-	for i := 0; i < l; i++ {
-		bufSize += p.valSize(s.Index(i))
-	}
-
-	n += len(p.tagcode)
-	n += sizeVarint(uint64(bufSize))
-	n += bufSize
-	return
-}
-
-// Encode a slice of slice of bytes ([][]byte).
-func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {
-	ss := *structPointer_BytesSlice(base, p.field)
-	l := len(ss)
-	if l == 0 {
-		return ErrNil
-	}
-	for i := 0; i < l; i++ {
-		o.buf = append(o.buf, p.tagcode...)
-		o.EncodeRawBytes(ss[i])
-	}
-	return nil
-}
-
-func size_slice_slice_byte(p *Properties, base structPointer) (n int) {
-	ss := *structPointer_BytesSlice(base, p.field)
-	l := len(ss)
-	if l == 0 {
-		return 0
-	}
-	n += l * len(p.tagcode)
-	for i := 0; i < l; i++ {
-		n += sizeRawBytes(ss[i])
-	}
-	return
-}
-
-// Encode a slice of strings ([]string).
-func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {
-	ss := *structPointer_StringSlice(base, p.field)
-	l := len(ss)
-	for i := 0; i < l; i++ {
-		o.buf = append(o.buf, p.tagcode...)
-		o.EncodeStringBytes(ss[i])
-	}
-	return nil
-}
-
-func size_slice_string(p *Properties, base structPointer) (n int) {
-	ss := *structPointer_StringSlice(base, p.field)
-	l := len(ss)
-	n += l * len(p.tagcode)
-	for i := 0; i < l; i++ {
-		n += sizeStringBytes(ss[i])
-	}
-	return
-}
-
-// Encode a slice of message structs ([]*struct).
-func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {
-	var state errorState
-	s := structPointer_StructPointerSlice(base, p.field)
-	l := s.Len()
-
-	for i := 0; i < l; i++ {
-		structp := s.Index(i)
-		if structPointer_IsNil(structp) {
-			return errRepeatedHasNil
-		}
-
-		// Can the object marshal itself?
-		if p.isMarshaler {
-			m := structPointer_Interface(structp, p.stype).(Marshaler)
-			data, err := m.Marshal()
-			if err != nil && !state.shouldContinue(err, nil) {
-				return err
-			}
-			o.buf = append(o.buf, p.tagcode...)
-			o.EncodeRawBytes(data)
-			continue
-		}
-
-		o.buf = append(o.buf, p.tagcode...)
-		err := o.enc_len_struct(p.sprop, structp, &state)
-		if err != nil && !state.shouldContinue(err, nil) {
-			if err == ErrNil {
-				return errRepeatedHasNil
-			}
-			return err
-		}
-	}
-	return state.err
-}
-
-func size_slice_struct_message(p *Properties, base structPointer) (n int) {
-	s := structPointer_StructPointerSlice(base, p.field)
-	l := s.Len()
-	n += l * len(p.tagcode)
-	for i := 0; i < l; i++ {
-		structp := s.Index(i)
-		if structPointer_IsNil(structp) {
-			return // return the size up to this point
-		}
-
-		// Can the object marshal itself?
-		if p.isMarshaler {
-			m := structPointer_Interface(structp, p.stype).(Marshaler)
-			data, _ := m.Marshal()
-			n += sizeRawBytes(data)
-			continue
-		}
-
-		n0 := size_struct(p.sprop, structp)
-		n1 := sizeVarint(uint64(n0)) // size of encoded length
-		n += n0 + n1
-	}
-	return
-}
-
-// Encode a slice of group structs ([]*struct).
-func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {
-	var state errorState
-	s := structPointer_StructPointerSlice(base, p.field)
-	l := s.Len()
-
-	for i := 0; i < l; i++ {
-		b := s.Index(i)
-		if structPointer_IsNil(b) {
-			return errRepeatedHasNil
-		}
-
-		o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
-
-		err := o.enc_struct(p.sprop, b)
-
-		if err != nil && !state.shouldContinue(err, nil) {
-			if err == ErrNil {
-				return errRepeatedHasNil
-			}
-			return err
-		}
-
-		o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
-	}
-	return state.err
-}
-
-func size_slice_struct_group(p *Properties, base structPointer) (n int) {
-	s := structPointer_StructPointerSlice(base, p.field)
-	l := s.Len()
-
-	n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))
-	n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))
-	for i := 0; i < l; i++ {
-		b := s.Index(i)
-		if structPointer_IsNil(b) {
-			return // return size up to this point
-		}
-
-		n += size_struct(p.sprop, b)
-	}
-	return
-}
-
-// Encode an extension map.
-func (o *Buffer) enc_map(p *Properties, base structPointer) error {
-	exts := structPointer_ExtMap(base, p.field)
-	if err := encodeExtensionsMap(*exts); err != nil {
-		return err
-	}
-
-	return o.enc_map_body(*exts)
-}
-
-func (o *Buffer) enc_exts(p *Properties, base structPointer) error {
-	exts := structPointer_Extensions(base, p.field)
-
-	v, mu := exts.extensionsRead()
-	if v == nil {
-		return nil
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if err := encodeExtensionsMap(v); err != nil {
-		return err
-	}
-
-	return o.enc_map_body(v)
-}
-
-func (o *Buffer) enc_map_body(v map[int32]Extension) error {
-	// Fast-path for common cases: zero or one extensions.
-	if len(v) <= 1 {
-		for _, e := range v {
-			o.buf = append(o.buf, e.enc...)
-		}
-		return nil
-	}
-
-	// Sort keys to provide a deterministic encoding.
-	keys := make([]int, 0, len(v))
-	for k := range v {
-		keys = append(keys, int(k))
-	}
-	sort.Ints(keys)
-
-	for _, k := range keys {
-		o.buf = append(o.buf, v[int32(k)].enc...)
-	}
-	return nil
-}
-
-func size_map(p *Properties, base structPointer) int {
-	v := structPointer_ExtMap(base, p.field)
-	return extensionsMapSize(*v)
-}
-
-func size_exts(p *Properties, base structPointer) int {
-	v := structPointer_Extensions(base, p.field)
-	return extensionsSize(v)
-}
-
-// Encode a map field.
-func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
-	var state errorState // XXX: or do we need to plumb this through?
-
-	/*
-		A map defined as
-			map<key_type, value_type> map_field = N;
-		is encoded in the same way as
-			message MapFieldEntry {
-				key_type key = 1;
-				value_type value = 2;
-			}
-			repeated MapFieldEntry map_field = N;
-	*/
-
-	v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
-	if v.Len() == 0 {
-		return nil
-	}
-
-	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
-
-	enc := func() error {
-		if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
-			return err
-		}
-		if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {
-			return err
-		}
-		return nil
-	}
-
-	// Don't sort map keys. It is not required by the spec, and C++ doesn't do it.
-	for _, key := range v.MapKeys() {
-		val := v.MapIndex(key)
-
-		keycopy.Set(key)
-		valcopy.Set(val)
-
-		o.buf = append(o.buf, p.tagcode...)
-		if err := o.enc_len_thing(enc, &state); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func size_new_map(p *Properties, base structPointer) int {
-	v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
-
-	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
-
-	n := 0
-	for _, key := range v.MapKeys() {
-		val := v.MapIndex(key)
-		keycopy.Set(key)
-		valcopy.Set(val)
-
-		// Tag codes for key and val are the responsibility of the sub-sizer.
-		keysize := p.mkeyprop.size(p.mkeyprop, keybase)
-		valsize := p.mvalprop.size(p.mvalprop, valbase)
-		entry := keysize + valsize
-		// Add on tag code and length of map entry itself.
-		n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry
-	}
-	return n
-}
-
-// mapEncodeScratch returns a new reflect.Value matching the map's value type,
-// and a structPointer suitable for passing to an encoder or sizer.
-func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
-	// Prepare addressable doubly-indirect placeholders for the key and value types.
-	// This is needed because the element-type encoders expect **T, but the map iteration produces T.
-
-	keycopy = reflect.New(mapType.Key()).Elem()                 // addressable K
-	keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
-	keyptr.Set(keycopy.Addr())                                  //
-	keybase = toStructPointer(keyptr.Addr())                    // **K
-
-	// Value types are more varied and require special handling.
-	switch mapType.Elem().Kind() {
-	case reflect.Slice:
-		// []byte
-		var dummy []byte
-		valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
-		valbase = toStructPointer(valcopy.Addr())
-	case reflect.Ptr:
-		// message; the generated field type is map[K]*Msg (so V is *Msg),
-		// so we only need one level of indirection.
-		valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
-		valbase = toStructPointer(valcopy.Addr())
-	default:
-		// everything else
-		valcopy = reflect.New(mapType.Elem()).Elem()                // addressable V
-		valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
-		valptr.Set(valcopy.Addr())                                  //
-		valbase = toStructPointer(valptr.Addr())                    // **V
-	}
-	return
-}
-
-// Encode a struct.
-func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
-	var state errorState
-	// Encode fields in tag order so that decoders may use optimizations
-	// that depend on the ordering.
-	// https://developers.google.com/protocol-buffers/docs/encoding#order
-	for _, i := range prop.order {
-		p := prop.Prop[i]
-		if p.enc != nil {
-			err := p.enc(o, p, base)
-			if err != nil {
-				if err == ErrNil {
-					if p.Required && state.err == nil {
-						state.err = &RequiredNotSetError{p.Name}
-					}
-				} else if err == errRepeatedHasNil {
-					// Give more context to nil values in repeated fields.
-					return errors.New("repeated field " + p.OrigName + " has nil element")
-				} else if !state.shouldContinue(err, p) {
-					return err
-				}
-			}
-			if len(o.buf) > maxMarshalSize {
-				return ErrTooLarge
-			}
-		}
-	}
-
-	// Do oneof fields.
-	if prop.oneofMarshaler != nil {
-		m := structPointer_Interface(base, prop.stype).(Message)
-		if err := prop.oneofMarshaler(m, o); err == ErrNil {
-			return errOneofHasNil
-		} else if err != nil {
-			return err
-		}
-	}
-
-	// Add unrecognized fields at the end.
-	if prop.unrecField.IsValid() {
-		v := *structPointer_Bytes(base, prop.unrecField)
-		if len(o.buf)+len(v) > maxMarshalSize {
-			return ErrTooLarge
-		}
-		if len(v) > 0 {
-			o.buf = append(o.buf, v...)
-		}
-	}
-
-	return state.err
-}
-
-func size_struct(prop *StructProperties, base structPointer) (n int) {
-	for _, i := range prop.order {
-		p := prop.Prop[i]
-		if p.size != nil {
-			n += p.size(p, base)
-		}
-	}
-
-	// Add unrecognized fields at the end.
-	if prop.unrecField.IsValid() {
-		v := *structPointer_Bytes(base, prop.unrecField)
-		n += len(v)
-	}
-
-	// Factor in any oneof fields.
-	if prop.oneofSizer != nil {
-		m := structPointer_Interface(base, prop.stype).(Message)
-		n += prop.oneofSizer(m)
-	}
-
-	return
-}
-
-var zeroes [20]byte // longer than any conceivable sizeVarint
-
-// Encode a struct, preceded by its encoded length (as a varint).
-func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {
-	return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)
-}
-
-// Encode something, preceded by its encoded length (as a varint).
-func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {
-	iLen := len(o.buf)
-	o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length
-	iMsg := len(o.buf)
-	err := enc()
-	if err != nil && !state.shouldContinue(err, nil) {
-		return err
-	}
-	lMsg := len(o.buf) - iMsg
-	lLen := sizeVarint(uint64(lMsg))
-	switch x := lLen - (iMsg - iLen); {
-	case x > 0: // actual length is x bytes larger than the space we reserved
-		// Move msg x bytes right.
-		o.buf = append(o.buf, zeroes[:x]...)
-		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
-	case x < 0: // actual length is x bytes smaller than the space we reserved
-		// Move msg x bytes left.
-		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
-		o.buf = o.buf[:len(o.buf)+x] // x is negative
-	}
-	// Encode the length in the reserved space.
-	o.buf = o.buf[:iLen]
-	o.EncodeVarint(uint64(lMsg))
-	o.buf = o.buf[:len(o.buf)+lMsg]
-	return state.err
-}
-
-// errorState maintains the first error that occurs and updates that error
-// with additional context.
-type errorState struct {
-	err error
-}
-
-// shouldContinue reports whether encoding should continue upon encountering the
-// given error. If the error is RequiredNotSetError, shouldContinue returns true
-// and, if this is the first appearance of that error, remembers it for future
-// reporting.
-//
-// If prop is not nil, it may update any error with additional context about the
-// field with the error.
-func (s *errorState) shouldContinue(err error, prop *Properties) bool {
-	// Ignore unset required fields.
-	reqNotSet, ok := err.(*RequiredNotSetError)
-	if !ok {
-		return false
-	}
-	if s.err == nil {
-		if prop != nil {
-			err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}
-		}
-		s.err = err
-	}
-	return true
-}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
deleted file mode 100644
index 2ed1cf596664d3dedb372fc051a04b79da040f21..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/equal.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2011 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Protocol buffer comparison.
-
-package proto
-
-import (
-	"bytes"
-	"log"
-	"reflect"
-	"strings"
-)
-
-/*
-Equal returns true iff protocol buffers a and b are equal.
-The arguments must both be pointers to protocol buffer structs.
-
-Equality is defined in this way:
-  - Two messages are equal iff they are the same type,
-    corresponding fields are equal, unknown field sets
-    are equal, and extensions sets are equal.
-  - Two set scalar fields are equal iff their values are equal.
-    If the fields are of a floating-point type, remember that
-    NaN != x for all x, including NaN. If the message is defined
-    in a proto3 .proto file, fields are not "set"; specifically,
-    zero length proto3 "bytes" fields are equal (nil == {}).
-  - Two repeated fields are equal iff their lengths are the same,
-    and their corresponding elements are equal. Note a "bytes" field,
-    although represented by []byte, is not a repeated field and the
-    rule for the scalar fields described above applies.
-  - Two unset fields are equal.
-  - Two unknown field sets are equal if their current
-    encoded state is equal.
-  - Two extension sets are equal iff they have corresponding
-    elements that are pairwise equal.
-  - Two map fields are equal iff their lengths are the same,
-    and they contain the same set of elements. Zero-length map
-    fields are equal.
-  - Every other combination of things are not equal.
-
-The return value is undefined if a and b are not protocol buffers.
-*/
-func Equal(a, b Message) bool {
-	if a == nil || b == nil {
-		return a == b
-	}
-	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
-	if v1.Type() != v2.Type() {
-		return false
-	}
-	if v1.Kind() == reflect.Ptr {
-		if v1.IsNil() {
-			return v2.IsNil()
-		}
-		if v2.IsNil() {
-			return false
-		}
-		v1, v2 = v1.Elem(), v2.Elem()
-	}
-	if v1.Kind() != reflect.Struct {
-		return false
-	}
-	return equalStruct(v1, v2)
-}
-
-// v1 and v2 are known to have the same type.
-func equalStruct(v1, v2 reflect.Value) bool {
-	sprop := GetProperties(v1.Type())
-	for i := 0; i < v1.NumField(); i++ {
-		f := v1.Type().Field(i)
-		if strings.HasPrefix(f.Name, "XXX_") {
-			continue
-		}
-		f1, f2 := v1.Field(i), v2.Field(i)
-		if f.Type.Kind() == reflect.Ptr {
-			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
-				// both unset
-				continue
-			} else if n1 != n2 {
-				// set/unset mismatch
-				return false
-			}
-			b1, ok := f1.Interface().(raw)
-			if ok {
-				b2 := f2.Interface().(raw)
-				// RawMessage
-				if !bytes.Equal(b1.Bytes(), b2.Bytes()) {
-					return false
-				}
-				continue
-			}
-			f1, f2 = f1.Elem(), f2.Elem()
-		}
-		if !equalAny(f1, f2, sprop.Prop[i]) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_InternalExtensions")
-		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
-			return false
-		}
-	}
-
-	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
-		em2 := v2.FieldByName("XXX_extensions")
-		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
-			return false
-		}
-	}
-
-	uf := v1.FieldByName("XXX_unrecognized")
-	if !uf.IsValid() {
-		return true
-	}
-
-	u1 := uf.Bytes()
-	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
-	if !bytes.Equal(u1, u2) {
-		return false
-	}
-
-	return true
-}
-
-// v1 and v2 are known to have the same type.
-// prop may be nil.
-func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
-	if v1.Type() == protoMessageType {
-		m1, _ := v1.Interface().(Message)
-		m2, _ := v2.Interface().(Message)
-		return Equal(m1, m2)
-	}
-	switch v1.Kind() {
-	case reflect.Bool:
-		return v1.Bool() == v2.Bool()
-	case reflect.Float32, reflect.Float64:
-		return v1.Float() == v2.Float()
-	case reflect.Int32, reflect.Int64:
-		return v1.Int() == v2.Int()
-	case reflect.Interface:
-		// Probably a oneof field; compare the inner values.
-		n1, n2 := v1.IsNil(), v2.IsNil()
-		if n1 || n2 {
-			return n1 == n2
-		}
-		e1, e2 := v1.Elem(), v2.Elem()
-		if e1.Type() != e2.Type() {
-			return false
-		}
-		return equalAny(e1, e2, nil)
-	case reflect.Map:
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for _, key := range v1.MapKeys() {
-			val2 := v2.MapIndex(key)
-			if !val2.IsValid() {
-				// This key was not found in the second map.
-				return false
-			}
-			if !equalAny(v1.MapIndex(key), val2, nil) {
-				return false
-			}
-		}
-		return true
-	case reflect.Ptr:
-		// Maps may have nil values in them, so check for nil.
-		if v1.IsNil() && v2.IsNil() {
-			return true
-		}
-		if v1.IsNil() != v2.IsNil() {
-			return false
-		}
-		return equalAny(v1.Elem(), v2.Elem(), prop)
-	case reflect.Slice:
-		if v1.Type().Elem().Kind() == reflect.Uint8 {
-			// short circuit: []byte
-
-			// Edge case: if this is in a proto3 message, a zero length
-			// bytes field is considered the zero value.
-			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
-				return true
-			}
-			if v1.IsNil() != v2.IsNil() {
-				return false
-			}
-			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
-		}
-
-		if v1.Len() != v2.Len() {
-			return false
-		}
-		for i := 0; i < v1.Len(); i++ {
-			if !equalAny(v1.Index(i), v2.Index(i), prop) {
-				return false
-			}
-		}
-		return true
-	case reflect.String:
-		return v1.Interface().(string) == v2.Interface().(string)
-	case reflect.Struct:
-		return equalStruct(v1, v2)
-	case reflect.Uint32, reflect.Uint64:
-		return v1.Uint() == v2.Uint()
-	}
-
-	// unknown type, so not a protocol buffer
-	log.Printf("proto: don't know how to compare %v", v1)
-	return false
-}
-
-// base is the struct type that the extensions are based on.
-// x1 and x2 are InternalExtensions.
-func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
-	em1, _ := x1.extensionsRead()
-	em2, _ := x2.extensionsRead()
-	return equalExtMap(base, em1, em2)
-}
-
-func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
-	if len(em1) != len(em2) {
-		return false
-	}
-
-	for extNum, e1 := range em1 {
-		e2, ok := em2[extNum]
-		if !ok {
-			return false
-		}
-
-		m1, m2 := e1.value, e2.value
-
-		if m1 != nil && m2 != nil {
-			// Both are unencoded.
-			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-				return false
-			}
-			continue
-		}
-
-		// At least one is encoded. To do a semantically correct comparison
-		// we need to unmarshal them first.
-		var desc *ExtensionDesc
-		if m := extensionMaps[base]; m != nil {
-			desc = m[extNum]
-		}
-		if desc == nil {
-			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
-			continue
-		}
-		var err error
-		if m1 == nil {
-			m1, err = decodeExtension(e1.enc, desc)
-		}
-		if m2 == nil && err == nil {
-			m2, err = decodeExtension(e2.enc, desc)
-		}
-		if err != nil {
-			// The encoded form is invalid.
-			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
-			return false
-		}
-		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
-			return false
-		}
-	}
-
-	return true
-}
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
deleted file mode 100644
index eaad21831263eecc5add3fa980847857d2123bf2..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ /dev/null
@@ -1,587 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Types and routines for supporting protocol buffer extensions.
- */
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"sync"
-)
-
-// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
-var ErrMissingExtension = errors.New("proto: missing extension")
-
-// ExtensionRange represents a range of message extensions for a protocol buffer.
-// Used in code generated by the protocol compiler.
-type ExtensionRange struct {
-	Start, End int32 // both inclusive
-}
-
-// extendableProto is an interface implemented by any protocol buffer generated by the current
-// proto compiler that may be extended.
-type extendableProto interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	extensionsWrite() map[int32]Extension
-	extensionsRead() (map[int32]Extension, sync.Locker)
-}
-
-// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
-// version of the proto compiler that may be extended.
-type extendableProtoV1 interface {
-	Message
-	ExtensionRangeArray() []ExtensionRange
-	ExtensionMap() map[int32]Extension
-}
-
-// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
-type extensionAdapter struct {
-	extendableProtoV1
-}
-
-func (e extensionAdapter) extensionsWrite() map[int32]Extension {
-	return e.ExtensionMap()
-}
-
-func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
-	return e.ExtensionMap(), notLocker{}
-}
-
-// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
-type notLocker struct{}
-
-func (n notLocker) Lock()   {}
-func (n notLocker) Unlock() {}
-
-// extendable returns the extendableProto interface for the given generated proto message.
-// If the proto message has the old extension format, it returns a wrapper that implements
-// the extendableProto interface.
-func extendable(p interface{}) (extendableProto, bool) {
-	if ep, ok := p.(extendableProto); ok {
-		return ep, ok
-	}
-	if ep, ok := p.(extendableProtoV1); ok {
-		return extensionAdapter{ep}, ok
-	}
-	return nil, false
-}
-
-// XXX_InternalExtensions is an internal representation of proto extensions.
-//
-// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
-// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
-//
-// The methods of XXX_InternalExtensions are not concurrency safe in general,
-// but calls to logically read-only methods such as has and get may be executed concurrently.
-type XXX_InternalExtensions struct {
-	// The struct must be indirect so that if a user inadvertently copies a
-	// generated message and its embedded XXX_InternalExtensions, they
-	// avoid the mayhem of a copied mutex.
-	//
-	// The mutex serializes all logically read-only operations to p.extensionMap.
-	// It is up to the client to ensure that write operations to p.extensionMap are
-	// mutually exclusive with other accesses.
-	p *struct {
-		mu           sync.Mutex
-		extensionMap map[int32]Extension
-	}
-}
-
-// extensionsWrite returns the extension map, creating it on first use.
-func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
-	if e.p == nil {
-		e.p = new(struct {
-			mu           sync.Mutex
-			extensionMap map[int32]Extension
-		})
-		e.p.extensionMap = make(map[int32]Extension)
-	}
-	return e.p.extensionMap
-}
-
-// extensionsRead returns the extensions map for read-only use.  It may be nil.
-// The caller must hold the returned mutex's lock when accessing Elements within the map.
-func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
-	if e.p == nil {
-		return nil, nil
-	}
-	return e.p.extensionMap, &e.p.mu
-}
-
-var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
-var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()
-
-// ExtensionDesc represents an extension specification.
-// Used in generated code from the protocol compiler.
-type ExtensionDesc struct {
-	ExtendedType  Message     // nil pointer to the type that is being extended
-	ExtensionType interface{} // nil pointer to the extension type
-	Field         int32       // field number
-	Name          string      // fully-qualified name of extension, for text formatting
-	Tag           string      // protobuf tag style
-	Filename      string      // name of the file in which the extension is defined
-}
-
-func (ed *ExtensionDesc) repeated() bool {
-	t := reflect.TypeOf(ed.ExtensionType)
-	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
-}
-
-// Extension represents an extension in a message.
-type Extension struct {
-	// When an extension is stored in a message using SetExtension
-	// only desc and value are set. When the message is marshaled
-	// enc will be set to the encoded form of the message.
-	//
-	// When a message is unmarshaled and contains extensions, each
-	// extension will have only enc set. When such an extension is
-	// accessed using GetExtension (or GetExtensions) desc and value
-	// will be set.
-	desc  *ExtensionDesc
-	value interface{}
-	enc   []byte
-}
-
-// SetRawExtension is for testing only.
-func SetRawExtension(base Message, id int32, b []byte) {
-	epb, ok := extendable(base)
-	if !ok {
-		return
-	}
-	extmap := epb.extensionsWrite()
-	extmap[id] = Extension{enc: b}
-}
-
-// isExtensionField returns true iff the given field number is in an extension range.
-func isExtensionField(pb extendableProto, field int32) bool {
-	for _, er := range pb.ExtensionRangeArray() {
-		if er.Start <= field && field <= er.End {
-			return true
-		}
-	}
-	return false
-}
-
-// checkExtensionTypes checks that the given extension is valid for pb.
-func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
-	var pbi interface{} = pb
-	// Check the extended type.
-	if ea, ok := pbi.(extensionAdapter); ok {
-		pbi = ea.extendableProtoV1
-	}
-	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
-		return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
-	}
-	// Check the range.
-	if !isExtensionField(pb, extension.Field) {
-		return errors.New("proto: bad extension number; not in declared ranges")
-	}
-	return nil
-}
-
-// extPropKey is sufficient to uniquely identify an extension.
-type extPropKey struct {
-	base  reflect.Type
-	field int32
-}
-
-var extProp = struct {
-	sync.RWMutex
-	m map[extPropKey]*Properties
-}{
-	m: make(map[extPropKey]*Properties),
-}
-
-func extensionProperties(ed *ExtensionDesc) *Properties {
-	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
-
-	extProp.RLock()
-	if prop, ok := extProp.m[key]; ok {
-		extProp.RUnlock()
-		return prop
-	}
-	extProp.RUnlock()
-
-	extProp.Lock()
-	defer extProp.Unlock()
-	// Check again.
-	if prop, ok := extProp.m[key]; ok {
-		return prop
-	}
-
-	prop := new(Properties)
-	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
-	extProp.m[key] = prop
-	return prop
-}
-
-// encode encodes any unmarshaled (unencoded) extensions in e.
-func encodeExtensions(e *XXX_InternalExtensions) error {
-	m, mu := e.extensionsRead()
-	if m == nil {
-		return nil // fast path
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	return encodeExtensionsMap(m)
-}
-
-// encode encodes any unmarshaled (unencoded) extensions in e.
-func encodeExtensionsMap(m map[int32]Extension) error {
-	for k, e := range m {
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		et := reflect.TypeOf(e.desc.ExtensionType)
-		props := extensionProperties(e.desc)
-
-		p := NewBuffer(nil)
-		// If e.value has type T, the encoder expects a *struct{ X T }.
-		// Pass a *T with a zero field and hope it all works out.
-		x := reflect.New(et)
-		x.Elem().Set(reflect.ValueOf(e.value))
-		if err := props.enc(p, props, toStructPointer(x)); err != nil {
-			return err
-		}
-		e.enc = p.buf
-		m[k] = e
-	}
-	return nil
-}
-
-func extensionsSize(e *XXX_InternalExtensions) (n int) {
-	m, mu := e.extensionsRead()
-	if m == nil {
-		return 0
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	return extensionsMapSize(m)
-}
-
-func extensionsMapSize(m map[int32]Extension) (n int) {
-	for _, e := range m {
-		if e.value == nil || e.desc == nil {
-			// Extension is only in its encoded form.
-			n += len(e.enc)
-			continue
-		}
-
-		// We don't skip extensions that have an encoded form set,
-		// because the extension value may have been mutated after
-		// the last time this function was called.
-
-		et := reflect.TypeOf(e.desc.ExtensionType)
-		props := extensionProperties(e.desc)
-
-		// If e.value has type T, the encoder expects a *struct{ X T }.
-		// Pass a *T with a zero field and hope it all works out.
-		x := reflect.New(et)
-		x.Elem().Set(reflect.ValueOf(e.value))
-		n += props.size(props, toStructPointer(x))
-	}
-	return
-}
-
-// HasExtension returns whether the given extension is present in pb.
-func HasExtension(pb Message, extension *ExtensionDesc) bool {
-	// TODO: Check types, field numbers, etc.?
-	epb, ok := extendable(pb)
-	if !ok {
-		return false
-	}
-	extmap, mu := epb.extensionsRead()
-	if extmap == nil {
-		return false
-	}
-	mu.Lock()
-	_, ok = extmap[extension.Field]
-	mu.Unlock()
-	return ok
-}
-
-// ClearExtension removes the given extension from pb.
-func ClearExtension(pb Message, extension *ExtensionDesc) {
-	epb, ok := extendable(pb)
-	if !ok {
-		return
-	}
-	// TODO: Check types, field numbers, etc.?
-	extmap := epb.extensionsWrite()
-	delete(extmap, extension.Field)
-}
-
-// GetExtension parses and returns the given extension of pb.
-// If the extension is not present and has no default value it returns ErrMissingExtension.
-func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
-	epb, ok := extendable(pb)
-	if !ok {
-		return nil, errors.New("proto: not an extendable proto")
-	}
-
-	if err := checkExtensionTypes(epb, extension); err != nil {
-		return nil, err
-	}
-
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return defaultExtensionValue(extension)
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	e, ok := emap[extension.Field]
-	if !ok {
-		// defaultExtensionValue returns the default value or
-		// ErrMissingExtension if there is no default.
-		return defaultExtensionValue(extension)
-	}
-
-	if e.value != nil {
-		// Already decoded. Check the descriptor, though.
-		if e.desc != extension {
-			// This shouldn't happen. If it does, it means that
-			// GetExtension was called twice with two different
-			// descriptors with the same field number.
-			return nil, errors.New("proto: descriptor conflict")
-		}
-		return e.value, nil
-	}
-
-	v, err := decodeExtension(e.enc, extension)
-	if err != nil {
-		return nil, err
-	}
-
-	// Remember the decoded version and drop the encoded version.
-	// That way it is safe to mutate what we return.
-	e.value = v
-	e.desc = extension
-	e.enc = nil
-	emap[extension.Field] = e
-	return e.value, nil
-}
-
-// defaultExtensionValue returns the default value for extension.
-// If no default for an extension is defined ErrMissingExtension is returned.
-func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
-	t := reflect.TypeOf(extension.ExtensionType)
-	props := extensionProperties(extension)
-
-	sf, _, err := fieldDefault(t, props)
-	if err != nil {
-		return nil, err
-	}
-
-	if sf == nil || sf.value == nil {
-		// There is no default value.
-		return nil, ErrMissingExtension
-	}
-
-	if t.Kind() != reflect.Ptr {
-		// We do not need to return a Ptr, we can directly return sf.value.
-		return sf.value, nil
-	}
-
-	// We need to return an interface{} that is a pointer to sf.value.
-	value := reflect.New(t).Elem()
-	value.Set(reflect.New(value.Type().Elem()))
-	if sf.kind == reflect.Int32 {
-		// We may have an int32 or an enum, but the underlying data is int32.
-		// Since we can't set an int32 into a non int32 reflect.value directly
-		// set it as a int32.
-		value.Elem().SetInt(int64(sf.value.(int32)))
-	} else {
-		value.Elem().Set(reflect.ValueOf(sf.value))
-	}
-	return value.Interface(), nil
-}
-
-// decodeExtension decodes an extension encoded in b.
-func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
-	o := NewBuffer(b)
-
-	t := reflect.TypeOf(extension.ExtensionType)
-
-	props := extensionProperties(extension)
-
-	// t is a pointer to a struct, pointer to basic type or a slice.
-	// Allocate a "field" to store the pointer/slice itself; the
-	// pointer/slice will be stored here. We pass
-	// the address of this field to props.dec.
-	// This passes a zero field and a *t and lets props.dec
-	// interpret it as a *struct{ x t }.
-	value := reflect.New(t).Elem()
-
-	for {
-		// Discard wire type and field number varint. It isn't needed.
-		if _, err := o.DecodeVarint(); err != nil {
-			return nil, err
-		}
-
-		if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil {
-			return nil, err
-		}
-
-		if o.index >= len(o.buf) {
-			break
-		}
-	}
-	return value.Interface(), nil
-}
-
-// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
-// The returned slice has the same length as es; missing extensions will appear as nil elements.
-func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
-	epb, ok := extendable(pb)
-	if !ok {
-		return nil, errors.New("proto: not an extendable proto")
-	}
-	extensions = make([]interface{}, len(es))
-	for i, e := range es {
-		extensions[i], err = GetExtension(epb, e)
-		if err == ErrMissingExtension {
-			err = nil
-		}
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
-// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
-// just the Field field, which defines the extension's field number.
-func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
-	epb, ok := extendable(pb)
-	if !ok {
-		return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)
-	}
-	registeredExtensions := RegisteredExtensions(pb)
-
-	emap, mu := epb.extensionsRead()
-	if emap == nil {
-		return nil, nil
-	}
-	mu.Lock()
-	defer mu.Unlock()
-	extensions := make([]*ExtensionDesc, 0, len(emap))
-	for extid, e := range emap {
-		desc := e.desc
-		if desc == nil {
-			desc = registeredExtensions[extid]
-			if desc == nil {
-				desc = &ExtensionDesc{Field: extid}
-			}
-		}
-
-		extensions = append(extensions, desc)
-	}
-	return extensions, nil
-}
-
-// SetExtension sets the specified extension of pb to the specified value.
-func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
-	epb, ok := extendable(pb)
-	if !ok {
-		return errors.New("proto: not an extendable proto")
-	}
-	if err := checkExtensionTypes(epb, extension); err != nil {
-		return err
-	}
-	typ := reflect.TypeOf(extension.ExtensionType)
-	if typ != reflect.TypeOf(value) {
-		return errors.New("proto: bad extension value type")
-	}
-	// nil extension values need to be caught early, because the
-	// encoder can't distinguish an ErrNil due to a nil extension
-	// from an ErrNil due to a missing field. Extensions are
-	// always optional, so the encoder would just swallow the error
-	// and drop all the extensions from the encoded message.
-	if reflect.ValueOf(value).IsNil() {
-		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
-	}
-
-	extmap := epb.extensionsWrite()
-	extmap[extension.Field] = Extension{desc: extension, value: value}
-	return nil
-}
-
-// ClearAllExtensions clears all extensions from pb.
-func ClearAllExtensions(pb Message) {
-	epb, ok := extendable(pb)
-	if !ok {
-		return
-	}
-	m := epb.extensionsWrite()
-	for k := range m {
-		delete(m, k)
-	}
-}
-
-// A global registry of extensions.
-// The generated code will register the generated descriptors by calling RegisterExtension.
-
-var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
-
-// RegisterExtension is called from the generated code.
-func RegisterExtension(desc *ExtensionDesc) {
-	st := reflect.TypeOf(desc.ExtendedType).Elem()
-	m := extensionMaps[st]
-	if m == nil {
-		m = make(map[int32]*ExtensionDesc)
-		extensionMaps[st] = m
-	}
-	if _, ok := m[desc.Field]; ok {
-		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
-	}
-	m[desc.Field] = desc
-}
-
-// RegisteredExtensions returns a map of the registered extensions of a
-// protocol buffer struct, indexed by the extension number.
-// The argument pb should be a nil pointer to the struct type.
-func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
-	return extensionMaps[reflect.TypeOf(pb).Elem()]
-}
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
deleted file mode 100644
index 1c225504a013c5da68f5b46caa5c110dd32db6cf..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/lib.go
+++ /dev/null
@@ -1,897 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/*
-Package proto converts data structures to and from the wire format of
-protocol buffers.  It works in concert with the Go source code generated
-for .proto files by the protocol compiler.
-
-A summary of the properties of the protocol buffer interface
-for a protocol buffer variable v:
-
-  - Names are turned from camel_case to CamelCase for export.
-  - There are no methods on v to set fields; just treat
-	them as structure fields.
-  - There are getters that return a field's value if set,
-	and return the field's default value if unset.
-	The getters work even if the receiver is a nil message.
-  - The zero value for a struct is its correct initialization state.
-	All desired fields must be set before marshaling.
-  - A Reset() method will restore a protobuf struct to its zero state.
-  - Non-repeated fields are pointers to the values; nil means unset.
-	That is, optional or required field int32 f becomes F *int32.
-  - Repeated fields are slices.
-  - Helper functions are available to aid the setting of fields.
-	msg.Foo = proto.String("hello") // set field
-  - Constants are defined to hold the default values of all fields that
-	have them.  They have the form Default_StructName_FieldName.
-	Because the getter methods handle defaulted values,
-	direct use of these constants should be rare.
-  - Enums are given type names and maps from names to values.
-	Enum values are prefixed by the enclosing message's name, or by the
-	enum's type name if it is a top-level enum. Enum types have a String
-	method, and a Enum method to assist in message construction.
-  - Nested messages, groups and enums have type names prefixed with the name of
-	the surrounding message type.
-  - Extensions are given descriptor names that start with E_,
-	followed by an underscore-delimited list of the nested messages
-	that contain it (if any) followed by the CamelCased name of the
-	extension field itself.  HasExtension, ClearExtension, GetExtension
-	and SetExtension are functions for manipulating extensions.
-  - Oneof field sets are given a single field in their message,
-	with distinguished wrapper types for each possible field value.
-  - Marshal and Unmarshal are functions to encode and decode the wire format.
-
-When the .proto file specifies `syntax="proto3"`, there are some differences:
-
-  - Non-repeated fields of non-message type are values instead of pointers.
-  - Enum types do not get an Enum method.
-
-The simplest way to describe this is to see an example.
-Given file test.proto, containing
-
-	package example;
-
-	enum FOO { X = 17; }
-
-	message Test {
-	  required string label = 1;
-	  optional int32 type = 2 [default=77];
-	  repeated int64 reps = 3;
-	  optional group OptionalGroup = 4 {
-	    required string RequiredField = 5;
-	  }
-	  oneof union {
-	    int32 number = 6;
-	    string name = 7;
-	  }
-	}
-
-The resulting file, test.pb.go, is:
-
-	package example
-
-	import proto "github.com/golang/protobuf/proto"
-	import math "math"
-
-	type FOO int32
-	const (
-		FOO_X FOO = 17
-	)
-	var FOO_name = map[int32]string{
-		17: "X",
-	}
-	var FOO_value = map[string]int32{
-		"X": 17,
-	}
-
-	func (x FOO) Enum() *FOO {
-		p := new(FOO)
-		*p = x
-		return p
-	}
-	func (x FOO) String() string {
-		return proto.EnumName(FOO_name, int32(x))
-	}
-	func (x *FOO) UnmarshalJSON(data []byte) error {
-		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
-		if err != nil {
-			return err
-		}
-		*x = FOO(value)
-		return nil
-	}
-
-	type Test struct {
-		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
-		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
-		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
-		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
-		// Types that are valid to be assigned to Union:
-		//	*Test_Number
-		//	*Test_Name
-		Union            isTest_Union `protobuf_oneof:"union"`
-		XXX_unrecognized []byte       `json:"-"`
-	}
-	func (m *Test) Reset()         { *m = Test{} }
-	func (m *Test) String() string { return proto.CompactTextString(m) }
-	func (*Test) ProtoMessage() {}
-
-	type isTest_Union interface {
-		isTest_Union()
-	}
-
-	type Test_Number struct {
-		Number int32 `protobuf:"varint,6,opt,name=number"`
-	}
-	type Test_Name struct {
-		Name string `protobuf:"bytes,7,opt,name=name"`
-	}
-
-	func (*Test_Number) isTest_Union() {}
-	func (*Test_Name) isTest_Union()   {}
-
-	func (m *Test) GetUnion() isTest_Union {
-		if m != nil {
-			return m.Union
-		}
-		return nil
-	}
-	const Default_Test_Type int32 = 77
-
-	func (m *Test) GetLabel() string {
-		if m != nil && m.Label != nil {
-			return *m.Label
-		}
-		return ""
-	}
-
-	func (m *Test) GetType() int32 {
-		if m != nil && m.Type != nil {
-			return *m.Type
-		}
-		return Default_Test_Type
-	}
-
-	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
-		if m != nil {
-			return m.Optionalgroup
-		}
-		return nil
-	}
-
-	type Test_OptionalGroup struct {
-		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
-	}
-	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
-	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
-
-	func (m *Test_OptionalGroup) GetRequiredField() string {
-		if m != nil && m.RequiredField != nil {
-			return *m.RequiredField
-		}
-		return ""
-	}
-
-	func (m *Test) GetNumber() int32 {
-		if x, ok := m.GetUnion().(*Test_Number); ok {
-			return x.Number
-		}
-		return 0
-	}
-
-	func (m *Test) GetName() string {
-		if x, ok := m.GetUnion().(*Test_Name); ok {
-			return x.Name
-		}
-		return ""
-	}
-
-	func init() {
-		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
-	}
-
-To create and play with a Test object:
-
-	package main
-
-	import (
-		"log"
-
-		"github.com/golang/protobuf/proto"
-		pb "./example.pb"
-	)
-
-	func main() {
-		test := &pb.Test{
-			Label: proto.String("hello"),
-			Type:  proto.Int32(17),
-			Reps:  []int64{1, 2, 3},
-			Optionalgroup: &pb.Test_OptionalGroup{
-				RequiredField: proto.String("good bye"),
-			},
-			Union: &pb.Test_Name{"fred"},
-		}
-		data, err := proto.Marshal(test)
-		if err != nil {
-			log.Fatal("marshaling error: ", err)
-		}
-		newTest := &pb.Test{}
-		err = proto.Unmarshal(data, newTest)
-		if err != nil {
-			log.Fatal("unmarshaling error: ", err)
-		}
-		// Now test and newTest contain the same data.
-		if test.GetLabel() != newTest.GetLabel() {
-			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
-		}
-		// Use a type switch to determine which oneof was set.
-		switch u := test.Union.(type) {
-		case *pb.Test_Number: // u.Number contains the number.
-		case *pb.Test_Name: // u.Name contains the string.
-		}
-		// etc.
-	}
-*/
-package proto
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"reflect"
-	"sort"
-	"strconv"
-	"sync"
-)
-
-// Message is implemented by generated protocol buffer messages.
-type Message interface {
-	Reset()
-	String() string
-	ProtoMessage()
-}
-
-// Stats records allocation details about the protocol buffer encoders
-// and decoders.  Useful for tuning the library itself.
-type Stats struct {
-	Emalloc uint64 // mallocs in encode
-	Dmalloc uint64 // mallocs in decode
-	Encode  uint64 // number of encodes
-	Decode  uint64 // number of decodes
-	Chit    uint64 // number of cache hits
-	Cmiss   uint64 // number of cache misses
-	Size    uint64 // number of sizes
-}
-
-// Set to true to enable stats collection.
-const collectStats = false
-
-var stats Stats
-
-// GetStats returns a copy of the global Stats structure.
-func GetStats() Stats { return stats }
-
-// A Buffer is a buffer manager for marshaling and unmarshaling
-// protocol buffers.  It may be reused between invocations to
-// reduce memory usage.  It is not necessary to use a Buffer;
-// the global functions Marshal and Unmarshal create a
-// temporary Buffer and are fine for most applications.
-type Buffer struct {
-	buf   []byte // encode/decode byte stream
-	index int    // read point
-
-	// pools of basic types to amortize allocation.
-	bools   []bool
-	uint32s []uint32
-	uint64s []uint64
-
-	// extra pools, only used with pointer_reflect.go
-	int32s   []int32
-	int64s   []int64
-	float32s []float32
-	float64s []float64
-}
-
-// NewBuffer allocates a new Buffer and initializes its internal data to
-// the contents of the argument slice.
-func NewBuffer(e []byte) *Buffer {
-	return &Buffer{buf: e}
-}
-
-// Reset resets the Buffer, ready for marshaling a new protocol buffer.
-func (p *Buffer) Reset() {
-	p.buf = p.buf[0:0] // for reading/writing
-	p.index = 0        // for reading
-}
-
-// SetBuf replaces the internal buffer with the slice,
-// ready for unmarshaling the contents of the slice.
-func (p *Buffer) SetBuf(s []byte) {
-	p.buf = s
-	p.index = 0
-}
-
-// Bytes returns the contents of the Buffer.
-func (p *Buffer) Bytes() []byte { return p.buf }
-
-/*
- * Helper routines for simplifying the creation of optional fields of basic type.
- */
-
-// Bool is a helper routine that allocates a new bool value
-// to store v and returns a pointer to it.
-func Bool(v bool) *bool {
-	return &v
-}
-
-// Int32 is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it.
-func Int32(v int32) *int32 {
-	return &v
-}
-
-// Int is a helper routine that allocates a new int32 value
-// to store v and returns a pointer to it, but unlike Int32
-// its argument value is an int.
-func Int(v int) *int32 {
-	p := new(int32)
-	*p = int32(v)
-	return p
-}
-
-// Int64 is a helper routine that allocates a new int64 value
-// to store v and returns a pointer to it.
-func Int64(v int64) *int64 {
-	return &v
-}
-
-// Float32 is a helper routine that allocates a new float32 value
-// to store v and returns a pointer to it.
-func Float32(v float32) *float32 {
-	return &v
-}
-
-// Float64 is a helper routine that allocates a new float64 value
-// to store v and returns a pointer to it.
-func Float64(v float64) *float64 {
-	return &v
-}
-
-// Uint32 is a helper routine that allocates a new uint32 value
-// to store v and returns a pointer to it.
-func Uint32(v uint32) *uint32 {
-	return &v
-}
-
-// Uint64 is a helper routine that allocates a new uint64 value
-// to store v and returns a pointer to it.
-func Uint64(v uint64) *uint64 {
-	return &v
-}
-
-// String is a helper routine that allocates a new string value
-// to store v and returns a pointer to it.
-func String(v string) *string {
-	return &v
-}
-
-// EnumName is a helper function to simplify printing protocol buffer enums
-// by name.  Given an enum map and a value, it returns a useful string.
-func EnumName(m map[int32]string, v int32) string {
-	s, ok := m[v]
-	if ok {
-		return s
-	}
-	return strconv.Itoa(int(v))
-}
-
-// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
-// from their JSON-encoded representation. Given a map from the enum's symbolic
-// names to its int values, and a byte buffer containing the JSON-encoded
-// value, it returns an int32 that can be cast to the enum type by the caller.
-//
-// The function can deal with both JSON representations, numeric and symbolic.
-func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
-	if data[0] == '"' {
-		// New style: enums are strings.
-		var repr string
-		if err := json.Unmarshal(data, &repr); err != nil {
-			return -1, err
-		}
-		val, ok := m[repr]
-		if !ok {
-			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
-		}
-		return val, nil
-	}
-	// Old style: enums are ints.
-	var val int32
-	if err := json.Unmarshal(data, &val); err != nil {
-		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
-	}
-	return val, nil
-}
-
-// DebugPrint dumps the encoded data in b in a debugging format with a header
-// including the string s. Used in testing but made available for general debugging.
-func (p *Buffer) DebugPrint(s string, b []byte) {
-	var u uint64
-
-	obuf := p.buf
-	index := p.index
-	p.buf = b
-	p.index = 0
-	depth := 0
-
-	fmt.Printf("\n--- %s ---\n", s)
-
-out:
-	for {
-		for i := 0; i < depth; i++ {
-			fmt.Print("  ")
-		}
-
-		index := p.index
-		if index == len(p.buf) {
-			break
-		}
-
-		op, err := p.DecodeVarint()
-		if err != nil {
-			fmt.Printf("%3d: fetching op err %v\n", index, err)
-			break out
-		}
-		tag := op >> 3
-		wire := op & 7
-
-		switch wire {
-		default:
-			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
-				index, tag, wire)
-			break out
-
-		case WireBytes:
-			var r []byte
-
-			r, err = p.DecodeRawBytes(false)
-			if err != nil {
-				break out
-			}
-			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
-			if len(r) <= 6 {
-				for i := 0; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			} else {
-				for i := 0; i < 3; i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-				fmt.Printf(" ..")
-				for i := len(r) - 3; i < len(r); i++ {
-					fmt.Printf(" %.2x", r[i])
-				}
-			}
-			fmt.Printf("\n")
-
-		case WireFixed32:
-			u, err = p.DecodeFixed32()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
-
-		case WireFixed64:
-			u, err = p.DecodeFixed64()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
-
-		case WireVarint:
-			u, err = p.DecodeVarint()
-			if err != nil {
-				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
-				break out
-			}
-			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
-
-		case WireStartGroup:
-			fmt.Printf("%3d: t=%3d start\n", index, tag)
-			depth++
-
-		case WireEndGroup:
-			depth--
-			fmt.Printf("%3d: t=%3d end\n", index, tag)
-		}
-	}
-
-	if depth != 0 {
-		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
-	}
-	fmt.Printf("\n")
-
-	p.buf = obuf
-	p.index = index
-}
-
-// SetDefaults sets unset protocol buffer fields to their default values.
-// It only modifies fields that are both unset and have defined defaults.
-// It recursively sets default values in any non-nil sub-messages.
-func SetDefaults(pb Message) {
-	setDefaults(reflect.ValueOf(pb), true, false)
-}
-
-// v is a pointer to a struct.
-func setDefaults(v reflect.Value, recur, zeros bool) {
-	v = v.Elem()
-
-	defaultMu.RLock()
-	dm, ok := defaults[v.Type()]
-	defaultMu.RUnlock()
-	if !ok {
-		dm = buildDefaultMessage(v.Type())
-		defaultMu.Lock()
-		defaults[v.Type()] = dm
-		defaultMu.Unlock()
-	}
-
-	for _, sf := range dm.scalars {
-		f := v.Field(sf.index)
-		if !f.IsNil() {
-			// field already set
-			continue
-		}
-		dv := sf.value
-		if dv == nil && !zeros {
-			// no explicit default, and don't want to set zeros
-			continue
-		}
-		fptr := f.Addr().Interface() // **T
-		// TODO: Consider batching the allocations we do here.
-		switch sf.kind {
-		case reflect.Bool:
-			b := new(bool)
-			if dv != nil {
-				*b = dv.(bool)
-			}
-			*(fptr.(**bool)) = b
-		case reflect.Float32:
-			f := new(float32)
-			if dv != nil {
-				*f = dv.(float32)
-			}
-			*(fptr.(**float32)) = f
-		case reflect.Float64:
-			f := new(float64)
-			if dv != nil {
-				*f = dv.(float64)
-			}
-			*(fptr.(**float64)) = f
-		case reflect.Int32:
-			// might be an enum
-			if ft := f.Type(); ft != int32PtrType {
-				// enum
-				f.Set(reflect.New(ft.Elem()))
-				if dv != nil {
-					f.Elem().SetInt(int64(dv.(int32)))
-				}
-			} else {
-				// int32 field
-				i := new(int32)
-				if dv != nil {
-					*i = dv.(int32)
-				}
-				*(fptr.(**int32)) = i
-			}
-		case reflect.Int64:
-			i := new(int64)
-			if dv != nil {
-				*i = dv.(int64)
-			}
-			*(fptr.(**int64)) = i
-		case reflect.String:
-			s := new(string)
-			if dv != nil {
-				*s = dv.(string)
-			}
-			*(fptr.(**string)) = s
-		case reflect.Uint8:
-			// exceptional case: []byte
-			var b []byte
-			if dv != nil {
-				db := dv.([]byte)
-				b = make([]byte, len(db))
-				copy(b, db)
-			} else {
-				b = []byte{}
-			}
-			*(fptr.(*[]byte)) = b
-		case reflect.Uint32:
-			u := new(uint32)
-			if dv != nil {
-				*u = dv.(uint32)
-			}
-			*(fptr.(**uint32)) = u
-		case reflect.Uint64:
-			u := new(uint64)
-			if dv != nil {
-				*u = dv.(uint64)
-			}
-			*(fptr.(**uint64)) = u
-		default:
-			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
-		}
-	}
-
-	for _, ni := range dm.nested {
-		f := v.Field(ni)
-		// f is *T or []*T or map[T]*T
-		switch f.Kind() {
-		case reflect.Ptr:
-			if f.IsNil() {
-				continue
-			}
-			setDefaults(f, recur, zeros)
-
-		case reflect.Slice:
-			for i := 0; i < f.Len(); i++ {
-				e := f.Index(i)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-
-		case reflect.Map:
-			for _, k := range f.MapKeys() {
-				e := f.MapIndex(k)
-				if e.IsNil() {
-					continue
-				}
-				setDefaults(e, recur, zeros)
-			}
-		}
-	}
-}
-
-var (
-	// defaults maps a protocol buffer struct type to a slice of the fields,
-	// with its scalar fields set to their proto-declared non-zero default values.
-	defaultMu sync.RWMutex
-	defaults  = make(map[reflect.Type]defaultMessage)
-
-	int32PtrType = reflect.TypeOf((*int32)(nil))
-)
-
-// defaultMessage represents information about the default values of a message.
-type defaultMessage struct {
-	scalars []scalarField
-	nested  []int // struct field index of nested messages
-}
-
-type scalarField struct {
-	index int          // struct field index
-	kind  reflect.Kind // element type (the T in *T or []T)
-	value interface{}  // the proto-declared default value, or nil
-}
-
-// t is a struct type.
-func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
-	sprop := GetProperties(t)
-	for _, prop := range sprop.Prop {
-		fi, ok := sprop.decoderTags.get(prop.Tag)
-		if !ok {
-			// XXX_unrecognized
-			continue
-		}
-		ft := t.Field(fi).Type
-
-		sf, nested, err := fieldDefault(ft, prop)
-		switch {
-		case err != nil:
-			log.Print(err)
-		case nested:
-			dm.nested = append(dm.nested, fi)
-		case sf != nil:
-			sf.index = fi
-			dm.scalars = append(dm.scalars, *sf)
-		}
-	}
-
-	return dm
-}
-
-// fieldDefault returns the scalarField for field type ft.
-// sf will be nil if the field can not have a default.
-// nestedMessage will be true if this is a nested message.
-// Note that sf.index is not set on return.
-func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
-	var canHaveDefault bool
-	switch ft.Kind() {
-	case reflect.Ptr:
-		if ft.Elem().Kind() == reflect.Struct {
-			nestedMessage = true
-		} else {
-			canHaveDefault = true // proto2 scalar field
-		}
-
-	case reflect.Slice:
-		switch ft.Elem().Kind() {
-		case reflect.Ptr:
-			nestedMessage = true // repeated message
-		case reflect.Uint8:
-			canHaveDefault = true // bytes field
-		}
-
-	case reflect.Map:
-		if ft.Elem().Kind() == reflect.Ptr {
-			nestedMessage = true // map with message values
-		}
-	}
-
-	if !canHaveDefault {
-		if nestedMessage {
-			return nil, true, nil
-		}
-		return nil, false, nil
-	}
-
-	// We now know that ft is a pointer or slice.
-	sf = &scalarField{kind: ft.Elem().Kind()}
-
-	// scalar fields without defaults
-	if !prop.HasDefault {
-		return sf, false, nil
-	}
-
-	// a scalar field: either *T or []byte
-	switch ft.Elem().Kind() {
-	case reflect.Bool:
-		x, err := strconv.ParseBool(prop.Default)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Float32:
-		x, err := strconv.ParseFloat(prop.Default, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
-		}
-		sf.value = float32(x)
-	case reflect.Float64:
-		x, err := strconv.ParseFloat(prop.Default, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.Int32:
-		x, err := strconv.ParseInt(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
-		}
-		sf.value = int32(x)
-	case reflect.Int64:
-		x, err := strconv.ParseInt(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	case reflect.String:
-		sf.value = prop.Default
-	case reflect.Uint8:
-		// []byte (not *uint8)
-		sf.value = []byte(prop.Default)
-	case reflect.Uint32:
-		x, err := strconv.ParseUint(prop.Default, 10, 32)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
-		}
-		sf.value = uint32(x)
-	case reflect.Uint64:
-		x, err := strconv.ParseUint(prop.Default, 10, 64)
-		if err != nil {
-			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
-		}
-		sf.value = x
-	default:
-		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
-	}
-
-	return sf, false, nil
-}
-
-// Map fields may have key types of non-float scalars, strings and enums.
-// The easiest way to sort them in some deterministic order is to use fmt.
-// If this turns out to be inefficient we can always consider other options,
-// such as doing a Schwartzian transform.
-
-func mapKeys(vs []reflect.Value) sort.Interface {
-	s := mapKeySorter{
-		vs: vs,
-		// default Less function: textual comparison
-		less: func(a, b reflect.Value) bool {
-			return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())
-		},
-	}
-
-	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps;
-	// numeric keys are sorted numerically.
-	if len(vs) == 0 {
-		return s
-	}
-	switch vs[0].Kind() {
-	case reflect.Int32, reflect.Int64:
-		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
-	case reflect.Uint32, reflect.Uint64:
-		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
-	}
-
-	return s
-}
-
-type mapKeySorter struct {
-	vs   []reflect.Value
-	less func(a, b reflect.Value) bool
-}
-
-func (s mapKeySorter) Len() int      { return len(s.vs) }
-func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
-func (s mapKeySorter) Less(i, j int) bool {
-	return s.less(s.vs[i], s.vs[j])
-}
-
-// isProto3Zero reports whether v is a zero proto3 value.
-func isProto3Zero(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint32, reflect.Uint64:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.String:
-		return v.String() == ""
-	}
-	return false
-}
-
-// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion2 = true
-
-// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
-// to assert that that code is compatible with this version of the proto package.
-const ProtoPackageIsVersion1 = true
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
deleted file mode 100644
index fd982decd66e4846031a72a785470be20afe99a5..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/message_set.go
+++ /dev/null
@@ -1,311 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Support for message sets.
- */
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"sort"
-)
-
-// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
-// A message type ID is required for storing a protocol buffer in a message set.
-var errNoMessageTypeID = errors.New("proto does not have a message type ID")
-
-// The first two types (_MessageSet_Item and messageSet)
-// model what the protocol compiler produces for the following protocol message:
-//   message MessageSet {
-//     repeated group Item = 1 {
-//       required int32 type_id = 2;
-//       required string message = 3;
-//     };
-//   }
-// That is the MessageSet wire format. We can't use a proto to generate these
-// because that would introduce a circular dependency between it and this package.
-
-type _MessageSet_Item struct {
-	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
-	Message []byte `protobuf:"bytes,3,req,name=message"`
-}
-
-type messageSet struct {
-	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
-	XXX_unrecognized []byte
-	// TODO: caching?
-}
-
-// Make sure messageSet is a Message.
-var _ Message = (*messageSet)(nil)
-
-// messageTypeIder is an interface satisfied by a protocol buffer type
-// that may be stored in a MessageSet.
-type messageTypeIder interface {
-	MessageTypeId() int32
-}
-
-func (ms *messageSet) find(pb Message) *_MessageSet_Item {
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return nil
-	}
-	id := mti.MessageTypeId()
-	for _, item := range ms.Item {
-		if *item.TypeId == id {
-			return item
-		}
-	}
-	return nil
-}
-
-func (ms *messageSet) Has(pb Message) bool {
-	if ms.find(pb) != nil {
-		return true
-	}
-	return false
-}
-
-func (ms *messageSet) Unmarshal(pb Message) error {
-	if item := ms.find(pb); item != nil {
-		return Unmarshal(item.Message, pb)
-	}
-	if _, ok := pb.(messageTypeIder); !ok {
-		return errNoMessageTypeID
-	}
-	return nil // TODO: return error instead?
-}
-
-func (ms *messageSet) Marshal(pb Message) error {
-	msg, err := Marshal(pb)
-	if err != nil {
-		return err
-	}
-	if item := ms.find(pb); item != nil {
-		// reuse existing item
-		item.Message = msg
-		return nil
-	}
-
-	mti, ok := pb.(messageTypeIder)
-	if !ok {
-		return errNoMessageTypeID
-	}
-
-	mtid := mti.MessageTypeId()
-	ms.Item = append(ms.Item, &_MessageSet_Item{
-		TypeId:  &mtid,
-		Message: msg,
-	})
-	return nil
-}
-
-func (ms *messageSet) Reset()         { *ms = messageSet{} }
-func (ms *messageSet) String() string { return CompactTextString(ms) }
-func (*messageSet) ProtoMessage()     {}
-
-// Support for the message_set_wire_format message option.
-
-func skipVarint(buf []byte) []byte {
-	i := 0
-	for ; buf[i]&0x80 != 0; i++ {
-	}
-	return buf[i+1:]
-}
-
-// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
-// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSet(exts interface{}) ([]byte, error) {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		if err := encodeExtensions(exts); err != nil {
-			return nil, err
-		}
-		m, _ = exts.extensionsRead()
-	case map[int32]Extension:
-		if err := encodeExtensionsMap(exts); err != nil {
-			return nil, err
-		}
-		m = exts
-	default:
-		return nil, errors.New("proto: not an extension map")
-	}
-
-	// Sort extension IDs to provide a deterministic encoding.
-	// See also enc_map in encode.go.
-	ids := make([]int, 0, len(m))
-	for id := range m {
-		ids = append(ids, int(id))
-	}
-	sort.Ints(ids)
-
-	ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))}
-	for _, id := range ids {
-		e := m[int32(id)]
-		// Remove the wire type and field number varint, as well as the length varint.
-		msg := skipVarint(skipVarint(e.enc))
-
-		ms.Item = append(ms.Item, &_MessageSet_Item{
-			TypeId:  Int32(int32(id)),
-			Message: msg,
-		})
-	}
-	return Marshal(ms)
-}
-
-// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
-// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSet(buf []byte, exts interface{}) error {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		m = exts.extensionsWrite()
-	case map[int32]Extension:
-		m = exts
-	default:
-		return errors.New("proto: not an extension map")
-	}
-
-	ms := new(messageSet)
-	if err := Unmarshal(buf, ms); err != nil {
-		return err
-	}
-	for _, item := range ms.Item {
-		id := *item.TypeId
-		msg := item.Message
-
-		// Restore wire type and field number varint, plus length varint.
-		// Be careful to preserve duplicate items.
-		b := EncodeVarint(uint64(id)<<3 | WireBytes)
-		if ext, ok := m[id]; ok {
-			// Existing data; rip off the tag and length varint
-			// so we join the new data correctly.
-			// We can assume that ext.enc is set because we are unmarshaling.
-			o := ext.enc[len(b):]   // skip wire type and field number
-			_, n := DecodeVarint(o) // calculate length of length varint
-			o = o[n:]               // skip length varint
-			msg = append(o, msg...) // join old data and new data
-		}
-		b = append(b, EncodeVarint(uint64(len(msg)))...)
-		b = append(b, msg...)
-
-		m[id] = Extension{enc: b}
-	}
-	return nil
-}
-
-// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
-// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
-	var m map[int32]Extension
-	switch exts := exts.(type) {
-	case *XXX_InternalExtensions:
-		m, _ = exts.extensionsRead()
-	case map[int32]Extension:
-		m = exts
-	default:
-		return nil, errors.New("proto: not an extension map")
-	}
-	var b bytes.Buffer
-	b.WriteByte('{')
-
-	// Process the map in key order for deterministic output.
-	ids := make([]int32, 0, len(m))
-	for id := range m {
-		ids = append(ids, id)
-	}
-	sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
-
-	for i, id := range ids {
-		ext := m[id]
-		if i > 0 {
-			b.WriteByte(',')
-		}
-
-		msd, ok := messageSetMap[id]
-		if !ok {
-			// Unknown type; we can't render it, so skip it.
-			continue
-		}
-		fmt.Fprintf(&b, `"[%s]":`, msd.name)
-
-		x := ext.value
-		if x == nil {
-			x = reflect.New(msd.t.Elem()).Interface()
-			if err := Unmarshal(ext.enc, x.(Message)); err != nil {
-				return nil, err
-			}
-		}
-		d, err := json.Marshal(x)
-		if err != nil {
-			return nil, err
-		}
-		b.Write(d)
-	}
-	b.WriteByte('}')
-	return b.Bytes(), nil
-}
-
-// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
-// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
-func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
-	// Common-case fast path.
-	if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
-		return nil
-	}
-
-	// This is fairly tricky, and it's not clear that it is needed.
-	return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
-}
-
-// A global registry of types that can be used in a MessageSet.
-
-var messageSetMap = make(map[int32]messageSetDesc)
-
-type messageSetDesc struct {
-	t    reflect.Type // pointer to struct
-	name string
-}
-
-// RegisterMessageSetType is called from the generated code.
-func RegisterMessageSetType(m Message, fieldNum int32, name string) {
-	messageSetMap[fieldNum] = messageSetDesc{
-		t:    reflect.TypeOf(m),
-		name: name,
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
deleted file mode 100644
index fb512e2e16dce05683722f810c279367bdc68fe9..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
+++ /dev/null
@@ -1,484 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build appengine js
-
-// This file contains an implementation of proto field accesses using package reflect.
-// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
-// be used on App Engine.
-
-package proto
-
-import (
-	"math"
-	"reflect"
-)
-
-// A structPointer is a pointer to a struct.
-type structPointer struct {
-	v reflect.Value
-}
-
-// toStructPointer returns a structPointer equivalent to the given reflect value.
-// The reflect value must itself be a pointer to a struct.
-func toStructPointer(v reflect.Value) structPointer {
-	return structPointer{v}
-}
-
-// IsNil reports whether p is nil.
-func structPointer_IsNil(p structPointer) bool {
-	return p.v.IsNil()
-}
-
-// Interface returns the struct pointer as an interface value.
-func structPointer_Interface(p structPointer, _ reflect.Type) interface{} {
-	return p.v.Interface()
-}
-
-// A field identifies a field in a struct, accessible from a structPointer.
-// In this implementation, a field is identified by the sequence of field indices
-// passed to reflect's FieldByIndex.
-type field []int
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return f.Index
-}
-
-// invalidField is an invalid field identifier.
-var invalidField = field(nil)
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool { return f != nil }
-
-// field returns the given field in the struct as a reflect value.
-func structPointer_field(p structPointer, f field) reflect.Value {
-	// Special case: an extension map entry with a value of type T
-	// passes a *T to the struct-handling code with a zero field,
-	// expecting that it will be treated as equivalent to *struct{ X T },
-	// which has the same memory layout. We have to handle that case
-	// specially, because reflect will panic if we call FieldByIndex on a
-	// non-struct.
-	if f == nil {
-		return p.v.Elem()
-	}
-
-	return p.v.Elem().FieldByIndex(f)
-}
-
-// ifield returns the given field in the struct as an interface value.
-func structPointer_ifield(p structPointer, f field) interface{} {
-	return structPointer_field(p, f).Addr().Interface()
-}
-
-// Bytes returns the address of a []byte field in the struct.
-func structPointer_Bytes(p structPointer, f field) *[]byte {
-	return structPointer_ifield(p, f).(*[]byte)
-}
-
-// BytesSlice returns the address of a [][]byte field in the struct.
-func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
-	return structPointer_ifield(p, f).(*[][]byte)
-}
-
-// Bool returns the address of a *bool field in the struct.
-func structPointer_Bool(p structPointer, f field) **bool {
-	return structPointer_ifield(p, f).(**bool)
-}
-
-// BoolVal returns the address of a bool field in the struct.
-func structPointer_BoolVal(p structPointer, f field) *bool {
-	return structPointer_ifield(p, f).(*bool)
-}
-
-// BoolSlice returns the address of a []bool field in the struct.
-func structPointer_BoolSlice(p structPointer, f field) *[]bool {
-	return structPointer_ifield(p, f).(*[]bool)
-}
-
-// String returns the address of a *string field in the struct.
-func structPointer_String(p structPointer, f field) **string {
-	return structPointer_ifield(p, f).(**string)
-}
-
-// StringVal returns the address of a string field in the struct.
-func structPointer_StringVal(p structPointer, f field) *string {
-	return structPointer_ifield(p, f).(*string)
-}
-
-// StringSlice returns the address of a []string field in the struct.
-func structPointer_StringSlice(p structPointer, f field) *[]string {
-	return structPointer_ifield(p, f).(*[]string)
-}
-
-// Extensions returns the address of an extension map field in the struct.
-func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
-	return structPointer_ifield(p, f).(*XXX_InternalExtensions)
-}
-
-// ExtMap returns the address of an extension map field in the struct.
-func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
-	return structPointer_ifield(p, f).(*map[int32]Extension)
-}
-
-// NewAt returns the reflect.Value for a pointer to a field in the struct.
-func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
-	return structPointer_field(p, f).Addr()
-}
-
-// SetStructPointer writes a *struct field in the struct.
-func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
-	structPointer_field(p, f).Set(q.v)
-}
-
-// GetStructPointer reads a *struct field in the struct.
-func structPointer_GetStructPointer(p structPointer, f field) structPointer {
-	return structPointer{structPointer_field(p, f)}
-}
-
-// StructPointerSlice the address of a []*struct field in the struct.
-func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice {
-	return structPointerSlice{structPointer_field(p, f)}
-}
-
-// A structPointerSlice represents the address of a slice of pointers to structs
-// (themselves messages or groups). That is, v.Type() is *[]*struct{...}.
-type structPointerSlice struct {
-	v reflect.Value
-}
-
-func (p structPointerSlice) Len() int                  { return p.v.Len() }
-func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} }
-func (p structPointerSlice) Append(q structPointer) {
-	p.v.Set(reflect.Append(p.v, q.v))
-}
-
-var (
-	int32Type   = reflect.TypeOf(int32(0))
-	uint32Type  = reflect.TypeOf(uint32(0))
-	float32Type = reflect.TypeOf(float32(0))
-	int64Type   = reflect.TypeOf(int64(0))
-	uint64Type  = reflect.TypeOf(uint64(0))
-	float64Type = reflect.TypeOf(float64(0))
-)
-
-// A word32 represents a field of type *int32, *uint32, *float32, or *enum.
-// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable.
-type word32 struct {
-	v reflect.Value
-}
-
-// IsNil reports whether p is nil.
-func word32_IsNil(p word32) bool {
-	return p.v.IsNil()
-}
-
-// Set sets p to point at a newly allocated word with bits set to x.
-func word32_Set(p word32, o *Buffer, x uint32) {
-	t := p.v.Type().Elem()
-	switch t {
-	case int32Type:
-		if len(o.int32s) == 0 {
-			o.int32s = make([]int32, uint32PoolSize)
-		}
-		o.int32s[0] = int32(x)
-		p.v.Set(reflect.ValueOf(&o.int32s[0]))
-		o.int32s = o.int32s[1:]
-		return
-	case uint32Type:
-		if len(o.uint32s) == 0 {
-			o.uint32s = make([]uint32, uint32PoolSize)
-		}
-		o.uint32s[0] = x
-		p.v.Set(reflect.ValueOf(&o.uint32s[0]))
-		o.uint32s = o.uint32s[1:]
-		return
-	case float32Type:
-		if len(o.float32s) == 0 {
-			o.float32s = make([]float32, uint32PoolSize)
-		}
-		o.float32s[0] = math.Float32frombits(x)
-		p.v.Set(reflect.ValueOf(&o.float32s[0]))
-		o.float32s = o.float32s[1:]
-		return
-	}
-
-	// must be enum
-	p.v.Set(reflect.New(t))
-	p.v.Elem().SetInt(int64(int32(x)))
-}
-
-// Get gets the bits pointed at by p, as a uint32.
-func word32_Get(p word32) uint32 {
-	elem := p.v.Elem()
-	switch elem.Kind() {
-	case reflect.Int32:
-		return uint32(elem.Int())
-	case reflect.Uint32:
-		return uint32(elem.Uint())
-	case reflect.Float32:
-		return math.Float32bits(float32(elem.Float()))
-	}
-	panic("unreachable")
-}
-
-// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct.
-func structPointer_Word32(p structPointer, f field) word32 {
-	return word32{structPointer_field(p, f)}
-}
-
-// A word32Val represents a field of type int32, uint32, float32, or enum.
-// That is, v.Type() is int32, uint32, float32, or enum and v is assignable.
-type word32Val struct {
-	v reflect.Value
-}
-
-// Set sets *p to x.
-func word32Val_Set(p word32Val, x uint32) {
-	switch p.v.Type() {
-	case int32Type:
-		p.v.SetInt(int64(x))
-		return
-	case uint32Type:
-		p.v.SetUint(uint64(x))
-		return
-	case float32Type:
-		p.v.SetFloat(float64(math.Float32frombits(x)))
-		return
-	}
-
-	// must be enum
-	p.v.SetInt(int64(int32(x)))
-}
-
-// Get gets the bits pointed at by p, as a uint32.
-func word32Val_Get(p word32Val) uint32 {
-	elem := p.v
-	switch elem.Kind() {
-	case reflect.Int32:
-		return uint32(elem.Int())
-	case reflect.Uint32:
-		return uint32(elem.Uint())
-	case reflect.Float32:
-		return math.Float32bits(float32(elem.Float()))
-	}
-	panic("unreachable")
-}
-
-// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct.
-func structPointer_Word32Val(p structPointer, f field) word32Val {
-	return word32Val{structPointer_field(p, f)}
-}
-
-// A word32Slice is a slice of 32-bit values.
-// That is, v.Type() is []int32, []uint32, []float32, or []enum.
-type word32Slice struct {
-	v reflect.Value
-}
-
-func (p word32Slice) Append(x uint32) {
-	n, m := p.v.Len(), p.v.Cap()
-	if n < m {
-		p.v.SetLen(n + 1)
-	} else {
-		t := p.v.Type().Elem()
-		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
-	}
-	elem := p.v.Index(n)
-	switch elem.Kind() {
-	case reflect.Int32:
-		elem.SetInt(int64(int32(x)))
-	case reflect.Uint32:
-		elem.SetUint(uint64(x))
-	case reflect.Float32:
-		elem.SetFloat(float64(math.Float32frombits(x)))
-	}
-}
-
-func (p word32Slice) Len() int {
-	return p.v.Len()
-}
-
-func (p word32Slice) Index(i int) uint32 {
-	elem := p.v.Index(i)
-	switch elem.Kind() {
-	case reflect.Int32:
-		return uint32(elem.Int())
-	case reflect.Uint32:
-		return uint32(elem.Uint())
-	case reflect.Float32:
-		return math.Float32bits(float32(elem.Float()))
-	}
-	panic("unreachable")
-}
-
-// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct.
-func structPointer_Word32Slice(p structPointer, f field) word32Slice {
-	return word32Slice{structPointer_field(p, f)}
-}
-
-// word64 is like word32 but for 64-bit values.
-type word64 struct {
-	v reflect.Value
-}
-
-func word64_Set(p word64, o *Buffer, x uint64) {
-	t := p.v.Type().Elem()
-	switch t {
-	case int64Type:
-		if len(o.int64s) == 0 {
-			o.int64s = make([]int64, uint64PoolSize)
-		}
-		o.int64s[0] = int64(x)
-		p.v.Set(reflect.ValueOf(&o.int64s[0]))
-		o.int64s = o.int64s[1:]
-		return
-	case uint64Type:
-		if len(o.uint64s) == 0 {
-			o.uint64s = make([]uint64, uint64PoolSize)
-		}
-		o.uint64s[0] = x
-		p.v.Set(reflect.ValueOf(&o.uint64s[0]))
-		o.uint64s = o.uint64s[1:]
-		return
-	case float64Type:
-		if len(o.float64s) == 0 {
-			o.float64s = make([]float64, uint64PoolSize)
-		}
-		o.float64s[0] = math.Float64frombits(x)
-		p.v.Set(reflect.ValueOf(&o.float64s[0]))
-		o.float64s = o.float64s[1:]
-		return
-	}
-	panic("unreachable")
-}
-
-func word64_IsNil(p word64) bool {
-	return p.v.IsNil()
-}
-
-func word64_Get(p word64) uint64 {
-	elem := p.v.Elem()
-	switch elem.Kind() {
-	case reflect.Int64:
-		return uint64(elem.Int())
-	case reflect.Uint64:
-		return elem.Uint()
-	case reflect.Float64:
-		return math.Float64bits(elem.Float())
-	}
-	panic("unreachable")
-}
-
-func structPointer_Word64(p structPointer, f field) word64 {
-	return word64{structPointer_field(p, f)}
-}
-
-// word64Val is like word32Val but for 64-bit values.
-type word64Val struct {
-	v reflect.Value
-}
-
-func word64Val_Set(p word64Val, o *Buffer, x uint64) {
-	switch p.v.Type() {
-	case int64Type:
-		p.v.SetInt(int64(x))
-		return
-	case uint64Type:
-		p.v.SetUint(x)
-		return
-	case float64Type:
-		p.v.SetFloat(math.Float64frombits(x))
-		return
-	}
-	panic("unreachable")
-}
-
-func word64Val_Get(p word64Val) uint64 {
-	elem := p.v
-	switch elem.Kind() {
-	case reflect.Int64:
-		return uint64(elem.Int())
-	case reflect.Uint64:
-		return elem.Uint()
-	case reflect.Float64:
-		return math.Float64bits(elem.Float())
-	}
-	panic("unreachable")
-}
-
-func structPointer_Word64Val(p structPointer, f field) word64Val {
-	return word64Val{structPointer_field(p, f)}
-}
-
-type word64Slice struct {
-	v reflect.Value
-}
-
-func (p word64Slice) Append(x uint64) {
-	n, m := p.v.Len(), p.v.Cap()
-	if n < m {
-		p.v.SetLen(n + 1)
-	} else {
-		t := p.v.Type().Elem()
-		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
-	}
-	elem := p.v.Index(n)
-	switch elem.Kind() {
-	case reflect.Int64:
-		elem.SetInt(int64(int64(x)))
-	case reflect.Uint64:
-		elem.SetUint(uint64(x))
-	case reflect.Float64:
-		elem.SetFloat(float64(math.Float64frombits(x)))
-	}
-}
-
-func (p word64Slice) Len() int {
-	return p.v.Len()
-}
-
-func (p word64Slice) Index(i int) uint64 {
-	elem := p.v.Index(i)
-	switch elem.Kind() {
-	case reflect.Int64:
-		return uint64(elem.Int())
-	case reflect.Uint64:
-		return uint64(elem.Uint())
-	case reflect.Float64:
-		return math.Float64bits(float64(elem.Float()))
-	}
-	panic("unreachable")
-}
-
-func structPointer_Word64Slice(p structPointer, f field) word64Slice {
-	return word64Slice{structPointer_field(p, f)}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
deleted file mode 100644
index 6b5567d47cd396b25370f8c06bad3b851776658f..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2012 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// +build !appengine,!js
-
-// This file contains the implementation of the proto field accesses using package unsafe.
-
-package proto
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-// NOTE: These type_Foo functions would more idiomatically be methods,
-// but Go does not allow methods on pointer types, and we must preserve
-// some pointer type for the garbage collector. We use these
-// funcs with clunky names as our poor approximation to methods.
-//
-// An alternative would be
-//	type structPointer struct { p unsafe.Pointer }
-// but that does not registerize as well.
-
-// A structPointer is a pointer to a struct.
-type structPointer unsafe.Pointer
-
-// toStructPointer returns a structPointer equivalent to the given reflect value.
-func toStructPointer(v reflect.Value) structPointer {
-	return structPointer(unsafe.Pointer(v.Pointer()))
-}
-
-// IsNil reports whether p is nil.
-func structPointer_IsNil(p structPointer) bool {
-	return p == nil
-}
-
-// Interface returns the struct pointer, assumed to have element type t,
-// as an interface value.
-func structPointer_Interface(p structPointer, t reflect.Type) interface{} {
-	return reflect.NewAt(t, unsafe.Pointer(p)).Interface()
-}
-
-// A field identifies a field in a struct, accessible from a structPointer.
-// In this implementation, a field is identified by its byte offset from the start of the struct.
-type field uintptr
-
-// toField returns a field equivalent to the given reflect field.
-func toField(f *reflect.StructField) field {
-	return field(f.Offset)
-}
-
-// invalidField is an invalid field identifier.
-const invalidField = ^field(0)
-
-// IsValid reports whether the field identifier is valid.
-func (f field) IsValid() bool {
-	return f != ^field(0)
-}
-
-// Bytes returns the address of a []byte field in the struct.
-func structPointer_Bytes(p structPointer, f field) *[]byte {
-	return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// BytesSlice returns the address of a [][]byte field in the struct.
-func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
-	return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// Bool returns the address of a *bool field in the struct.
-func structPointer_Bool(p structPointer, f field) **bool {
-	return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// BoolVal returns the address of a bool field in the struct.
-func structPointer_BoolVal(p structPointer, f field) *bool {
-	return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// BoolSlice returns the address of a []bool field in the struct.
-func structPointer_BoolSlice(p structPointer, f field) *[]bool {
-	return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// String returns the address of a *string field in the struct.
-func structPointer_String(p structPointer, f field) **string {
-	return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// StringVal returns the address of a string field in the struct.
-func structPointer_StringVal(p structPointer, f field) *string {
-	return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// StringSlice returns the address of a []string field in the struct.
-func structPointer_StringSlice(p structPointer, f field) *[]string {
-	return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// ExtMap returns the address of an extension map field in the struct.
-func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
-	return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
-	return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// NewAt returns the reflect.Value for a pointer to a field in the struct.
-func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
-	return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f)))
-}
-
-// SetStructPointer writes a *struct field in the struct.
-func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
-	*(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q
-}
-
-// GetStructPointer reads a *struct field in the struct.
-func structPointer_GetStructPointer(p structPointer, f field) structPointer {
-	return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// StructPointerSlice the address of a []*struct field in the struct.
-func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice {
-	return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups).
-type structPointerSlice []structPointer
-
-func (v *structPointerSlice) Len() int                  { return len(*v) }
-func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] }
-func (v *structPointerSlice) Append(p structPointer)    { *v = append(*v, p) }
-
-// A word32 is the address of a "pointer to 32-bit value" field.
-type word32 **uint32
-
-// IsNil reports whether *v is nil.
-func word32_IsNil(p word32) bool {
-	return *p == nil
-}
-
-// Set sets *v to point at a newly allocated word set to x.
-func word32_Set(p word32, o *Buffer, x uint32) {
-	if len(o.uint32s) == 0 {
-		o.uint32s = make([]uint32, uint32PoolSize)
-	}
-	o.uint32s[0] = x
-	*p = &o.uint32s[0]
-	o.uint32s = o.uint32s[1:]
-}
-
-// Get gets the value pointed at by *v.
-func word32_Get(p word32) uint32 {
-	return **p
-}
-
-// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
-func structPointer_Word32(p structPointer, f field) word32 {
-	return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
-}
-
-// A word32Val is the address of a 32-bit value field.
-type word32Val *uint32
-
-// Set sets *p to x.
-func word32Val_Set(p word32Val, x uint32) {
-	*p = x
-}
-
-// Get gets the value pointed at by p.
-func word32Val_Get(p word32Val) uint32 {
-	return *p
-}
-
-// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
-func structPointer_Word32Val(p structPointer, f field) word32Val {
-	return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
-}
-
-// A word32Slice is a slice of 32-bit values.
-type word32Slice []uint32
-
-func (v *word32Slice) Append(x uint32)    { *v = append(*v, x) }
-func (v *word32Slice) Len() int           { return len(*v) }
-func (v *word32Slice) Index(i int) uint32 { return (*v)[i] }
-
-// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct.
-func structPointer_Word32Slice(p structPointer, f field) *word32Slice {
-	return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
-
-// word64 is like word32 but for 64-bit values.
-type word64 **uint64
-
-func word64_Set(p word64, o *Buffer, x uint64) {
-	if len(o.uint64s) == 0 {
-		o.uint64s = make([]uint64, uint64PoolSize)
-	}
-	o.uint64s[0] = x
-	*p = &o.uint64s[0]
-	o.uint64s = o.uint64s[1:]
-}
-
-func word64_IsNil(p word64) bool {
-	return *p == nil
-}
-
-func word64_Get(p word64) uint64 {
-	return **p
-}
-
-func structPointer_Word64(p structPointer, f field) word64 {
-	return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
-}
-
-// word64Val is like word32Val but for 64-bit values.
-type word64Val *uint64
-
-func word64Val_Set(p word64Val, o *Buffer, x uint64) {
-	*p = x
-}
-
-func word64Val_Get(p word64Val) uint64 {
-	return *p
-}
-
-func structPointer_Word64Val(p structPointer, f field) word64Val {
-	return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
-}
-
-// word64Slice is like word32Slice but for 64-bit values.
-type word64Slice []uint64
-
-func (v *word64Slice) Append(x uint64)    { *v = append(*v, x) }
-func (v *word64Slice) Len() int           { return len(*v) }
-func (v *word64Slice) Index(i int) uint64 { return (*v)[i] }
-
-func structPointer_Word64Slice(p structPointer, f field) *word64Slice {
-	return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
-}
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
deleted file mode 100644
index ec2289c0058e47e3d20fa2bef7a3979529aa7512..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ /dev/null
@@ -1,872 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-/*
- * Routines for encoding data into the wire format for protocol buffers.
- */
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-const debug bool = false
-
-// Constants that identify the encoding of a value on the wire.
-const (
-	WireVarint     = 0
-	WireFixed64    = 1
-	WireBytes      = 2
-	WireStartGroup = 3
-	WireEndGroup   = 4
-	WireFixed32    = 5
-)
-
-const startSize = 10 // initial slice/string sizes
-
-// Encoders are defined in encode.go
-// An encoder outputs the full representation of a field, including its
-// tag and encoder type.
-type encoder func(p *Buffer, prop *Properties, base structPointer) error
-
-// A valueEncoder encodes a single integer in a particular encoding.
-type valueEncoder func(o *Buffer, x uint64) error
-
-// Sizers are defined in encode.go
-// A sizer returns the encoded size of a field, including its tag and encoder
-// type.
-type sizer func(prop *Properties, base structPointer) int
-
-// A valueSizer returns the encoded size of a single integer in a particular
-// encoding.
-type valueSizer func(x uint64) int
-
-// Decoders are defined in decode.go
-// A decoder creates a value from its wire representation.
-// Unrecognized subelements are saved in unrec.
-type decoder func(p *Buffer, prop *Properties, base structPointer) error
-
-// A valueDecoder decodes a single integer in a particular encoding.
-type valueDecoder func(o *Buffer) (x uint64, err error)
-
-// A oneofMarshaler does the marshaling for all oneof fields in a message.
-type oneofMarshaler func(Message, *Buffer) error
-
-// A oneofUnmarshaler does the unmarshaling for a oneof field in a message.
-type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error)
-
-// A oneofSizer does the sizing for all oneof fields in a message.
-type oneofSizer func(Message) int
-
-// tagMap is an optimization over map[int]int for typical protocol buffer
-// use-cases. Encoded protocol buffers are often in tag order with small tag
-// numbers.
-type tagMap struct {
-	fastTags []int
-	slowTags map[int]int
-}
-
-// tagMapFastLimit is the upper bound on the tag number that will be stored in
-// the tagMap slice rather than its map.
-const tagMapFastLimit = 1024
-
-func (p *tagMap) get(t int) (int, bool) {
-	if t > 0 && t < tagMapFastLimit {
-		if t >= len(p.fastTags) {
-			return 0, false
-		}
-		fi := p.fastTags[t]
-		return fi, fi >= 0
-	}
-	fi, ok := p.slowTags[t]
-	return fi, ok
-}
-
-func (p *tagMap) put(t int, fi int) {
-	if t > 0 && t < tagMapFastLimit {
-		for len(p.fastTags) < t+1 {
-			p.fastTags = append(p.fastTags, -1)
-		}
-		p.fastTags[t] = fi
-		return
-	}
-	if p.slowTags == nil {
-		p.slowTags = make(map[int]int)
-	}
-	p.slowTags[t] = fi
-}
-
-// StructProperties represents properties for all the fields of a struct.
-// decoderTags and decoderOrigNames should only be used by the decoder.
-type StructProperties struct {
-	Prop             []*Properties  // properties for each field
-	reqCount         int            // required count
-	decoderTags      tagMap         // map from proto tag to struct field number
-	decoderOrigNames map[string]int // map from original name to struct field number
-	order            []int          // list of struct field numbers in tag order
-	unrecField       field          // field id of the XXX_unrecognized []byte field
-	extendable       bool           // is this an extendable proto
-
-	oneofMarshaler   oneofMarshaler
-	oneofUnmarshaler oneofUnmarshaler
-	oneofSizer       oneofSizer
-	stype            reflect.Type
-
-	// OneofTypes contains information about the oneof fields in this message.
-	// It is keyed by the original name of a field.
-	OneofTypes map[string]*OneofProperties
-}
-
-// OneofProperties represents information about a specific field in a oneof.
-type OneofProperties struct {
-	Type  reflect.Type // pointer to generated struct type for this oneof field
-	Field int          // struct field number of the containing oneof in the message
-	Prop  *Properties
-}
-
-// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
-// See encode.go, (*Buffer).enc_struct.
-
-func (sp *StructProperties) Len() int { return len(sp.order) }
-func (sp *StructProperties) Less(i, j int) bool {
-	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
-}
-func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
-
-// Properties represents the protocol-specific behavior of a single struct field.
-type Properties struct {
-	Name     string // name of the field, for error messages
-	OrigName string // original name before protocol compiler (always set)
-	JSONName string // name to use for JSON; determined by protoc
-	Wire     string
-	WireType int
-	Tag      int
-	Required bool
-	Optional bool
-	Repeated bool
-	Packed   bool   // relevant for repeated primitives only
-	Enum     string // set for enum types only
-	proto3   bool   // whether this is known to be a proto3 field; set for []byte only
-	oneof    bool   // whether this is a oneof field
-
-	Default    string // default value
-	HasDefault bool   // whether an explicit default was provided
-	def_uint64 uint64
-
-	enc           encoder
-	valEnc        valueEncoder // set for bool and numeric types only
-	field         field
-	tagcode       []byte // encoding of EncodeVarint((Tag<<3)|WireType)
-	tagbuf        [8]byte
-	stype         reflect.Type      // set for struct types only
-	sprop         *StructProperties // set for struct types only
-	isMarshaler   bool
-	isUnmarshaler bool
-
-	mtype    reflect.Type // set for map types only
-	mkeyprop *Properties  // set for map types only
-	mvalprop *Properties  // set for map types only
-
-	size    sizer
-	valSize valueSizer // set for bool and numeric types only
-
-	dec    decoder
-	valDec valueDecoder // set for bool and numeric types only
-
-	// If this is a packable field, this will be the decoder for the packed version of the field.
-	packedDec decoder
-}
-
-// String formats the properties in the protobuf struct field tag style.
-func (p *Properties) String() string {
-	s := p.Wire
-	s = ","
-	s += strconv.Itoa(p.Tag)
-	if p.Required {
-		s += ",req"
-	}
-	if p.Optional {
-		s += ",opt"
-	}
-	if p.Repeated {
-		s += ",rep"
-	}
-	if p.Packed {
-		s += ",packed"
-	}
-	s += ",name=" + p.OrigName
-	if p.JSONName != p.OrigName {
-		s += ",json=" + p.JSONName
-	}
-	if p.proto3 {
-		s += ",proto3"
-	}
-	if p.oneof {
-		s += ",oneof"
-	}
-	if len(p.Enum) > 0 {
-		s += ",enum=" + p.Enum
-	}
-	if p.HasDefault {
-		s += ",def=" + p.Default
-	}
-	return s
-}
-
-// Parse populates p by parsing a string in the protobuf struct field tag style.
-func (p *Properties) Parse(s string) {
-	// "bytes,49,opt,name=foo,def=hello!"
-	fields := strings.Split(s, ",") // breaks def=, but handled below.
-	if len(fields) < 2 {
-		fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
-		return
-	}
-
-	p.Wire = fields[0]
-	switch p.Wire {
-	case "varint":
-		p.WireType = WireVarint
-		p.valEnc = (*Buffer).EncodeVarint
-		p.valDec = (*Buffer).DecodeVarint
-		p.valSize = sizeVarint
-	case "fixed32":
-		p.WireType = WireFixed32
-		p.valEnc = (*Buffer).EncodeFixed32
-		p.valDec = (*Buffer).DecodeFixed32
-		p.valSize = sizeFixed32
-	case "fixed64":
-		p.WireType = WireFixed64
-		p.valEnc = (*Buffer).EncodeFixed64
-		p.valDec = (*Buffer).DecodeFixed64
-		p.valSize = sizeFixed64
-	case "zigzag32":
-		p.WireType = WireVarint
-		p.valEnc = (*Buffer).EncodeZigzag32
-		p.valDec = (*Buffer).DecodeZigzag32
-		p.valSize = sizeZigzag32
-	case "zigzag64":
-		p.WireType = WireVarint
-		p.valEnc = (*Buffer).EncodeZigzag64
-		p.valDec = (*Buffer).DecodeZigzag64
-		p.valSize = sizeZigzag64
-	case "bytes", "group":
-		p.WireType = WireBytes
-		// no numeric converter for non-numeric types
-	default:
-		fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
-		return
-	}
-
-	var err error
-	p.Tag, err = strconv.Atoi(fields[1])
-	if err != nil {
-		return
-	}
-
-	for i := 2; i < len(fields); i++ {
-		f := fields[i]
-		switch {
-		case f == "req":
-			p.Required = true
-		case f == "opt":
-			p.Optional = true
-		case f == "rep":
-			p.Repeated = true
-		case f == "packed":
-			p.Packed = true
-		case strings.HasPrefix(f, "name="):
-			p.OrigName = f[5:]
-		case strings.HasPrefix(f, "json="):
-			p.JSONName = f[5:]
-		case strings.HasPrefix(f, "enum="):
-			p.Enum = f[5:]
-		case f == "proto3":
-			p.proto3 = true
-		case f == "oneof":
-			p.oneof = true
-		case strings.HasPrefix(f, "def="):
-			p.HasDefault = true
-			p.Default = f[4:] // rest of string
-			if i+1 < len(fields) {
-				// Commas aren't escaped, and def is always last.
-				p.Default += "," + strings.Join(fields[i+1:], ",")
-				break
-			}
-		}
-	}
-}
-
-func logNoSliceEnc(t1, t2 reflect.Type) {
-	fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
-}
-
-var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
-
-// Initialize the fields for encoding and decoding.
-func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
-	p.enc = nil
-	p.dec = nil
-	p.size = nil
-
-	switch t1 := typ; t1.Kind() {
-	default:
-		fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1)
-
-	// proto3 scalar types
-
-	case reflect.Bool:
-		p.enc = (*Buffer).enc_proto3_bool
-		p.dec = (*Buffer).dec_proto3_bool
-		p.size = size_proto3_bool
-	case reflect.Int32:
-		p.enc = (*Buffer).enc_proto3_int32
-		p.dec = (*Buffer).dec_proto3_int32
-		p.size = size_proto3_int32
-	case reflect.Uint32:
-		p.enc = (*Buffer).enc_proto3_uint32
-		p.dec = (*Buffer).dec_proto3_int32 // can reuse
-		p.size = size_proto3_uint32
-	case reflect.Int64, reflect.Uint64:
-		p.enc = (*Buffer).enc_proto3_int64
-		p.dec = (*Buffer).dec_proto3_int64
-		p.size = size_proto3_int64
-	case reflect.Float32:
-		p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits
-		p.dec = (*Buffer).dec_proto3_int32
-		p.size = size_proto3_uint32
-	case reflect.Float64:
-		p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits
-		p.dec = (*Buffer).dec_proto3_int64
-		p.size = size_proto3_int64
-	case reflect.String:
-		p.enc = (*Buffer).enc_proto3_string
-		p.dec = (*Buffer).dec_proto3_string
-		p.size = size_proto3_string
-
-	case reflect.Ptr:
-		switch t2 := t1.Elem(); t2.Kind() {
-		default:
-			fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2)
-			break
-		case reflect.Bool:
-			p.enc = (*Buffer).enc_bool
-			p.dec = (*Buffer).dec_bool
-			p.size = size_bool
-		case reflect.Int32:
-			p.enc = (*Buffer).enc_int32
-			p.dec = (*Buffer).dec_int32
-			p.size = size_int32
-		case reflect.Uint32:
-			p.enc = (*Buffer).enc_uint32
-			p.dec = (*Buffer).dec_int32 // can reuse
-			p.size = size_uint32
-		case reflect.Int64, reflect.Uint64:
-			p.enc = (*Buffer).enc_int64
-			p.dec = (*Buffer).dec_int64
-			p.size = size_int64
-		case reflect.Float32:
-			p.enc = (*Buffer).enc_uint32 // can just treat them as bits
-			p.dec = (*Buffer).dec_int32
-			p.size = size_uint32
-		case reflect.Float64:
-			p.enc = (*Buffer).enc_int64 // can just treat them as bits
-			p.dec = (*Buffer).dec_int64
-			p.size = size_int64
-		case reflect.String:
-			p.enc = (*Buffer).enc_string
-			p.dec = (*Buffer).dec_string
-			p.size = size_string
-		case reflect.Struct:
-			p.stype = t1.Elem()
-			p.isMarshaler = isMarshaler(t1)
-			p.isUnmarshaler = isUnmarshaler(t1)
-			if p.Wire == "bytes" {
-				p.enc = (*Buffer).enc_struct_message
-				p.dec = (*Buffer).dec_struct_message
-				p.size = size_struct_message
-			} else {
-				p.enc = (*Buffer).enc_struct_group
-				p.dec = (*Buffer).dec_struct_group
-				p.size = size_struct_group
-			}
-		}
-
-	case reflect.Slice:
-		switch t2 := t1.Elem(); t2.Kind() {
-		default:
-			logNoSliceEnc(t1, t2)
-			break
-		case reflect.Bool:
-			if p.Packed {
-				p.enc = (*Buffer).enc_slice_packed_bool
-				p.size = size_slice_packed_bool
-			} else {
-				p.enc = (*Buffer).enc_slice_bool
-				p.size = size_slice_bool
-			}
-			p.dec = (*Buffer).dec_slice_bool
-			p.packedDec = (*Buffer).dec_slice_packed_bool
-		case reflect.Int32:
-			if p.Packed {
-				p.enc = (*Buffer).enc_slice_packed_int32
-				p.size = size_slice_packed_int32
-			} else {
-				p.enc = (*Buffer).enc_slice_int32
-				p.size = size_slice_int32
-			}
-			p.dec = (*Buffer).dec_slice_int32
-			p.packedDec = (*Buffer).dec_slice_packed_int32
-		case reflect.Uint32:
-			if p.Packed {
-				p.enc = (*Buffer).enc_slice_packed_uint32
-				p.size = size_slice_packed_uint32
-			} else {
-				p.enc = (*Buffer).enc_slice_uint32
-				p.size = size_slice_uint32
-			}
-			p.dec = (*Buffer).dec_slice_int32
-			p.packedDec = (*Buffer).dec_slice_packed_int32
-		case reflect.Int64, reflect.Uint64:
-			if p.Packed {
-				p.enc = (*Buffer).enc_slice_packed_int64
-				p.size = size_slice_packed_int64
-			} else {
-				p.enc = (*Buffer).enc_slice_int64
-				p.size = size_slice_int64
-			}
-			p.dec = (*Buffer).dec_slice_int64
-			p.packedDec = (*Buffer).dec_slice_packed_int64
-		case reflect.Uint8:
-			p.dec = (*Buffer).dec_slice_byte
-			if p.proto3 {
-				p.enc = (*Buffer).enc_proto3_slice_byte
-				p.size = size_proto3_slice_byte
-			} else {
-				p.enc = (*Buffer).enc_slice_byte
-				p.size = size_slice_byte
-			}
-		case reflect.Float32, reflect.Float64:
-			switch t2.Bits() {
-			case 32:
-				// can just treat them as bits
-				if p.Packed {
-					p.enc = (*Buffer).enc_slice_packed_uint32
-					p.size = size_slice_packed_uint32
-				} else {
-					p.enc = (*Buffer).enc_slice_uint32
-					p.size = size_slice_uint32
-				}
-				p.dec = (*Buffer).dec_slice_int32
-				p.packedDec = (*Buffer).dec_slice_packed_int32
-			case 64:
-				// can just treat them as bits
-				if p.Packed {
-					p.enc = (*Buffer).enc_slice_packed_int64
-					p.size = size_slice_packed_int64
-				} else {
-					p.enc = (*Buffer).enc_slice_int64
-					p.size = size_slice_int64
-				}
-				p.dec = (*Buffer).dec_slice_int64
-				p.packedDec = (*Buffer).dec_slice_packed_int64
-			default:
-				logNoSliceEnc(t1, t2)
-				break
-			}
-		case reflect.String:
-			p.enc = (*Buffer).enc_slice_string
-			p.dec = (*Buffer).dec_slice_string
-			p.size = size_slice_string
-		case reflect.Ptr:
-			switch t3 := t2.Elem(); t3.Kind() {
-			default:
-				fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
-				break
-			case reflect.Struct:
-				p.stype = t2.Elem()
-				p.isMarshaler = isMarshaler(t2)
-				p.isUnmarshaler = isUnmarshaler(t2)
-				if p.Wire == "bytes" {
-					p.enc = (*Buffer).enc_slice_struct_message
-					p.dec = (*Buffer).dec_slice_struct_message
-					p.size = size_slice_struct_message
-				} else {
-					p.enc = (*Buffer).enc_slice_struct_group
-					p.dec = (*Buffer).dec_slice_struct_group
-					p.size = size_slice_struct_group
-				}
-			}
-		case reflect.Slice:
-			switch t2.Elem().Kind() {
-			default:
-				fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
-				break
-			case reflect.Uint8:
-				p.enc = (*Buffer).enc_slice_slice_byte
-				p.dec = (*Buffer).dec_slice_slice_byte
-				p.size = size_slice_slice_byte
-			}
-		}
-
-	case reflect.Map:
-		p.enc = (*Buffer).enc_new_map
-		p.dec = (*Buffer).dec_new_map
-		p.size = size_new_map
-
-		p.mtype = t1
-		p.mkeyprop = &Properties{}
-		p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
-		p.mvalprop = &Properties{}
-		vtype := p.mtype.Elem()
-		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
-			// The value type is not a message (*T) or bytes ([]byte),
-			// so we need encoders for the pointer to this type.
-			vtype = reflect.PtrTo(vtype)
-		}
-		p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
-	}
-
-	// precalculate tag code
-	wire := p.WireType
-	if p.Packed {
-		wire = WireBytes
-	}
-	x := uint32(p.Tag)<<3 | uint32(wire)
-	i := 0
-	for i = 0; x > 127; i++ {
-		p.tagbuf[i] = 0x80 | uint8(x&0x7F)
-		x >>= 7
-	}
-	p.tagbuf[i] = uint8(x)
-	p.tagcode = p.tagbuf[0 : i+1]
-
-	if p.stype != nil {
-		if lockGetProp {
-			p.sprop = GetProperties(p.stype)
-		} else {
-			p.sprop = getPropertiesLocked(p.stype)
-		}
-	}
-}
-
-var (
-	marshalerType   = reflect.TypeOf((*Marshaler)(nil)).Elem()
-	unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
-)
-
-// isMarshaler reports whether type t implements Marshaler.
-func isMarshaler(t reflect.Type) bool {
-	// We're checking for (likely) pointer-receiver methods
-	// so if t is not a pointer, something is very wrong.
-	// The calls above only invoke isMarshaler on pointer types.
-	if t.Kind() != reflect.Ptr {
-		panic("proto: misuse of isMarshaler")
-	}
-	return t.Implements(marshalerType)
-}
-
-// isUnmarshaler reports whether type t implements Unmarshaler.
-func isUnmarshaler(t reflect.Type) bool {
-	// We're checking for (likely) pointer-receiver methods
-	// so if t is not a pointer, something is very wrong.
-	// The calls above only invoke isUnmarshaler on pointer types.
-	if t.Kind() != reflect.Ptr {
-		panic("proto: misuse of isUnmarshaler")
-	}
-	return t.Implements(unmarshalerType)
-}
-
-// Init populates the properties from a protocol buffer struct tag.
-func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
-	p.init(typ, name, tag, f, true)
-}
-
-func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
-	// "bytes,49,opt,def=hello!"
-	p.Name = name
-	p.OrigName = name
-	if f != nil {
-		p.field = toField(f)
-	}
-	if tag == "" {
-		return
-	}
-	p.Parse(tag)
-	p.setEncAndDec(typ, f, lockGetProp)
-}
-
-var (
-	propertiesMu  sync.RWMutex
-	propertiesMap = make(map[reflect.Type]*StructProperties)
-)
-
-// GetProperties returns the list of properties for the type represented by t.
-// t must represent a generated struct type of a protocol message.
-func GetProperties(t reflect.Type) *StructProperties {
-	if t.Kind() != reflect.Struct {
-		panic("proto: type must have kind struct")
-	}
-
-	// Most calls to GetProperties in a long-running program will be
-	// retrieving details for types we have seen before.
-	propertiesMu.RLock()
-	sprop, ok := propertiesMap[t]
-	propertiesMu.RUnlock()
-	if ok {
-		if collectStats {
-			stats.Chit++
-		}
-		return sprop
-	}
-
-	propertiesMu.Lock()
-	sprop = getPropertiesLocked(t)
-	propertiesMu.Unlock()
-	return sprop
-}
-
-// getPropertiesLocked requires that propertiesMu is held.
-func getPropertiesLocked(t reflect.Type) *StructProperties {
-	if prop, ok := propertiesMap[t]; ok {
-		if collectStats {
-			stats.Chit++
-		}
-		return prop
-	}
-	if collectStats {
-		stats.Cmiss++
-	}
-
-	prop := new(StructProperties)
-	// in case of recursive protos, fill this in now.
-	propertiesMap[t] = prop
-
-	// build properties
-	prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ||
-		reflect.PtrTo(t).Implements(extendableProtoV1Type)
-	prop.unrecField = invalidField
-	prop.Prop = make([]*Properties, t.NumField())
-	prop.order = make([]int, t.NumField())
-
-	for i := 0; i < t.NumField(); i++ {
-		f := t.Field(i)
-		p := new(Properties)
-		name := f.Name
-		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
-
-		if f.Name == "XXX_InternalExtensions" { // special case
-			p.enc = (*Buffer).enc_exts
-			p.dec = nil // not needed
-			p.size = size_exts
-		} else if f.Name == "XXX_extensions" { // special case
-			p.enc = (*Buffer).enc_map
-			p.dec = nil // not needed
-			p.size = size_map
-		} else if f.Name == "XXX_unrecognized" { // special case
-			prop.unrecField = toField(&f)
-		}
-		oneof := f.Tag.Get("protobuf_oneof") // special case
-		if oneof != "" {
-			// Oneof fields don't use the traditional protobuf tag.
-			p.OrigName = oneof
-		}
-		prop.Prop[i] = p
-		prop.order[i] = i
-		if debug {
-			print(i, " ", f.Name, " ", t.String(), " ")
-			if p.Tag > 0 {
-				print(p.String())
-			}
-			print("\n")
-		}
-		if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" {
-			fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
-		}
-	}
-
-	// Re-order prop.order.
-	sort.Sort(prop)
-
-	type oneofMessage interface {
-		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
-	}
-	if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
-		var oots []interface{}
-		prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs()
-		prop.stype = t
-
-		// Interpret oneof metadata.
-		prop.OneofTypes = make(map[string]*OneofProperties)
-		for _, oot := range oots {
-			oop := &OneofProperties{
-				Type: reflect.ValueOf(oot).Type(), // *T
-				Prop: new(Properties),
-			}
-			sft := oop.Type.Elem().Field(0)
-			oop.Prop.Name = sft.Name
-			oop.Prop.Parse(sft.Tag.Get("protobuf"))
-			// There will be exactly one interface field that
-			// this new value is assignable to.
-			for i := 0; i < t.NumField(); i++ {
-				f := t.Field(i)
-				if f.Type.Kind() != reflect.Interface {
-					continue
-				}
-				if !oop.Type.AssignableTo(f.Type) {
-					continue
-				}
-				oop.Field = i
-				break
-			}
-			prop.OneofTypes[oop.Prop.OrigName] = oop
-		}
-	}
-
-	// build required counts
-	// build tags
-	reqCount := 0
-	prop.decoderOrigNames = make(map[string]int)
-	for i, p := range prop.Prop {
-		if strings.HasPrefix(p.Name, "XXX_") {
-			// Internal fields should not appear in tags/origNames maps.
-			// They are handled specially when encoding and decoding.
-			continue
-		}
-		if p.Required {
-			reqCount++
-		}
-		prop.decoderTags.put(p.Tag, i)
-		prop.decoderOrigNames[p.OrigName] = i
-	}
-	prop.reqCount = reqCount
-
-	return prop
-}
-
-// Return the Properties object for the x[0]'th field of the structure.
-func propByIndex(t reflect.Type, x []int) *Properties {
-	if len(x) != 1 {
-		fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t)
-		return nil
-	}
-	prop := GetProperties(t)
-	return prop.Prop[x[0]]
-}
-
-// Get the address and type of a pointer to a struct from an interface.
-func getbase(pb Message) (t reflect.Type, b structPointer, err error) {
-	if pb == nil {
-		err = ErrNil
-		return
-	}
-	// get the reflect type of the pointer to the struct.
-	t = reflect.TypeOf(pb)
-	// get the address of the struct.
-	value := reflect.ValueOf(pb)
-	b = toStructPointer(value)
-	return
-}
-
-// A global registry of enum types.
-// The generated code will register the generated maps by calling RegisterEnum.
-
-var enumValueMaps = make(map[string]map[string]int32)
-
-// RegisterEnum is called from the generated code to install the enum descriptor
-// maps into the global table to aid parsing text format protocol buffers.
-func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
-	if _, ok := enumValueMaps[typeName]; ok {
-		panic("proto: duplicate enum registered: " + typeName)
-	}
-	enumValueMaps[typeName] = valueMap
-}
-
-// EnumValueMap returns the mapping from names to integers of the
-// enum type enumType, or a nil if not found.
-func EnumValueMap(enumType string) map[string]int32 {
-	return enumValueMaps[enumType]
-}
-
-// A registry of all linked message types.
-// The string is a fully-qualified proto name ("pkg.Message").
-var (
-	protoTypes    = make(map[string]reflect.Type)
-	revProtoTypes = make(map[reflect.Type]string)
-)
-
-// RegisterType is called from generated code and maps from the fully qualified
-// proto name to the type (pointer to struct) of the protocol buffer.
-func RegisterType(x Message, name string) {
-	if _, ok := protoTypes[name]; ok {
-		// TODO: Some day, make this a panic.
-		log.Printf("proto: duplicate proto type registered: %s", name)
-		return
-	}
-	t := reflect.TypeOf(x)
-	protoTypes[name] = t
-	revProtoTypes[t] = name
-}
-
-// MessageName returns the fully-qualified proto name for the given message type.
-func MessageName(x Message) string {
-	type xname interface {
-		XXX_MessageName() string
-	}
-	if m, ok := x.(xname); ok {
-		return m.XXX_MessageName()
-	}
-	return revProtoTypes[reflect.TypeOf(x)]
-}
-
-// MessageType returns the message type (pointer to struct) for a named message.
-func MessageType(name string) reflect.Type { return protoTypes[name] }
-
-// A registry of all linked proto files.
-var (
-	protoFiles = make(map[string][]byte) // file name => fileDescriptor
-)
-
-// RegisterFile is called from generated code and maps from the
-// full file name of a .proto file to its compressed FileDescriptorProto.
-func RegisterFile(filename string, fileDescriptor []byte) {
-	protoFiles[filename] = fileDescriptor
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
-func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go
deleted file mode 100644
index 965876bf033b64fac26deb2730244625d033fa41..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/text.go
+++ /dev/null
@@ -1,854 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for writing the text protocol buffer format.
-
-import (
-	"bufio"
-	"bytes"
-	"encoding"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"math"
-	"reflect"
-	"sort"
-	"strings"
-)
-
-var (
-	newline         = []byte("\n")
-	spaces          = []byte("                                        ")
-	gtNewline       = []byte(">\n")
-	endBraceNewline = []byte("}\n")
-	backslashN      = []byte{'\\', 'n'}
-	backslashR      = []byte{'\\', 'r'}
-	backslashT      = []byte{'\\', 't'}
-	backslashDQ     = []byte{'\\', '"'}
-	backslashBS     = []byte{'\\', '\\'}
-	posInf          = []byte("inf")
-	negInf          = []byte("-inf")
-	nan             = []byte("nan")
-)
-
-type writer interface {
-	io.Writer
-	WriteByte(byte) error
-}
-
-// textWriter is an io.Writer that tracks its indentation level.
-type textWriter struct {
-	ind      int
-	complete bool // if the current position is a complete line
-	compact  bool // whether to write out as a one-liner
-	w        writer
-}
-
-func (w *textWriter) WriteString(s string) (n int, err error) {
-	if !strings.Contains(s, "\n") {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		w.complete = false
-		return io.WriteString(w.w, s)
-	}
-	// WriteString is typically called without newlines, so this
-	// codepath and its copy are rare.  We copy to avoid
-	// duplicating all of Write's logic here.
-	return w.Write([]byte(s))
-}
-
-func (w *textWriter) Write(p []byte) (n int, err error) {
-	newlines := bytes.Count(p, newline)
-	if newlines == 0 {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		n, err = w.w.Write(p)
-		w.complete = false
-		return n, err
-	}
-
-	frags := bytes.SplitN(p, newline, newlines+1)
-	if w.compact {
-		for i, frag := range frags {
-			if i > 0 {
-				if err := w.w.WriteByte(' '); err != nil {
-					return n, err
-				}
-				n++
-			}
-			nn, err := w.w.Write(frag)
-			n += nn
-			if err != nil {
-				return n, err
-			}
-		}
-		return n, nil
-	}
-
-	for i, frag := range frags {
-		if w.complete {
-			w.writeIndent()
-		}
-		nn, err := w.w.Write(frag)
-		n += nn
-		if err != nil {
-			return n, err
-		}
-		if i+1 < len(frags) {
-			if err := w.w.WriteByte('\n'); err != nil {
-				return n, err
-			}
-			n++
-		}
-	}
-	w.complete = len(frags[len(frags)-1]) == 0
-	return n, nil
-}
-
-func (w *textWriter) WriteByte(c byte) error {
-	if w.compact && c == '\n' {
-		c = ' '
-	}
-	if !w.compact && w.complete {
-		w.writeIndent()
-	}
-	err := w.w.WriteByte(c)
-	w.complete = c == '\n'
-	return err
-}
-
-func (w *textWriter) indent() { w.ind++ }
-
-func (w *textWriter) unindent() {
-	if w.ind == 0 {
-		log.Print("proto: textWriter unindented too far")
-		return
-	}
-	w.ind--
-}
-
-func writeName(w *textWriter, props *Properties) error {
-	if _, err := w.WriteString(props.OrigName); err != nil {
-		return err
-	}
-	if props.Wire != "group" {
-		return w.WriteByte(':')
-	}
-	return nil
-}
-
-// raw is the interface satisfied by RawMessage.
-type raw interface {
-	Bytes() []byte
-}
-
-func requiresQuotes(u string) bool {
-	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
-	for _, ch := range u {
-		switch {
-		case ch == '.' || ch == '/' || ch == '_':
-			continue
-		case '0' <= ch && ch <= '9':
-			continue
-		case 'A' <= ch && ch <= 'Z':
-			continue
-		case 'a' <= ch && ch <= 'z':
-			continue
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-// isAny reports whether sv is a google.protobuf.Any message
-func isAny(sv reflect.Value) bool {
-	type wkt interface {
-		XXX_WellKnownType() string
-	}
-	t, ok := sv.Addr().Interface().(wkt)
-	return ok && t.XXX_WellKnownType() == "Any"
-}
-
-// writeProto3Any writes an expanded google.protobuf.Any message.
-//
-// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
-// required messages are not linked in).
-//
-// It returns (true, error) when sv was written in expanded format or an error
-// was encountered.
-func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
-	turl := sv.FieldByName("TypeUrl")
-	val := sv.FieldByName("Value")
-	if !turl.IsValid() || !val.IsValid() {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	b, ok := val.Interface().([]byte)
-	if !ok {
-		return true, errors.New("proto: invalid google.protobuf.Any message")
-	}
-
-	parts := strings.Split(turl.String(), "/")
-	mt := MessageType(parts[len(parts)-1])
-	if mt == nil {
-		return false, nil
-	}
-	m := reflect.New(mt.Elem())
-	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
-		return false, nil
-	}
-	w.Write([]byte("["))
-	u := turl.String()
-	if requiresQuotes(u) {
-		writeString(w, u)
-	} else {
-		w.Write([]byte(u))
-	}
-	if w.compact {
-		w.Write([]byte("]:<"))
-	} else {
-		w.Write([]byte("]: <\n"))
-		w.ind++
-	}
-	if err := tm.writeStruct(w, m.Elem()); err != nil {
-		return true, err
-	}
-	if w.compact {
-		w.Write([]byte("> "))
-	} else {
-		w.ind--
-		w.Write([]byte(">\n"))
-	}
-	return true, nil
-}
-
-func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
-	if tm.ExpandAny && isAny(sv) {
-		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
-			return err
-		}
-	}
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < sv.NumField(); i++ {
-		fv := sv.Field(i)
-		props := sprops.Prop[i]
-		name := st.Field(i).Name
-
-		if strings.HasPrefix(name, "XXX_") {
-			// There are two XXX_ fields:
-			//   XXX_unrecognized []byte
-			//   XXX_extensions   map[int32]proto.Extension
-			// The first is handled here;
-			// the second is handled at the bottom of this function.
-			if name == "XXX_unrecognized" && !fv.IsNil() {
-				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Ptr && fv.IsNil() {
-			// Field not filled in. This could be an optional field or
-			// a required field that wasn't filled in. Either way, there
-			// isn't anything we can show for it.
-			continue
-		}
-		if fv.Kind() == reflect.Slice && fv.IsNil() {
-			// Repeated field that is empty, or a bytes field that is unused.
-			continue
-		}
-
-		if props.Repeated && fv.Kind() == reflect.Slice {
-			// Repeated field.
-			for j := 0; j < fv.Len(); j++ {
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				v := fv.Index(j)
-				if v.Kind() == reflect.Ptr && v.IsNil() {
-					// A nil message in a repeated field is not valid,
-					// but we can handle that more gracefully than panicking.
-					if _, err := w.Write([]byte("<nil>\n")); err != nil {
-						return err
-					}
-					continue
-				}
-				if err := tm.writeAny(w, v, props); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if fv.Kind() == reflect.Map {
-			// Map fields are rendered as a repeated struct with key/value fields.
-			keys := fv.MapKeys()
-			sort.Sort(mapKeys(keys))
-			for _, key := range keys {
-				val := fv.MapIndex(key)
-				if err := writeName(w, props); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				// open struct
-				if err := w.WriteByte('<'); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				w.indent()
-				// key
-				if _, err := w.WriteString("key:"); err != nil {
-					return err
-				}
-				if !w.compact {
-					if err := w.WriteByte(' '); err != nil {
-						return err
-					}
-				}
-				if err := tm.writeAny(w, key, props.mkeyprop); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-				// nil values aren't legal, but we can avoid panicking because of them.
-				if val.Kind() != reflect.Ptr || !val.IsNil() {
-					// value
-					if _, err := w.WriteString("value:"); err != nil {
-						return err
-					}
-					if !w.compact {
-						if err := w.WriteByte(' '); err != nil {
-							return err
-						}
-					}
-					if err := tm.writeAny(w, val, props.mvalprop); err != nil {
-						return err
-					}
-					if err := w.WriteByte('\n'); err != nil {
-						return err
-					}
-				}
-				// close struct
-				w.unindent()
-				if err := w.WriteByte('>'); err != nil {
-					return err
-				}
-				if err := w.WriteByte('\n'); err != nil {
-					return err
-				}
-			}
-			continue
-		}
-		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
-			// empty bytes field
-			continue
-		}
-		if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
-			// proto3 non-repeated scalar field; skip if zero value
-			if isProto3Zero(fv) {
-				continue
-			}
-		}
-
-		if fv.Kind() == reflect.Interface {
-			// Check if it is a oneof.
-			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
-				// fv is nil, or holds a pointer to generated struct.
-				// That generated struct has exactly one field,
-				// which has a protobuf struct tag.
-				if fv.IsNil() {
-					continue
-				}
-				inner := fv.Elem().Elem() // interface -> *T -> T
-				tag := inner.Type().Field(0).Tag.Get("protobuf")
-				props = new(Properties) // Overwrite the outer props var, but not its pointee.
-				props.Parse(tag)
-				// Write the value in the oneof, not the oneof itself.
-				fv = inner.Field(0)
-
-				// Special case to cope with malformed messages gracefully:
-				// If the value in the oneof is a nil pointer, don't panic
-				// in writeAny.
-				if fv.Kind() == reflect.Ptr && fv.IsNil() {
-					// Use errors.New so writeAny won't render quotes.
-					msg := errors.New("/* nil */")
-					fv = reflect.ValueOf(&msg).Elem()
-				}
-			}
-		}
-
-		if err := writeName(w, props); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-		if b, ok := fv.Interface().(raw); ok {
-			if err := writeRaw(w, b.Bytes()); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// Enums have a String method, so writeAny will work fine.
-		if err := tm.writeAny(w, fv, props); err != nil {
-			return err
-		}
-
-		if err := w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-
-	// Extensions (the XXX_extensions field).
-	pv := sv.Addr()
-	if _, ok := extendable(pv.Interface()); ok {
-		if err := tm.writeExtensions(w, pv); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// writeRaw writes an uninterpreted raw message.
-func writeRaw(w *textWriter, b []byte) error {
-	if err := w.WriteByte('<'); err != nil {
-		return err
-	}
-	if !w.compact {
-		if err := w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-	w.indent()
-	if err := writeUnknownStruct(w, b); err != nil {
-		return err
-	}
-	w.unindent()
-	if err := w.WriteByte('>'); err != nil {
-		return err
-	}
-	return nil
-}
-
-// writeAny writes an arbitrary field.
-func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
-	v = reflect.Indirect(v)
-
-	// Floats have special cases.
-	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
-		x := v.Float()
-		var b []byte
-		switch {
-		case math.IsInf(x, 1):
-			b = posInf
-		case math.IsInf(x, -1):
-			b = negInf
-		case math.IsNaN(x):
-			b = nan
-		}
-		if b != nil {
-			_, err := w.Write(b)
-			return err
-		}
-		// Other values are handled below.
-	}
-
-	// We don't attempt to serialise every possible value type; only those
-	// that can occur in protocol buffers.
-	switch v.Kind() {
-	case reflect.Slice:
-		// Should only be a []byte; repeated fields are handled in writeStruct.
-		if err := writeString(w, string(v.Bytes())); err != nil {
-			return err
-		}
-	case reflect.String:
-		if err := writeString(w, v.String()); err != nil {
-			return err
-		}
-	case reflect.Struct:
-		// Required/optional group/message.
-		var bra, ket byte = '<', '>'
-		if props != nil && props.Wire == "group" {
-			bra, ket = '{', '}'
-		}
-		if err := w.WriteByte(bra); err != nil {
-			return err
-		}
-		if !w.compact {
-			if err := w.WriteByte('\n'); err != nil {
-				return err
-			}
-		}
-		w.indent()
-		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
-			text, err := etm.MarshalText()
-			if err != nil {
-				return err
-			}
-			if _, err = w.Write(text); err != nil {
-				return err
-			}
-		} else if err := tm.writeStruct(w, v); err != nil {
-			return err
-		}
-		w.unindent()
-		if err := w.WriteByte(ket); err != nil {
-			return err
-		}
-	default:
-		_, err := fmt.Fprint(w, v.Interface())
-		return err
-	}
-	return nil
-}
-
-// equivalent to C's isprint.
-func isprint(c byte) bool {
-	return c >= 0x20 && c < 0x7f
-}
-
-// writeString writes a string in the protocol buffer text format.
-// It is similar to strconv.Quote except we don't use Go escape sequences,
-// we treat the string as a byte sequence, and we use octal escapes.
-// These differences are to maintain interoperability with the other
-// languages' implementations of the text format.
-func writeString(w *textWriter, s string) error {
-	// use WriteByte here to get any needed indent
-	if err := w.WriteByte('"'); err != nil {
-		return err
-	}
-	// Loop over the bytes, not the runes.
-	for i := 0; i < len(s); i++ {
-		var err error
-		// Divergence from C++: we don't escape apostrophes.
-		// There's no need to escape them, and the C++ parser
-		// copes with a naked apostrophe.
-		switch c := s[i]; c {
-		case '\n':
-			_, err = w.w.Write(backslashN)
-		case '\r':
-			_, err = w.w.Write(backslashR)
-		case '\t':
-			_, err = w.w.Write(backslashT)
-		case '"':
-			_, err = w.w.Write(backslashDQ)
-		case '\\':
-			_, err = w.w.Write(backslashBS)
-		default:
-			if isprint(c) {
-				err = w.w.WriteByte(c)
-			} else {
-				_, err = fmt.Fprintf(w.w, "\\%03o", c)
-			}
-		}
-		if err != nil {
-			return err
-		}
-	}
-	return w.WriteByte('"')
-}
-
-func writeUnknownStruct(w *textWriter, data []byte) (err error) {
-	if !w.compact {
-		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
-			return err
-		}
-	}
-	b := NewBuffer(data)
-	for b.index < len(b.buf) {
-		x, err := b.DecodeVarint()
-		if err != nil {
-			_, err := fmt.Fprintf(w, "/* %v */\n", err)
-			return err
-		}
-		wire, tag := x&7, x>>3
-		if wire == WireEndGroup {
-			w.unindent()
-			if _, err := w.Write(endBraceNewline); err != nil {
-				return err
-			}
-			continue
-		}
-		if _, err := fmt.Fprint(w, tag); err != nil {
-			return err
-		}
-		if wire != WireStartGroup {
-			if err := w.WriteByte(':'); err != nil {
-				return err
-			}
-		}
-		if !w.compact || wire == WireStartGroup {
-			if err := w.WriteByte(' '); err != nil {
-				return err
-			}
-		}
-		switch wire {
-		case WireBytes:
-			buf, e := b.DecodeRawBytes(false)
-			if e == nil {
-				_, err = fmt.Fprintf(w, "%q", buf)
-			} else {
-				_, err = fmt.Fprintf(w, "/* %v */", e)
-			}
-		case WireFixed32:
-			x, err = b.DecodeFixed32()
-			err = writeUnknownInt(w, x, err)
-		case WireFixed64:
-			x, err = b.DecodeFixed64()
-			err = writeUnknownInt(w, x, err)
-		case WireStartGroup:
-			err = w.WriteByte('{')
-			w.indent()
-		case WireVarint:
-			x, err = b.DecodeVarint()
-			err = writeUnknownInt(w, x, err)
-		default:
-			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
-		}
-		if err != nil {
-			return err
-		}
-		if err = w.WriteByte('\n'); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeUnknownInt(w *textWriter, x uint64, err error) error {
-	if err == nil {
-		_, err = fmt.Fprint(w, x)
-	} else {
-		_, err = fmt.Fprintf(w, "/* %v */", err)
-	}
-	return err
-}
-
-type int32Slice []int32
-
-func (s int32Slice) Len() int           { return len(s) }
-func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
-func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-// writeExtensions writes all the extensions in pv.
-// pv is assumed to be a pointer to a protocol message struct that is extendable.
-func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
-	emap := extensionMaps[pv.Type().Elem()]
-	ep, _ := extendable(pv.Interface())
-
-	// Order the extensions by ID.
-	// This isn't strictly necessary, but it will give us
-	// canonical output, which will also make testing easier.
-	m, mu := ep.extensionsRead()
-	if m == nil {
-		return nil
-	}
-	mu.Lock()
-	ids := make([]int32, 0, len(m))
-	for id := range m {
-		ids = append(ids, id)
-	}
-	sort.Sort(int32Slice(ids))
-	mu.Unlock()
-
-	for _, extNum := range ids {
-		ext := m[extNum]
-		var desc *ExtensionDesc
-		if emap != nil {
-			desc = emap[extNum]
-		}
-		if desc == nil {
-			// Unknown extension.
-			if err := writeUnknownStruct(w, ext.enc); err != nil {
-				return err
-			}
-			continue
-		}
-
-		pb, err := GetExtension(ep, desc)
-		if err != nil {
-			return fmt.Errorf("failed getting extension: %v", err)
-		}
-
-		// Repeated extensions will appear as a slice.
-		if !desc.repeated() {
-			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
-				return err
-			}
-		} else {
-			v := reflect.ValueOf(pb)
-			for i := 0; i < v.Len(); i++ {
-				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
-	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
-		return err
-	}
-	if !w.compact {
-		if err := w.WriteByte(' '); err != nil {
-			return err
-		}
-	}
-	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
-		return err
-	}
-	if err := w.WriteByte('\n'); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (w *textWriter) writeIndent() {
-	if !w.complete {
-		return
-	}
-	remain := w.ind * 2
-	for remain > 0 {
-		n := remain
-		if n > len(spaces) {
-			n = len(spaces)
-		}
-		w.w.Write(spaces[:n])
-		remain -= n
-	}
-	w.complete = false
-}
-
-// TextMarshaler is a configurable text format marshaler.
-type TextMarshaler struct {
-	Compact   bool // use compact text format (one line).
-	ExpandAny bool // expand google.protobuf.Any messages of known types
-}
-
-// Marshal writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
-	val := reflect.ValueOf(pb)
-	if pb == nil || val.IsNil() {
-		w.Write([]byte("<nil>"))
-		return nil
-	}
-	var bw *bufio.Writer
-	ww, ok := w.(writer)
-	if !ok {
-		bw = bufio.NewWriter(w)
-		ww = bw
-	}
-	aw := &textWriter{
-		w:        ww,
-		complete: true,
-		compact:  tm.Compact,
-	}
-
-	if etm, ok := pb.(encoding.TextMarshaler); ok {
-		text, err := etm.MarshalText()
-		if err != nil {
-			return err
-		}
-		if _, err = aw.Write(text); err != nil {
-			return err
-		}
-		if bw != nil {
-			return bw.Flush()
-		}
-		return nil
-	}
-	// Dereference the received pointer so we don't have outer < and >.
-	v := reflect.Indirect(val)
-	if err := tm.writeStruct(aw, v); err != nil {
-		return err
-	}
-	if bw != nil {
-		return bw.Flush()
-	}
-	return nil
-}
-
-// Text is the same as Marshal, but returns the string directly.
-func (tm *TextMarshaler) Text(pb Message) string {
-	var buf bytes.Buffer
-	tm.Marshal(&buf, pb)
-	return buf.String()
-}
-
-var (
-	defaultTextMarshaler = TextMarshaler{}
-	compactTextMarshaler = TextMarshaler{Compact: true}
-)
-
-// TODO: consider removing some of the Marshal functions below.
-
-// MarshalText writes a given protocol buffer in text format.
-// The only errors returned are from w.
-func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
-
-// MarshalTextString is the same as MarshalText, but returns the string directly.
-func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
-
-// CompactText writes a given protocol buffer in compact text format (one line).
-func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
-
-// CompactTextString is the same as CompactText, but returns the string directly.
-func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go
deleted file mode 100644
index 5e14513f28c9041020ee559c9ec437361720024f..0000000000000000000000000000000000000000
--- a/vendor/github.com/golang/protobuf/proto/text_parser.go
+++ /dev/null
@@ -1,895 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package proto
-
-// Functions for parsing the Text protocol buffer format.
-// TODO: message sets.
-
-import (
-	"encoding"
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-)
-
-// Error string emitted when deserializing Any and fields are already set
-const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
-
-type ParseError struct {
-	Message string
-	Line    int // 1-based line number
-	Offset  int // 0-based byte offset from start of input
-}
-
-func (p *ParseError) Error() string {
-	if p.Line == 1 {
-		// show offset only for first line
-		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
-	}
-	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
-}
-
-type token struct {
-	value    string
-	err      *ParseError
-	line     int    // line number
-	offset   int    // byte number from start of input, not start of line
-	unquoted string // the unquoted version of value, if it was a quoted string
-}
-
-func (t *token) String() string {
-	if t.err == nil {
-		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
-	}
-	return fmt.Sprintf("parse error: %v", t.err)
-}
-
-type textParser struct {
-	s            string // remaining input
-	done         bool   // whether the parsing is finished (success or error)
-	backed       bool   // whether back() was called
-	offset, line int
-	cur          token
-}
-
-func newTextParser(s string) *textParser {
-	p := new(textParser)
-	p.s = s
-	p.line = 1
-	p.cur.line = 1
-	return p
-}
-
-func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
-	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
-	p.cur.err = pe
-	p.done = true
-	return pe
-}
-
-// Numbers and identifiers are matched by [-+._A-Za-z0-9]
-func isIdentOrNumberChar(c byte) bool {
-	switch {
-	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
-		return true
-	case '0' <= c && c <= '9':
-		return true
-	}
-	switch c {
-	case '-', '+', '.', '_':
-		return true
-	}
-	return false
-}
-
-func isWhitespace(c byte) bool {
-	switch c {
-	case ' ', '\t', '\n', '\r':
-		return true
-	}
-	return false
-}
-
-func isQuote(c byte) bool {
-	switch c {
-	case '"', '\'':
-		return true
-	}
-	return false
-}
-
-func (p *textParser) skipWhitespace() {
-	i := 0
-	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
-		if p.s[i] == '#' {
-			// comment; skip to end of line or input
-			for i < len(p.s) && p.s[i] != '\n' {
-				i++
-			}
-			if i == len(p.s) {
-				break
-			}
-		}
-		if p.s[i] == '\n' {
-			p.line++
-		}
-		i++
-	}
-	p.offset += i
-	p.s = p.s[i:len(p.s)]
-	if len(p.s) == 0 {
-		p.done = true
-	}
-}
-
-func (p *textParser) advance() {
-	// Skip whitespace
-	p.skipWhitespace()
-	if p.done {
-		return
-	}
-
-	// Start of non-whitespace
-	p.cur.err = nil
-	p.cur.offset, p.cur.line = p.offset, p.line
-	p.cur.unquoted = ""
-	switch p.s[0] {
-	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
-		// Single symbol
-		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
-	case '"', '\'':
-		// Quoted string
-		i := 1
-		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
-			if p.s[i] == '\\' && i+1 < len(p.s) {
-				// skip escaped char
-				i++
-			}
-			i++
-		}
-		if i >= len(p.s) || p.s[i] != p.s[0] {
-			p.errorf("unmatched quote")
-			return
-		}
-		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
-		if err != nil {
-			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
-			return
-		}
-		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
-		p.cur.unquoted = unq
-	default:
-		i := 0
-		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
-			i++
-		}
-		if i == 0 {
-			p.errorf("unexpected byte %#x", p.s[0])
-			return
-		}
-		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
-	}
-	p.offset += len(p.cur.value)
-}
-
-var (
-	errBadUTF8 = errors.New("proto: bad UTF-8")
-	errBadHex  = errors.New("proto: bad hexadecimal")
-)
-
-func unquoteC(s string, quote rune) (string, error) {
-	// This is based on C++'s tokenizer.cc.
-	// Despite its name, this is *not* parsing C syntax.
-	// For instance, "\0" is an invalid quoted string.
-
-	// Avoid allocation in trivial cases.
-	simple := true
-	for _, r := range s {
-		if r == '\\' || r == quote {
-			simple = false
-			break
-		}
-	}
-	if simple {
-		return s, nil
-	}
-
-	buf := make([]byte, 0, 3*len(s)/2)
-	for len(s) > 0 {
-		r, n := utf8.DecodeRuneInString(s)
-		if r == utf8.RuneError && n == 1 {
-			return "", errBadUTF8
-		}
-		s = s[n:]
-		if r != '\\' {
-			if r < utf8.RuneSelf {
-				buf = append(buf, byte(r))
-			} else {
-				buf = append(buf, string(r)...)
-			}
-			continue
-		}
-
-		ch, tail, err := unescape(s)
-		if err != nil {
-			return "", err
-		}
-		buf = append(buf, ch...)
-		s = tail
-	}
-	return string(buf), nil
-}
-
-func unescape(s string) (ch string, tail string, err error) {
-	r, n := utf8.DecodeRuneInString(s)
-	if r == utf8.RuneError && n == 1 {
-		return "", "", errBadUTF8
-	}
-	s = s[n:]
-	switch r {
-	case 'a':
-		return "\a", s, nil
-	case 'b':
-		return "\b", s, nil
-	case 'f':
-		return "\f", s, nil
-	case 'n':
-		return "\n", s, nil
-	case 'r':
-		return "\r", s, nil
-	case 't':
-		return "\t", s, nil
-	case 'v':
-		return "\v", s, nil
-	case '?':
-		return "?", s, nil // trigraph workaround
-	case '\'', '"', '\\':
-		return string(r), s, nil
-	case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X':
-		if len(s) < 2 {
-			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
-		}
-		base := 8
-		ss := s[:2]
-		s = s[2:]
-		if r == 'x' || r == 'X' {
-			base = 16
-		} else {
-			ss = string(r) + ss
-		}
-		i, err := strconv.ParseUint(ss, base, 8)
-		if err != nil {
-			return "", "", err
-		}
-		return string([]byte{byte(i)}), s, nil
-	case 'u', 'U':
-		n := 4
-		if r == 'U' {
-			n = 8
-		}
-		if len(s) < n {
-			return "", "", fmt.Errorf(`\%c requires %d digits`, r, n)
-		}
-
-		bs := make([]byte, n/2)
-		for i := 0; i < n; i += 2 {
-			a, ok1 := unhex(s[i])
-			b, ok2 := unhex(s[i+1])
-			if !ok1 || !ok2 {
-				return "", "", errBadHex
-			}
-			bs[i/2] = a<<4 | b
-		}
-		s = s[n:]
-		return string(bs), s, nil
-	}
-	return "", "", fmt.Errorf(`unknown escape \%c`, r)
-}
-
-// Adapted from src/pkg/strconv/quote.go.
-func unhex(b byte) (v byte, ok bool) {
-	switch {
-	case '0' <= b && b <= '9':
-		return b - '0', true
-	case 'a' <= b && b <= 'f':
-		return b - 'a' + 10, true
-	case 'A' <= b && b <= 'F':
-		return b - 'A' + 10, true
-	}
-	return 0, false
-}
-
-// Back off the parser by one token. Can only be done between calls to next().
-// It makes the next advance() a no-op.
-func (p *textParser) back() { p.backed = true }
-
-// Advances the parser and returns the new current token.
-func (p *textParser) next() *token {
-	if p.backed || p.done {
-		p.backed = false
-		return &p.cur
-	}
-	p.advance()
-	if p.done {
-		p.cur.value = ""
-	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
-		// Look for multiple quoted strings separated by whitespace,
-		// and concatenate them.
-		cat := p.cur
-		for {
-			p.skipWhitespace()
-			if p.done || !isQuote(p.s[0]) {
-				break
-			}
-			p.advance()
-			if p.cur.err != nil {
-				return &p.cur
-			}
-			cat.value += " " + p.cur.value
-			cat.unquoted += p.cur.unquoted
-		}
-		p.done = false // parser may have seen EOF, but we want to return cat
-		p.cur = cat
-	}
-	return &p.cur
-}
-
-func (p *textParser) consumeToken(s string) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != s {
-		p.back()
-		return p.errorf("expected %q, found %q", s, tok.value)
-	}
-	return nil
-}
-
-// Return a RequiredNotSetError indicating which required field was not set.
-func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	for i := 0; i < st.NumField(); i++ {
-		if !isNil(sv.Field(i)) {
-			continue
-		}
-
-		props := sprops.Prop[i]
-		if props.Required {
-			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
-		}
-	}
-	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
-}
-
-// Returns the index in the struct for the named field, as well as the parsed tag properties.
-func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
-	i, ok := sprops.decoderOrigNames[name]
-	if ok {
-		return i, sprops.Prop[i], true
-	}
-	return -1, nil, false
-}
-
-// Consume a ':' from the input stream (if the next token is a colon),
-// returning an error if a colon is needed but not present.
-func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ":" {
-		// Colon is optional when the field is a group or message.
-		needColon := true
-		switch props.Wire {
-		case "group":
-			needColon = false
-		case "bytes":
-			// A "bytes" field is either a message, a string, or a repeated field;
-			// those three become *T, *string and []T respectively, so we can check for
-			// this field being a pointer to a non-string.
-			if typ.Kind() == reflect.Ptr {
-				// *T or *string
-				if typ.Elem().Kind() == reflect.String {
-					break
-				}
-			} else if typ.Kind() == reflect.Slice {
-				// []T or []*T
-				if typ.Elem().Kind() != reflect.Ptr {
-					break
-				}
-			} else if typ.Kind() == reflect.String {
-				// The proto3 exception is for a string field,
-				// which requires a colon.
-				break
-			}
-			needColon = false
-		}
-		if needColon {
-			return p.errorf("expected ':', found %q", tok.value)
-		}
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
-	st := sv.Type()
-	sprops := GetProperties(st)
-	reqCount := sprops.reqCount
-	var reqFieldErr error
-	fieldSet := make(map[string]bool)
-	// A struct is a sequence of "name: value", terminated by one of
-	// '>' or '}', or the end of the input.  A name may also be
-	// "[extension]" or "[type/url]".
-	//
-	// The whole struct can also be an expanded Any message, like:
-	// [type/url] < ... struct contents ... >
-	for {
-		tok := p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		if tok.value == terminator {
-			break
-		}
-		if tok.value == "[" {
-			// Looks like an extension or an Any.
-			//
-			// TODO: Check whether we need to handle
-			// namespace rooted names (e.g. ".something.Foo").
-			extName, err := p.consumeExtName()
-			if err != nil {
-				return err
-			}
-
-			if s := strings.LastIndex(extName, "/"); s >= 0 {
-				// If it contains a slash, it's an Any type URL.
-				messageName := extName[s+1:]
-				mt := MessageType(messageName)
-				if mt == nil {
-					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
-				}
-				tok = p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				// consume an optional colon
-				if tok.value == ":" {
-					tok = p.next()
-					if tok.err != nil {
-						return tok.err
-					}
-				}
-				var terminator string
-				switch tok.value {
-				case "<":
-					terminator = ">"
-				case "{":
-					terminator = "}"
-				default:
-					return p.errorf("expected '{' or '<', found %q", tok.value)
-				}
-				v := reflect.New(mt.Elem())
-				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
-					return pe
-				}
-				b, err := Marshal(v.Interface().(Message))
-				if err != nil {
-					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
-				}
-				if fieldSet["type_url"] {
-					return p.errorf(anyRepeatedlyUnpacked, "type_url")
-				}
-				if fieldSet["value"] {
-					return p.errorf(anyRepeatedlyUnpacked, "value")
-				}
-				sv.FieldByName("TypeUrl").SetString(extName)
-				sv.FieldByName("Value").SetBytes(b)
-				fieldSet["type_url"] = true
-				fieldSet["value"] = true
-				continue
-			}
-
-			var desc *ExtensionDesc
-			// This could be faster, but it's functional.
-			// TODO: Do something smarter than a linear scan.
-			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
-				if d.Name == extName {
-					desc = d
-					break
-				}
-			}
-			if desc == nil {
-				return p.errorf("unrecognized extension %q", extName)
-			}
-
-			props := &Properties{}
-			props.Parse(desc.Tag)
-
-			typ := reflect.TypeOf(desc.ExtensionType)
-			if err := p.checkForColon(props, typ); err != nil {
-				return err
-			}
-
-			rep := desc.repeated()
-
-			// Read the extension structure, and set it in
-			// the value we're constructing.
-			var ext reflect.Value
-			if !rep {
-				ext = reflect.New(typ).Elem()
-			} else {
-				ext = reflect.New(typ.Elem()).Elem()
-			}
-			if err := p.readAny(ext, props); err != nil {
-				if _, ok := err.(*RequiredNotSetError); !ok {
-					return err
-				}
-				reqFieldErr = err
-			}
-			ep := sv.Addr().Interface().(Message)
-			if !rep {
-				SetExtension(ep, desc, ext.Interface())
-			} else {
-				old, err := GetExtension(ep, desc)
-				var sl reflect.Value
-				if err == nil {
-					sl = reflect.ValueOf(old) // existing slice
-				} else {
-					sl = reflect.MakeSlice(typ, 0, 1)
-				}
-				sl = reflect.Append(sl, ext)
-				SetExtension(ep, desc, sl.Interface())
-			}
-			if err := p.consumeOptionalSeparator(); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// This is a normal, non-extension field.
-		name := tok.value
-		var dst reflect.Value
-		fi, props, ok := structFieldByName(sprops, name)
-		if ok {
-			dst = sv.Field(fi)
-		} else if oop, ok := sprops.OneofTypes[name]; ok {
-			// It is a oneof.
-			props = oop.Prop
-			nv := reflect.New(oop.Type.Elem())
-			dst = nv.Elem().Field(0)
-			field := sv.Field(oop.Field)
-			if !field.IsNil() {
-				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
-			}
-			field.Set(nv)
-		}
-		if !dst.IsValid() {
-			return p.errorf("unknown field name %q in %v", name, st)
-		}
-
-		if dst.Kind() == reflect.Map {
-			// Consume any colon.
-			if err := p.checkForColon(props, dst.Type()); err != nil {
-				return err
-			}
-
-			// Construct the map if it doesn't already exist.
-			if dst.IsNil() {
-				dst.Set(reflect.MakeMap(dst.Type()))
-			}
-			key := reflect.New(dst.Type().Key()).Elem()
-			val := reflect.New(dst.Type().Elem()).Elem()
-
-			// The map entry should be this sequence of tokens:
-			//	< key : KEY value : VALUE >
-			// However, implementations may omit key or value, and technically
-			// we should support them in any order.  See b/28924776 for a time
-			// this went wrong.
-
-			tok := p.next()
-			var terminator string
-			switch tok.value {
-			case "<":
-				terminator = ">"
-			case "{":
-				terminator = "}"
-			default:
-				return p.errorf("expected '{' or '<', found %q", tok.value)
-			}
-			for {
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == terminator {
-					break
-				}
-				switch tok.value {
-				case "key":
-					if err := p.consumeToken(":"); err != nil {
-						return err
-					}
-					if err := p.readAny(key, props.mkeyprop); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				case "value":
-					if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
-						return err
-					}
-					if err := p.readAny(val, props.mvalprop); err != nil {
-						return err
-					}
-					if err := p.consumeOptionalSeparator(); err != nil {
-						return err
-					}
-				default:
-					p.back()
-					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
-				}
-			}
-
-			dst.SetMapIndex(key, val)
-			continue
-		}
-
-		// Check that it's not already set if it's not a repeated field.
-		if !props.Repeated && fieldSet[name] {
-			return p.errorf("non-repeated field %q was repeated", name)
-		}
-
-		if err := p.checkForColon(props, dst.Type()); err != nil {
-			return err
-		}
-
-		// Parse into the field.
-		fieldSet[name] = true
-		if err := p.readAny(dst, props); err != nil {
-			if _, ok := err.(*RequiredNotSetError); !ok {
-				return err
-			}
-			reqFieldErr = err
-		}
-		if props.Required {
-			reqCount--
-		}
-
-		if err := p.consumeOptionalSeparator(); err != nil {
-			return err
-		}
-
-	}
-
-	if reqCount > 0 {
-		return p.missingRequiredFieldError(sv)
-	}
-	return reqFieldErr
-}
-
-// consumeExtName consumes extension name or expanded Any type URL and the
-// following ']'. It returns the name or URL consumed.
-func (p *textParser) consumeExtName() (string, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return "", tok.err
-	}
-
-	// If extension name or type url is quoted, it's a single token.
-	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
-		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
-		if err != nil {
-			return "", err
-		}
-		return name, p.consumeToken("]")
-	}
-
-	// Consume everything up to "]"
-	var parts []string
-	for tok.value != "]" {
-		parts = append(parts, tok.value)
-		tok = p.next()
-		if tok.err != nil {
-			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
-		}
-	}
-	return strings.Join(parts, ""), nil
-}
-
-// consumeOptionalSeparator consumes an optional semicolon or comma.
-// It is used in readStruct to provide backward compatibility.
-func (p *textParser) consumeOptionalSeparator() error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ";" && tok.value != "," {
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) readAny(v reflect.Value, props *Properties) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value == "" {
-		return p.errorf("unexpected EOF")
-	}
-
-	switch fv := v; fv.Kind() {
-	case reflect.Slice:
-		at := v.Type()
-		if at.Elem().Kind() == reflect.Uint8 {
-			// Special case for []byte
-			if tok.value[0] != '"' && tok.value[0] != '\'' {
-				// Deliberately written out here, as the error after
-				// this switch statement would write "invalid []byte: ...",
-				// which is not as user-friendly.
-				return p.errorf("invalid string: %v", tok.value)
-			}
-			bytes := []byte(tok.unquoted)
-			fv.Set(reflect.ValueOf(bytes))
-			return nil
-		}
-		// Repeated field.
-		if tok.value == "[" {
-			// Repeated field with list notation, like [1,2,3].
-			for {
-				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-				err := p.readAny(fv.Index(fv.Len()-1), props)
-				if err != nil {
-					return err
-				}
-				tok := p.next()
-				if tok.err != nil {
-					return tok.err
-				}
-				if tok.value == "]" {
-					break
-				}
-				if tok.value != "," {
-					return p.errorf("Expected ']' or ',' found %q", tok.value)
-				}
-			}
-			return nil
-		}
-		// One value of the repeated field.
-		p.back()
-		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
-		return p.readAny(fv.Index(fv.Len()-1), props)
-	case reflect.Bool:
-		// true/1/t/True or false/f/0/False.
-		switch tok.value {
-		case "true", "1", "t", "True":
-			fv.SetBool(true)
-			return nil
-		case "false", "0", "f", "False":
-			fv.SetBool(false)
-			return nil
-		}
-	case reflect.Float32, reflect.Float64:
-		v := tok.value
-		// Ignore 'f' for compatibility with output generated by C++, but don't
-		// remove 'f' when the value is "-inf" or "inf".
-		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
-			v = v[:len(v)-1]
-		}
-		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
-			fv.SetFloat(f)
-			return nil
-		}
-	case reflect.Int32:
-		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-		if len(props.Enum) == 0 {
-			break
-		}
-		m, ok := enumValueMaps[props.Enum]
-		if !ok {
-			break
-		}
-		x, ok := m[tok.value]
-		if !ok {
-			break
-		}
-		fv.SetInt(int64(x))
-		return nil
-	case reflect.Int64:
-		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
-			fv.SetInt(x)
-			return nil
-		}
-
-	case reflect.Ptr:
-		// A basic field (indirected through pointer), or a repeated message/group
-		p.back()
-		fv.Set(reflect.New(fv.Type().Elem()))
-		return p.readAny(fv.Elem(), props)
-	case reflect.String:
-		if tok.value[0] == '"' || tok.value[0] == '\'' {
-			fv.SetString(tok.unquoted)
-			return nil
-		}
-	case reflect.Struct:
-		var terminator string
-		switch tok.value {
-		case "{":
-			terminator = "}"
-		case "<":
-			terminator = ">"
-		default:
-			return p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
-		return p.readStruct(fv, terminator)
-	case reflect.Uint32:
-		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-			fv.SetUint(x)
-			return nil
-		}
-	case reflect.Uint64:
-		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
-			fv.SetUint(x)
-			return nil
-		}
-	}
-	return p.errorf("invalid %v: %v", v.Type(), tok.value)
-}
-
-// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
-// before starting to unmarshal, so any existing data in pb is always removed.
-// If a required field is not set and no other error occurs,
-// UnmarshalText returns *RequiredNotSetError.
-func UnmarshalText(s string, pb Message) error {
-	if um, ok := pb.(encoding.TextUnmarshaler); ok {
-		err := um.UnmarshalText([]byte(s))
-		return err
-	}
-	pb.Reset()
-	v := reflect.ValueOf(pb)
-	if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil {
-		return pe
-	}
-	return nil
-}
diff --git a/vendor/github.com/google/go-jsonnet/CONTRIBUTING b/vendor/github.com/google/go-jsonnet/CONTRIBUTING
new file mode 100644
index 0000000000000000000000000000000000000000..5189a6f2ce3ff14b1be8a3f03be4a5312b37f27d
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/CONTRIBUTING
@@ -0,0 +1,4 @@
+Before we can merge your pull request, we need you to sign either the Google individual or corporate
+contributor license agreement (CLA), unless you are a Google employee, intern, or contractor.
+
+Please see http://jsonnet.org/contributing.html for more information.
diff --git a/vendor/github.com/google/go-jsonnet/README.md b/vendor/github.com/google/go-jsonnet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ce4a2d680893b96280d7b2d4600ad4904f0d645
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/README.md
@@ -0,0 +1,47 @@
+# go-jsonnet
+
+[![GoDoc Widget]][GoDoc] [![Travis Widget]][Travis] [![Coverage Status Widget]][Coverage Status]
+
+[GoDoc]: https://godoc.org/github.com/google/go-jsonnet
+[GoDoc Widget]: https://godoc.org/github.com/google/go-jsonnet?status.png
+[Travis]: https://travis-ci.org/google/go-jsonnet
+[Travis Widget]: https://travis-ci.org/google/go-jsonnet.svg?branch=master
+[Coverage Status Widget]: https://coveralls.io/repos/github/google/go-jsonnet/badge.svg?branch=master
+[Coverage Status]: https://coveralls.io/github/google/go-jsonnet?branch=master
+
+This an implementation of [Jsonnet](http://jsonnet.org/) in pure Go.  It is
+feature complete but is not as heavily exercised as the [Jsonnet C++
+implementation](https://github.com/google/jsonnet).  Please try it out and give
+feedback.
+
+This code is known to work on Go 1.6 and above.
+
+## Build instructions
+
+```
+export GOPATH=$HOME/go-workspace
+mkdir -pv $GOPATH
+go get github.com/google/go-jsonnet
+cd $GOPATH/src/github.com/google/go-jsonnet
+cd jsonnet
+go build
+./jsonnet /dev/stdin <<< '{x: 1, y: self.x} + {x: 10}'
+{
+   "x": 10,
+   "y": 10
+}
+```
+
+## Implementation Notes
+
+We are generating some helper classes on types by using
+http://clipperhouse.github.io/gen/.  Do the following to regenerate these if
+necessary:
+
+```
+go get github.com/mjibson/esc
+go get github.com/clipperhouse/gen
+go get github.com/clipperhouse/set
+export PATH=$PATH:$GOPATH/bin  # If you haven't already
+go generate
+```
diff --git a/vendor/github.com/google/go-jsonnet/_gen.go b/vendor/github.com/google/go-jsonnet/_gen.go
new file mode 100644
index 0000000000000000000000000000000000000000..9828a2a24c88a81a55abd4fd09c32d26b9575284
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/_gen.go
@@ -0,0 +1,7 @@
+package main
+
+import (
+	_ "github.com/clipperhouse/set"
+	_ "github.com/clipperhouse/slice"
+	_ "github.com/clipperhouse/stringer"
+)
diff --git a/vendor/github.com/google/go-jsonnet/ast/ast.go b/vendor/github.com/google/go-jsonnet/ast/ast.go
index d943d510e4191d6511f8c75de9066fd28cae12d6..1e9f389f37802fb09af3153232a1068857286693 100644
--- a/vendor/github.com/google/go-jsonnet/ast/ast.go
+++ b/vendor/github.com/google/go-jsonnet/ast/ast.go
@@ -30,10 +30,14 @@ type Identifiers []Identifier
 
 // ---------------------------------------------------------------------------
 
+type Context *string
+
 type Node interface {
+	Context() Context
 	Loc() *LocationRange
 	FreeVariables() Identifiers
 	SetFreeVariables(Identifiers)
+	SetContext(Context)
 }
 type Nodes []Node
 
@@ -41,6 +45,7 @@ type Nodes []Node
 
 type NodeBase struct {
 	loc           LocationRange
+	context       Context
 	freeVariables Identifiers
 }
 
@@ -70,24 +75,44 @@ func (n *NodeBase) SetFreeVariables(idents Identifiers) {
 	n.freeVariables = idents
 }
 
-// ---------------------------------------------------------------------------
+func (n *NodeBase) Context() Context {
+	return n.context
+}
 
-// +gen stringer
-type CompKind int
+func (n *NodeBase) SetContext(context Context) {
+	n.context = context
+}
 
-const (
-	CompFor CompKind = iota
-	CompIf
-)
+// ---------------------------------------------------------------------------
 
-// TODO(sbarzowski) separate types for two kinds
-// TODO(sbarzowski) bonus points for attaching ifs to the previous for
-type CompSpec struct {
-	Kind    CompKind
-	VarName *Identifier // nil when kind != compSpecFor
-	Expr    Node
+type IfSpec struct {
+	Expr Node
+}
+
+// Example:
+// expr for x in arr1 for y in arr2 for z in arr3
+// The order is the same as in python, i.e. the leftmost is the outermost.
+//
+// Our internal representation reflects how they are semantically nested:
+// ForSpec(z, outer=ForSpec(y, outer=ForSpec(x, outer=nil)))
+// Any ifspecs are attached to the relevant ForSpec.
+//
+// Ifs are attached to the one on the left, for example:
+// expr for x in arr1 for y in arr2 if x % 2 == 0 for z in arr3
+// The if is attached to the y forspec.
+//
+// It desugares to:
+// flatMap(\x ->
+//         flatMap(\y ->
+//                 flatMap(\z -> [expr], arr3)
+//                 arr2)
+//         arr3)
+type ForSpec struct {
+	VarName    Identifier
+	Expr       Node
+	Conditions []IfSpec
+	Outer      *ForSpec
 }
-type CompSpecs []CompSpec
 
 // ---------------------------------------------------------------------------
 
@@ -95,10 +120,19 @@ type CompSpecs []CompSpec
 type Apply struct {
 	NodeBase
 	Target        Node
-	Arguments     Nodes
+	Arguments     Arguments
 	TrailingComma bool
 	TailStrict    bool
-	// TODO(sbarzowski) support named arguments
+}
+
+type NamedArgument struct {
+	Name Identifier
+	Arg  Node
+}
+
+type Arguments struct {
+	Positional Nodes
+	Named      []NamedArgument
 }
 
 // ---------------------------------------------------------------------------
@@ -127,7 +161,7 @@ type ArrayComp struct {
 	NodeBase
 	Body          Node
 	TrailingComma bool
-	Specs         CompSpecs
+	Spec          ForSpec
 }
 
 // ---------------------------------------------------------------------------
@@ -277,17 +311,27 @@ type Error struct {
 // Function represents a function definition
 type Function struct {
 	NodeBase
-	Parameters    Identifiers // TODO(sbarzowski) support default arguments
+	Parameters    Parameters
 	TrailingComma bool
 	Body          Node
 }
 
+type NamedParameter struct {
+	Name       Identifier
+	DefaultArg Node
+}
+
+type Parameters struct {
+	Required Identifiers
+	Optional []NamedParameter
+}
+
 // ---------------------------------------------------------------------------
 
 // Import represents import "file".
 type Import struct {
 	NodeBase
-	File string
+	File *LiteralString
 }
 
 // ---------------------------------------------------------------------------
@@ -295,7 +339,7 @@ type Import struct {
 // ImportStr represents importstr "file".
 type ImportStr struct {
 	NodeBase
-	File string
+	File *LiteralString
 }
 
 // ---------------------------------------------------------------------------
@@ -325,11 +369,9 @@ type Slice struct {
 
 // LocalBind is a helper struct for astLocal
 type LocalBind struct {
-	Variable      Identifier
-	Body          Node
-	FunctionSugar bool
-	Params        Identifiers // if functionSugar is true
-	TrailingComma bool
+	Variable Identifier
+	Body     Node
+	Fun      *Function
 }
 type LocalBinds []LocalBind
 
@@ -364,7 +406,6 @@ type LiteralNumber struct {
 
 // ---------------------------------------------------------------------------
 
-// +gen stringer
 type LiteralStringKind int
 
 const (
@@ -375,6 +416,16 @@ const (
 	VerbatimStringSingle
 )
 
+func (k LiteralStringKind) FullyEscaped() bool {
+	switch k {
+	case StringSingle, StringDouble:
+		return true
+	case StringBlock, VerbatimStringDouble, VerbatimStringSingle:
+		return false
+	}
+	panic(fmt.Sprintf("Unknown string kind: %v", k))
+}
+
 // LiteralString represents a JSON string
 type LiteralString struct {
 	NodeBase
@@ -385,7 +436,6 @@ type LiteralString struct {
 
 // ---------------------------------------------------------------------------
 
-// +gen stringer
 type ObjectFieldKind int
 
 const (
@@ -396,7 +446,6 @@ const (
 	ObjectLocal                            // local id = expr2
 )
 
-// +gen stringer
 type ObjectFieldHide int
 
 const (
@@ -411,21 +460,16 @@ type ObjectField struct {
 	Hide          ObjectFieldHide // (ignore if kind != astObjectField*)
 	SuperSugar    bool            // +:  (ignore if kind != astObjectField*)
 	MethodSugar   bool            // f(x, y, z): ...  (ignore if kind  == astObjectAssert)
-	Expr1         Node            // Not in scope of the object
+	Method        *Function
+	Expr1         Node // Not in scope of the object
 	Id            *Identifier
-	Ids           Identifiers // If methodSugar == true then holds the params.
+	Params        *Parameters // If methodSugar == true then holds the params.
 	TrailingComma bool        // If methodSugar == true then remembers the trailing comma
 	Expr2, Expr3  Node        // In scope of the object (can see self).
 }
 
-// TODO(jbeda): Add the remaining constructor helpers here
-
-func ObjectFieldLocal(methodSugar bool, id *Identifier, ids Identifiers, trailingComma bool, body Node) ObjectField {
-	return ObjectField{ObjectLocal, ObjectFieldVisible, false, methodSugar, nil, id, ids, trailingComma, body, nil}
-}
-
 func ObjectFieldLocalNoMethod(id *Identifier, body Node) ObjectField {
-	return ObjectField{ObjectLocal, ObjectFieldVisible, false, false, nil, id, Identifiers{}, false, body, nil}
+	return ObjectField{ObjectLocal, ObjectFieldVisible, false, false, nil, nil, id, nil, false, body, nil}
 }
 
 type ObjectFields []ObjectField
@@ -443,9 +487,10 @@ type Object struct {
 // ---------------------------------------------------------------------------
 
 type DesugaredObjectField struct {
-	Hide ObjectFieldHide
-	Name Node
-	Body Node
+	Hide      ObjectFieldHide
+	Name      Node
+	Body      Node
+	PlusSuper bool
 }
 type DesugaredObjectFields []DesugaredObjectField
 
@@ -467,19 +512,7 @@ type ObjectComp struct {
 	NodeBase
 	Fields        ObjectFields
 	TrailingComma bool
-	Specs         CompSpecs
-}
-
-// ---------------------------------------------------------------------------
-
-// ObjectComprehensionSimple represents post-desugaring object
-// comprehension { [e]: e for x in e }.
-type ObjectComprehensionSimple struct {
-	NodeBase
-	Field Node
-	Value Node
-	Id    Identifier
-	Array Node
+	Spec          ForSpec
 }
 
 // ---------------------------------------------------------------------------
diff --git a/vendor/github.com/google/go-jsonnet/ast/compkind_stringer.go b/vendor/github.com/google/go-jsonnet/ast/compkind_stringer.go
deleted file mode 100644
index dfd76e0cb889690fd13200fc547e54cae148d112..0000000000000000000000000000000000000000
--- a/vendor/github.com/google/go-jsonnet/ast/compkind_stringer.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Generated by: main
-// TypeWriter: stringer
-// Directive: +gen on astCompKind
-
-package ast
-
-import (
-	"fmt"
-)
-
-const _astCompKind_name = "astCompForastCompIf"
-
-var _astCompKind_index = [...]uint8{0, 10, 19}
-
-func (i CompKind) String() string {
-	if i < 0 || i+1 >= CompKind(len(_astCompKind_index)) {
-		return fmt.Sprintf("astCompKind(%d)", i)
-	}
-	return _astCompKind_name[_astCompKind_index[i]:_astCompKind_index[i+1]]
-}
diff --git a/vendor/github.com/google/go-jsonnet/ast/literalstringkind_stringer.go b/vendor/github.com/google/go-jsonnet/ast/literalstringkind_stringer.go
deleted file mode 100644
index a0d52ba7b7d561d068e2576a2ac34b43b614232b..0000000000000000000000000000000000000000
--- a/vendor/github.com/google/go-jsonnet/ast/literalstringkind_stringer.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Generated by: main
-// TypeWriter: stringer
-// Directive: +gen on astLiteralStringKind
-
-package ast
-
-import (
-	"fmt"
-)
-
-const _astLiteralStringKind_name = "astStringSingleastStringDoubleastStringBlock"
-
-var _astLiteralStringKind_index = [...]uint8{0, 15, 30, 44}
-
-func (i LiteralStringKind) String() string {
-	if i < 0 || i+1 >= LiteralStringKind(len(_astLiteralStringKind_index)) {
-		return fmt.Sprintf("astLiteralStringKind(%d)", i)
-	}
-	return _astLiteralStringKind_name[_astLiteralStringKind_index[i]:_astLiteralStringKind_index[i+1]]
-}
diff --git a/vendor/github.com/google/go-jsonnet/ast/location.go b/vendor/github.com/google/go-jsonnet/ast/location.go
index 9ace48aec00b85125f01e3dd2c0826f69ca792ca..84eff08c1b516d2de74f86958017f756572521b8 100644
--- a/vendor/github.com/google/go-jsonnet/ast/location.go
+++ b/vendor/github.com/google/go-jsonnet/ast/location.go
@@ -16,14 +16,22 @@ limitations under the License.
 
 package ast
 
-import "fmt"
+import (
+	"bytes"
+	"fmt"
+)
+
+type Source struct {
+	lines []string
+}
 
 //////////////////////////////////////////////////////////////////////////////
 // Location
 
 // Location represents a single location in an (unspecified) file.
 type Location struct {
-	Line   int
+	Line int
+	// Column is a byte offset from the beginning of the line
 	Column int
 }
 
@@ -36,6 +44,13 @@ func (l *Location) String() string {
 	return fmt.Sprintf("%v:%v", l.Line, l.Column)
 }
 
+func locationBefore(a Location, b Location) bool {
+	if a.Line != b.Line {
+		return a.Line < b.Line
+	}
+	return a.Column < b.Column
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // LocationRange
 
@@ -43,7 +58,15 @@ func (l *Location) String() string {
 type LocationRange struct {
 	FileName string
 	Begin    Location
-	End      Location
+	End      Location // TODO(sbarzowski) inclusive? exclusive? a gap?
+	file     *Source
+}
+
+func LocationRangeBetween(a, b *LocationRange) LocationRange {
+	if a.file != b.file {
+		panic("Cannot create a LocationRange between different files")
+	}
+	return MakeLocationRange(a.FileName, a.file, a.Begin, b.End)
 }
 
 // IsSet returns if this LocationRange has been set.
@@ -70,11 +93,101 @@ func (lr *LocationRange) String() string {
 	return fmt.Sprintf("%s(%v)-(%v)", filePrefix, lr.Begin.String(), lr.End.String())
 }
 
+func (l *LocationRange) WithCode() bool {
+	return l.Begin.Line != 0
+}
+
 // This is useful for special locations, e.g. manifestation entry point.
 func MakeLocationRangeMessage(msg string) LocationRange {
 	return LocationRange{FileName: msg}
 }
 
-func MakeLocationRange(fn string, begin Location, end Location) LocationRange {
-	return LocationRange{FileName: fn, Begin: begin, End: end}
+func MakeLocationRange(fn string, fc *Source, begin Location, end Location) LocationRange {
+	return LocationRange{FileName: fn, file: fc, Begin: begin, End: end}
+}
+
+type SourceProvider struct {
+}
+
+func (sp *SourceProvider) GetSnippet(loc LocationRange) string {
+	var result bytes.Buffer
+	if loc.Begin.Line == 0 {
+		return ""
+	}
+	for i := loc.Begin.Line; i <= loc.End.Line; i++ {
+		inLineRange := trimToLine(loc, i)
+		for j := inLineRange.Begin.Column; j < inLineRange.End.Column; j++ {
+			result.WriteByte(loc.file.lines[i-1][j-1])
+		}
+		if i != loc.End.Line {
+			result.WriteByte('\n')
+		}
+	}
+	return result.String()
+}
+
+func BuildSource(s string) *Source {
+	var result []string
+	var lineBuf bytes.Buffer
+	for _, runeValue := range s {
+		lineBuf.WriteRune(runeValue)
+		if runeValue == '\n' {
+			result = append(result, lineBuf.String())
+			lineBuf.Reset()
+		}
+	}
+	rest := lineBuf.String()
+	// Stuff after last end-of-line (EOF or some more code)
+	result = append(result, rest+"\n")
+	return &Source{result}
+}
+
+func trimToLine(loc LocationRange, line int) LocationRange {
+	if loc.Begin.Line > line {
+		panic("invalid")
+	}
+	if loc.Begin.Line != line {
+		loc.Begin.Column = 1
+	}
+	loc.Begin.Line = line
+	if loc.End.Line < line {
+		panic("invalid")
+	}
+	if loc.End.Line != line {
+		loc.End.Column = len(loc.file.lines[line-1])
+	}
+	loc.End.Line = line
+	return loc
+}
+
+// lineBeginning returns a part of the line directly before LocationRange
+// for example:
+// local x = foo()
+//           ^^^^^ <- LocationRange loc
+// then
+// local x = foo()
+// ^^^^^^^^^^ <- lineBeginning(loc)
+func LineBeginning(loc *LocationRange) LocationRange {
+	return LocationRange{
+		Begin:    Location{Line: loc.Begin.Line, Column: 1},
+		End:      loc.Begin,
+		FileName: loc.FileName,
+		file:     loc.file,
+	}
+}
+
+// lineEnding returns a part of the line directly after LocationRange
+// for example:
+// local x = foo() + test
+//           ^^^^^ <- LocationRange loc
+// then
+// local x = foo() + test
+//                ^^^^^^^ <- lineEnding(loc)
+func LineEnding(loc *LocationRange) LocationRange {
+	return LocationRange{
+		Begin:    loc.End,
+		End:      Location{Line: loc.End.Line, Column: len(loc.file.lines[loc.End.Line-1])},
+		FileName: loc.FileName,
+		file:     loc.file,
+	}
 }
diff --git a/vendor/github.com/google/go-jsonnet/ast/objectfieldhide_stringer.go b/vendor/github.com/google/go-jsonnet/ast/objectfieldhide_stringer.go
deleted file mode 100644
index 3b43a22c806f33dda130831a846f60c69a6ae782..0000000000000000000000000000000000000000
--- a/vendor/github.com/google/go-jsonnet/ast/objectfieldhide_stringer.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Generated by: main
-// TypeWriter: stringer
-// Directive: +gen on astObjectFieldHide
-
-package ast
-
-import (
-	"fmt"
-)
-
-const _astObjectFieldHide_name = "astObjectFieldHiddenastObjectFieldInheritastObjectFieldVisible"
-
-var _astObjectFieldHide_index = [...]uint8{0, 20, 41, 62}
-
-func (i ObjectFieldHide) String() string {
-	if i < 0 || i+1 >= ObjectFieldHide(len(_astObjectFieldHide_index)) {
-		return fmt.Sprintf("astObjectFieldHide(%d)", i)
-	}
-	return _astObjectFieldHide_name[_astObjectFieldHide_index[i]:_astObjectFieldHide_index[i+1]]
-}
diff --git a/vendor/github.com/google/go-jsonnet/ast/objectfieldkind_stringer.go b/vendor/github.com/google/go-jsonnet/ast/objectfieldkind_stringer.go
deleted file mode 100644
index b98d6eb5dfc7151b0a7c902043c3c020dc80c786..0000000000000000000000000000000000000000
--- a/vendor/github.com/google/go-jsonnet/ast/objectfieldkind_stringer.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Generated by: main
-// TypeWriter: stringer
-// Directive: +gen on astObjectFieldKind
-
-package ast
-
-import (
-	"fmt"
-)
-
-const _astObjectFieldKind_name = "astObjectAssertastObjectFieldIDastObjectFieldExprastObjectFieldStrastObjectLocal"
-
-var _astObjectFieldKind_index = [...]uint8{0, 15, 31, 49, 66, 80}
-
-func (i ObjectFieldKind) String() string {
-	if i < 0 || i+1 >= ObjectFieldKind(len(_astObjectFieldKind_index)) {
-		return fmt.Sprintf("astObjectFieldKind(%d)", i)
-	}
-	return _astObjectFieldKind_name[_astObjectFieldKind_index[i]:_astObjectFieldKind_index[i+1]]
-}
diff --git a/vendor/github.com/google/go-jsonnet/builtins.go b/vendor/github.com/google/go-jsonnet/builtins.go
new file mode 100644
index 0000000000000000000000000000000000000000..33719b6e20c9d94137805a49b3cfecbd02275323
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/builtins.go
@@ -0,0 +1,790 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"sort"
+
+	"github.com/google/go-jsonnet/ast"
+)
+
+// TODO(sbarzowski) Is this the best option? It's the first one that worked for me...
+//go:generate esc -o std.go -pkg=jsonnet std/std.jsonnet
+
+func getStdCode() string {
+	return FSMustString(false, "/std/std.jsonnet")
+}
+
+func builtinPlus(e *evaluator, xp, yp potentialValue) (value, error) {
+	// TODO(sbarzowski) more types, mixing types
+	// TODO(sbarzowski) perhaps a more elegant way to dispatch
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluate(yp)
+	if err != nil {
+		return nil, err
+	}
+	switch right := y.(type) {
+	case *valueString:
+		left, err := builtinToString(e, xp)
+		if err != nil {
+			return nil, err
+		}
+		return concatStrings(left.(*valueString), right), nil
+
+	}
+	switch left := x.(type) {
+	case *valueNumber:
+		right, err := e.getNumber(y)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueNumber(left.value + right.value), nil
+	case *valueString:
+		right, err := builtinToString(e, yp)
+		if err != nil {
+			return nil, err
+		}
+		return concatStrings(left, right.(*valueString)), nil
+	case valueObject:
+		right, err := e.getObject(y)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueExtendedObject(left, right), nil
+	case *valueArray:
+		right, err := e.getArray(y)
+		if err != nil {
+			return nil, err
+		}
+		return concatArrays(left, right), nil
+	default:
+		return nil, e.typeErrorGeneral(x)
+	}
+}
+
+func builtinMinus(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluateNumber(yp)
+	if err != nil {
+		return nil, err
+	}
+	return makeValueNumber(x.value - y.value), nil
+}
+
+func builtinMult(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluateNumber(yp)
+	if err != nil {
+		return nil, err
+	}
+	return makeValueNumber(x.value * y.value), nil
+}
+
+func builtinDiv(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluateNumber(yp)
+	if err != nil {
+		return nil, err
+	}
+	if y.value == 0 {
+		return nil, e.Error("Division by zero.")
+	}
+	return makeDoubleCheck(e, x.value/y.value)
+}
+
+func builtinModulo(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluateNumber(yp)
+	if err != nil {
+		return nil, err
+	}
+	if y.value == 0 {
+		return nil, e.Error("Division by zero.")
+	}
+	return makeDoubleCheck(e, math.Mod(x.value, y.value))
+}
+
+func builtinLess(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	switch left := x.(type) {
+	case *valueNumber:
+		right, err := e.evaluateNumber(yp)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueBoolean(left.value < right.value), nil
+	case *valueString:
+		right, err := e.evaluateString(yp)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueBoolean(stringLessThan(left, right)), nil
+	default:
+		return nil, e.typeErrorGeneral(x)
+	}
+}
+
+func builtinGreater(e *evaluator, xp, yp potentialValue) (value, error) {
+	return builtinLess(e, yp, xp)
+}
+
+func builtinGreaterEq(e *evaluator, xp, yp potentialValue) (value, error) {
+	res, err := builtinLess(e, xp, yp)
+	if err != nil {
+		return nil, err
+	}
+	return res.(*valueBoolean).not(), nil
+}
+
+func builtinLessEq(e *evaluator, xp, yp potentialValue) (value, error) {
+	res, err := builtinGreater(e, xp, yp)
+	if err != nil {
+		return nil, err
+	}
+	return res.(*valueBoolean).not(), nil
+}
+
+func builtinAnd(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateBoolean(xp)
+	if err != nil {
+		return nil, err
+	}
+	if !x.value {
+		return x, nil
+	}
+	y, err := e.evaluateBoolean(yp)
+	if err != nil {
+		return nil, err
+	}
+	return y, nil
+}
+
+func builtinOr(e *evaluator, xp, yp potentialValue) (value, error) {
+	x, err := e.evaluateBoolean(xp)
+	if err != nil {
+		return nil, err
+	}
+	if x.value {
+		return x, nil
+	}
+	y, err := e.evaluateBoolean(yp)
+	if err != nil {
+		return nil, err
+	}
+	return y, nil
+}
+
+func builtinLength(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	var num int
+	switch x := x.(type) {
+	case valueObject:
+		num = len(objectFields(x, withoutHidden))
+	case *valueArray:
+		num = len(x.elements)
+	case *valueString:
+		num = x.length()
+	case *valueFunction:
+		num = len(x.parameters().required)
+	default:
+		return nil, e.typeErrorGeneral(x)
+	}
+	return makeValueNumber(float64(num)), nil
+}
+
+func builtinToString(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	switch x := x.(type) {
+	case *valueString:
+		return x, nil
+	}
+	s, err := e.i.manifestAndSerializeJSON(e.trace, x, false, "")
+	if err != nil {
+		return nil, err
+	}
+	return makeValueString(s), nil
+}
+
+func builtinMakeArray(e *evaluator, szp potentialValue, funcp potentialValue) (value, error) {
+	sz, err := e.evaluateInt(szp)
+	if err != nil {
+		return nil, err
+	}
+	fun, err := e.evaluateFunction(funcp)
+	if err != nil {
+		return nil, err
+	}
+	var elems []potentialValue
+	for i := 0; i < sz; i++ {
+		elem := fun.call(args(&readyValue{intToValue(i)}))
+		elems = append(elems, elem)
+	}
+	return makeValueArray(elems), nil
+}
+
+func builtinFlatMap(e *evaluator, funcp potentialValue, arrp potentialValue) (value, error) {
+	arr, err := e.evaluateArray(arrp)
+	if err != nil {
+		return nil, err
+	}
+	fun, err := e.evaluateFunction(funcp)
+	if err != nil {
+		return nil, err
+	}
+	num := arr.length()
+	// Start with capacity of the original array.
+	// This may spare us a few reallocations.
+	// TODO(sbarzowski) verify that it actually helps
+	elems := make([]potentialValue, 0, num)
+	for i := 0; i < num; i++ {
+		returned, err := e.evaluateArray(fun.call(args(arr.elements[i])))
+		if err != nil {
+			return nil, err
+		}
+		for _, elem := range returned.elements {
+			elems = append(elems, elem)
+		}
+	}
+	return makeValueArray(elems), nil
+}
+
+func builtinFilter(e *evaluator, funcp potentialValue, arrp potentialValue) (value, error) {
+	arr, err := e.evaluateArray(arrp)
+	if err != nil {
+		return nil, err
+	}
+	fun, err := e.evaluateFunction(funcp)
+	if err != nil {
+		return nil, err
+	}
+	num := arr.length()
+	// Start with capacity of the original array.
+	// This may spare us a few reallocations.
+	// TODO(sbarzowski) verify that it actually helps
+	elems := make([]potentialValue, 0, num)
+	for i := 0; i < num; i++ {
+		included, err := e.evaluateBoolean(fun.call(args(arr.elements[i])))
+		if err != nil {
+			return nil, err
+		}
+		if included.value {
+			elems = append(elems, arr.elements[i])
+		}
+	}
+	return makeValueArray(elems), nil
+}
+
+func builtinNegation(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateBoolean(xp)
+	if err != nil {
+		return nil, err
+	}
+	return makeValueBoolean(!x.value), nil
+}
+
+func builtinBitNeg(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	i := int64(x.value)
+	return int64ToValue(^i), nil
+}
+
+func builtinIdentity(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+func builtinUnaryMinus(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	return makeValueNumber(-x.value), nil
+}
+
+func primitiveEquals(e *evaluator, xp potentialValue, yp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	y, err := e.evaluate(yp)
+	if err != nil {
+		return nil, err
+	}
+	if x.getType() != y.getType() {
+		return makeValueBoolean(false), nil
+	}
+	switch left := x.(type) {
+	case *valueBoolean:
+		right, err := e.getBoolean(y)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueBoolean(left.value == right.value), nil
+	case *valueNumber:
+		right, err := e.getNumber(y)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueBoolean(left.value == right.value), nil
+	case *valueString:
+		right, err := e.getString(y)
+		if err != nil {
+			return nil, err
+		}
+		return makeValueBoolean(stringEqual(left, right)), nil
+	case *valueNull:
+		return makeValueBoolean(true), nil
+	case *valueFunction:
+		return nil, e.Error("Cannot test equality of functions")
+	default:
+		return nil, e.Error(
+			"primitiveEquals operates on primitive types, got " + x.getType().name,
+		)
+	}
+}
+
+func builtinType(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluate(xp)
+	if err != nil {
+		return nil, err
+	}
+	return makeValueString(x.getType().name), nil
+}
+
+func builtinMd5(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateString(xp)
+	if err != nil {
+		return nil, err
+	}
+	hash := md5.Sum([]byte(string(x.value)))
+	return makeValueString(hex.EncodeToString(hash[:])), nil
+}
+
+// Maximum allowed unicode codepoint
+// https://en.wikipedia.org/wiki/Unicode#Architecture_and_terminology
+const codepointMax = 0x10FFFF
+
+func builtinChar(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateNumber(xp)
+	if err != nil {
+		return nil, err
+	}
+	if x.value > codepointMax {
+		return nil, e.Error(fmt.Sprintf("Invalid unicode codepoint, got %v", x.value))
+	} else if x.value < 0 {
+		return nil, e.Error(fmt.Sprintf("Codepoints must be >= 0, got %v", x.value))
+	}
+	return makeValueString(string(rune(x.value))), nil
+}
+
+func builtinCodepoint(e *evaluator, xp potentialValue) (value, error) {
+	x, err := e.evaluateString(xp)
+	if err != nil {
+		return nil, err
+	}
+	if x.length() != 1 {
+		return nil, e.Error(fmt.Sprintf("codepoint takes a string of length 1, got length %v", x.length()))
+	}
+	return makeValueNumber(float64(x.value[0])), nil
+}
+
+func makeDoubleCheck(e *evaluator, x float64) (value, error) {
+	if math.IsNaN(x) {
+		return nil, e.Error("Not a number")
+	}
+	if math.IsInf(x, 0) {
+		return nil, e.Error("Overflow")
+	}
+	return makeValueNumber(x), nil
+}
+
+func liftNumeric(f func(float64) float64) func(*evaluator, potentialValue) (value, error) {
+	return func(e *evaluator, xp potentialValue) (value, error) {
+		x, err := e.evaluateNumber(xp)
+		if err != nil {
+			return nil, err
+		}
+		return makeDoubleCheck(e, f(x.value))
+	}
+}
+
+var builtinSqrt = liftNumeric(math.Sqrt)
+var builtinCeil = liftNumeric(math.Ceil)
+var builtinFloor = liftNumeric(math.Floor)
+var builtinSin = liftNumeric(math.Sin)
+var builtinCos = liftNumeric(math.Cos)
+var builtinTan = liftNumeric(math.Tan)
+var builtinAsin = liftNumeric(math.Asin)
+var builtinAcos = liftNumeric(math.Acos)
+var builtinAtan = liftNumeric(math.Atan)
+var builtinLog = liftNumeric(math.Log)
+var builtinExp = liftNumeric(math.Exp)
+var builtinMantissa = liftNumeric(func(f float64) float64 {
+	mantissa, _ := math.Frexp(f)
+	return mantissa
+})
+var builtinExponent = liftNumeric(func(f float64) float64 {
+	_, exponent := math.Frexp(f)
+	return float64(exponent)
+})
+
+func liftBitwise(f func(int64, int64) int64) func(*evaluator, potentialValue, potentialValue) (value, error) {
+	return func(e *evaluator, xp, yp potentialValue) (value, error) {
+		x, err := e.evaluateInt64(xp)
+		if err != nil {
+			return nil, err
+		}
+		y, err := e.evaluateInt64(yp)
+		if err != nil {
+			return nil, err
+		}
+		return makeDoubleCheck(e, float64(f(x, y)))
+	}
+}
+
+// TODO(sbarzowski) negative shifts
+var builtinShiftL = liftBitwise(func(x, y int64) int64 { return x << uint(y) })
+var builtinShiftR = liftBitwise(func(x, y int64) int64 { return x >> uint(y) })
+var builtinBitwiseAnd = liftBitwise(func(x, y int64) int64 { return x & y })
+var builtinBitwiseOr = liftBitwise(func(x, y int64) int64 { return x | y })
+var builtinBitwiseXor = liftBitwise(func(x, y int64) int64 { return x ^ y })
+
+func builtinObjectFieldsEx(e *evaluator, objp potentialValue, includeHiddenP potentialValue) (value, error) {
+	obj, err := e.evaluateObject(objp)
+	if err != nil {
+		return nil, err
+	}
+	includeHidden, err := e.evaluateBoolean(includeHiddenP)
+	if err != nil {
+		return nil, err
+	}
+	fields := objectFields(obj, withHiddenFromBool(includeHidden.value))
+	sort.Strings(fields)
+	elems := []potentialValue{}
+	for _, fieldname := range fields {
+		elems = append(elems, &readyValue{makeValueString(fieldname)})
+	}
+	return makeValueArray(elems), nil
+}
+
+func builtinObjectHasEx(e *evaluator, objp potentialValue, fnamep potentialValue, includeHiddenP potentialValue) (value, error) {
+	obj, err := e.evaluateObject(objp)
+	if err != nil {
+		return nil, err
+	}
+	fname, err := e.evaluateString(fnamep)
+	if err != nil {
+		return nil, err
+	}
+	includeHidden, err := e.evaluateBoolean(includeHiddenP)
+	if err != nil {
+		return nil, err
+	}
+	h := withHiddenFromBool(includeHidden.value)
+	fieldp := tryObjectIndex(objectBinding(obj), string(fname.value), h)
+	return makeValueBoolean(fieldp != nil), nil
+}
+
+func builtinPow(e *evaluator, basep potentialValue, expp potentialValue) (value, error) {
+	base, err := e.evaluateNumber(basep)
+	if err != nil {
+		return nil, err
+	}
+	exp, err := e.evaluateNumber(expp)
+	if err != nil {
+		return nil, err
+	}
+	return makeDoubleCheck(e, math.Pow(base.value, exp.value))
+}
+
+func builtinUglyObjectFlatMerge(e *evaluator, objarrp potentialValue) (value, error) {
+	objarr, err := e.evaluateArray(objarrp)
+	if err != nil {
+		return nil, err
+	}
+	if len(objarr.elements) == 0 {
+		return &valueSimpleObject{}, nil
+	}
+	newFields := make(simpleObjectFieldMap)
+	for _, elem := range objarr.elements {
+		obj, err := e.evaluateObject(elem)
+		if err != nil {
+			return nil, err
+		}
+		// starts getting ugly - we mess with object internals
+		simpleObj := obj.(*valueSimpleObject)
+		for fieldName, fieldVal := range simpleObj.fields {
+			if _, alreadyExists := newFields[fieldName]; alreadyExists {
+				return nil, e.Error(duplicateFieldNameErrMsg(fieldName))
+			}
+			newFields[fieldName] = simpleObjectField{
+				hide: fieldVal.hide,
+				field: &bindingsUnboundField{
+					inner:    fieldVal.field,
+					bindings: simpleObj.upValues,
+				},
+			}
+		}
+	}
+	return makeValueSimpleObject(
+		nil, // no binding frame
+		newFields,
+		[]unboundField{}, // No asserts allowed
+	), nil
+}
+
+func builtinExtVar(e *evaluator, namep potentialValue) (value, error) {
+	name, err := e.evaluateString(namep)
+	if err != nil {
+		return nil, err
+	}
+	index := name.getString()
+	if pv, ok := e.i.extVars[index]; ok {
+		return e.evaluate(pv)
+	}
+	return nil, e.Error("Undefined external variable: " + string(index))
+}
+
+func builtinNative(e *evaluator, namep potentialValue) (value, error) {
+	name, err := e.evaluateString(namep)
+	if err != nil {
+		return nil, err
+	}
+	index := name.getString()
+	if f, exists := e.i.nativeFuncs[index]; exists {
+		return &valueFunction{ec: f}, nil
+
+	}
+	return nil, e.Error(fmt.Sprintf("Unrecognized native function name: %v", index))
+
+}
+
+type unaryBuiltin func(*evaluator, potentialValue) (value, error)
+type binaryBuiltin func(*evaluator, potentialValue, potentialValue) (value, error)
+type ternaryBuiltin func(*evaluator, potentialValue, potentialValue, potentialValue) (value, error)
+
+type UnaryBuiltin struct {
+	name       ast.Identifier
+	function   unaryBuiltin
+	parameters ast.Identifiers
+}
+
+func getBuiltinEvaluator(e *evaluator, name ast.Identifier) *evaluator {
+	loc := ast.MakeLocationRangeMessage("<builtin>")
+	context := "builtin function <" + string(name) + ">"
+	trace := TraceElement{loc: &loc, context: &context}
+	return &evaluator{i: e.i, trace: &trace}
+}
+
+func (b *UnaryBuiltin) EvalCall(args callArguments, e *evaluator) (value, error) {
+	flatArgs := flattenArgs(args, b.Parameters())
+	return b.function(getBuiltinEvaluator(e, b.name), flatArgs[0])
+}
+
+func (b *UnaryBuiltin) Parameters() Parameters {
+	return Parameters{required: b.parameters}
+}
+
+func (b *UnaryBuiltin) Name() ast.Identifier {
+	return b.name
+}
+
+type BinaryBuiltin struct {
+	name       ast.Identifier
+	function   binaryBuiltin
+	parameters ast.Identifiers
+}
+
+// flattenArgs transforms all arguments to a simple array of positional arguments.
+// It's needed, because it's possible to use named arguments for required parameters.
+// For example both `toString("x")` and `toString(a="x")` are allowed.
+// It assumes that we have already checked for duplicates.
+func flattenArgs(args callArguments, params Parameters) []potentialValue {
+	if len(args.named) == 0 {
+		return args.positional
+	}
+	if len(params.optional) != 0 {
+		panic("Can't normalize arguments if optional parameters are present")
+	}
+	needed := make(map[ast.Identifier]int)
+
+	for i := len(args.positional); i < len(params.required); i++ {
+		needed[params.required[i]] = i
+	}
+
+	flatArgs := make([]potentialValue, len(params.required))
+	copy(flatArgs, args.positional)
+	for _, arg := range args.named {
+		flatArgs[needed[arg.name]] = arg.pv
+	}
+	return flatArgs
+}
+
+func (b *BinaryBuiltin) EvalCall(args callArguments, e *evaluator) (value, error) {
+	flatArgs := flattenArgs(args, b.Parameters())
+	return b.function(getBuiltinEvaluator(e, b.name), flatArgs[0], flatArgs[1])
+}
+
+func (b *BinaryBuiltin) Parameters() Parameters {
+	return Parameters{required: b.parameters}
+}
+
+func (b *BinaryBuiltin) Name() ast.Identifier {
+	return b.name
+}
+
+type TernaryBuiltin struct {
+	name       ast.Identifier
+	function   ternaryBuiltin
+	parameters ast.Identifiers
+}
+
+func (b *TernaryBuiltin) EvalCall(args callArguments, e *evaluator) (value, error) {
+	flatArgs := flattenArgs(args, b.Parameters())
+	return b.function(getBuiltinEvaluator(e, b.name), flatArgs[0], flatArgs[1], flatArgs[2])
+}
+
+func (b *TernaryBuiltin) Parameters() Parameters {
+	return Parameters{required: b.parameters}
+}
+
+func (b *TernaryBuiltin) Name() ast.Identifier {
+	return b.name
+}
+
+var desugaredBop = map[ast.BinaryOp]ast.Identifier{
+	ast.BopPercent:         "mod",
+	ast.BopManifestEqual:   "equals",
+	ast.BopManifestUnequal: "notEquals", // Special case
+	ast.BopIn:              "objectHasAll",
+}
+
+var bopBuiltins = []*BinaryBuiltin{
+	ast.BopMult: &BinaryBuiltin{name: "operator*", function: builtinMult, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopDiv:  &BinaryBuiltin{name: "operator/", function: builtinDiv, parameters: ast.Identifiers{"x", "y"}},
+	// ast.BopPercent:  <desugared>,
+
+	ast.BopPlus:  &BinaryBuiltin{name: "operator+", function: builtinPlus, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopMinus: &BinaryBuiltin{name: "operator-", function: builtinMinus, parameters: ast.Identifiers{"x", "y"}},
+
+	ast.BopShiftL: &BinaryBuiltin{name: "operator<<", function: builtinShiftL, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopShiftR: &BinaryBuiltin{name: "operator>>", function: builtinShiftR, parameters: ast.Identifiers{"x", "y"}},
+
+	ast.BopGreater:   &BinaryBuiltin{name: "operator>", function: builtinGreater, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopGreaterEq: &BinaryBuiltin{name: "operator>=", function: builtinGreaterEq, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopLess:      &BinaryBuiltin{name: "operator<,", function: builtinLess, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopLessEq:    &BinaryBuiltin{name: "operator<=", function: builtinLessEq, parameters: ast.Identifiers{"x", "y"}},
+
+	// bopManifestEqual:   <desugared>,
+	// bopManifestUnequal: <desugared>,
+
+	ast.BopBitwiseAnd: &BinaryBuiltin{name: "operator&", function: builtinBitwiseAnd, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopBitwiseXor: &BinaryBuiltin{name: "operator^", function: builtinBitwiseXor, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopBitwiseOr:  &BinaryBuiltin{name: "operator|", function: builtinBitwiseOr, parameters: ast.Identifiers{"x", "y"}},
+
+	ast.BopAnd: &BinaryBuiltin{name: "operator&&", function: builtinAnd, parameters: ast.Identifiers{"x", "y"}},
+	ast.BopOr:  &BinaryBuiltin{name: "operator||", function: builtinOr, parameters: ast.Identifiers{"x", "y"}},
+}
+
+var uopBuiltins = []*UnaryBuiltin{
+	ast.UopNot:        &UnaryBuiltin{name: "operator!", function: builtinNegation, parameters: ast.Identifiers{"x"}},
+	ast.UopBitwiseNot: &UnaryBuiltin{name: "operator~", function: builtinBitNeg, parameters: ast.Identifiers{"x"}},
+	ast.UopPlus:       &UnaryBuiltin{name: "operator+ (unary)", function: builtinIdentity, parameters: ast.Identifiers{"x"}},
+	ast.UopMinus:      &UnaryBuiltin{name: "operator- (unary)", function: builtinUnaryMinus, parameters: ast.Identifiers{"x"}},
+}
+
+type builtin interface {
+	evalCallable
+	Name() ast.Identifier
+}
+
+func buildBuiltinMap(builtins []builtin) map[string]evalCallable {
+	result := make(map[string]evalCallable)
+	for _, b := range builtins {
+		result[string(b.Name())] = b
+	}
+	return result
+}
+
+var funcBuiltins = buildBuiltinMap([]builtin{
+	&UnaryBuiltin{name: "extVar", function: builtinExtVar, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "length", function: builtinLength, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "toString", function: builtinToString, parameters: ast.Identifiers{"a"}},
+	&BinaryBuiltin{name: "makeArray", function: builtinMakeArray, parameters: ast.Identifiers{"sz", "func"}},
+	&BinaryBuiltin{name: "flatMap", function: builtinFlatMap, parameters: ast.Identifiers{"func", "arr"}},
+	&BinaryBuiltin{name: "filter", function: builtinFilter, parameters: ast.Identifiers{"func", "arr"}},
+	&BinaryBuiltin{name: "primitiveEquals", function: primitiveEquals, parameters: ast.Identifiers{"sz", "func"}},
+	&BinaryBuiltin{name: "objectFieldsEx", function: builtinObjectFieldsEx, parameters: ast.Identifiers{"obj", "hidden"}},
+	&TernaryBuiltin{name: "objectHasEx", function: builtinObjectHasEx, parameters: ast.Identifiers{"obj", "fname", "hidden"}},
+	&UnaryBuiltin{name: "type", function: builtinType, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "char", function: builtinChar, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "codepoint", function: builtinCodepoint, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "ceil", function: builtinCeil, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "floor", function: builtinFloor, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "sqrt", function: builtinSqrt, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "sin", function: builtinSin, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "cos", function: builtinCos, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "tan", function: builtinTan, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "asin", function: builtinAsin, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "acos", function: builtinAcos, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "atan", function: builtinAtan, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "log", function: builtinLog, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "exp", function: builtinExp, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "mantissa", function: builtinMantissa, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "exponent", function: builtinExponent, parameters: ast.Identifiers{"x"}},
+	&BinaryBuiltin{name: "pow", function: builtinPow, parameters: ast.Identifiers{"base", "exp"}},
+	&BinaryBuiltin{name: "modulo", function: builtinModulo, parameters: ast.Identifiers{"x", "y"}},
+	&UnaryBuiltin{name: "md5", function: builtinMd5, parameters: ast.Identifiers{"x"}},
+	&UnaryBuiltin{name: "native", function: builtinNative, parameters: ast.Identifiers{"x"}},
+
+	// internal
+	&UnaryBuiltin{name: "$objectFlatMerge", function: builtinUglyObjectFlatMerge, parameters: ast.Identifiers{"x"}},
+})
diff --git a/vendor/github.com/google/go-jsonnet/desugarer.go b/vendor/github.com/google/go-jsonnet/desugarer.go
new file mode 100644
index 0000000000000000000000000000000000000000..d5b1630be17c0aad4652359874324476c4bc9fc2
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/desugarer.go
@@ -0,0 +1,599 @@
+/*
+Copyright 2016 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"unicode/utf8"
+
+	"github.com/google/go-jsonnet/ast"
+	"github.com/google/go-jsonnet/parser"
+)
+
+func makeStr(s string) *ast.LiteralString {
+	return &ast.LiteralString{ast.NodeBase{}, s, ast.StringDouble, ""}
+}
+
+func stringUnescape(loc *ast.LocationRange, s string) (string, error) {
+	var buf bytes.Buffer
+	// read one rune at a time
+	for i := 0; i < len(s); {
+		r, w := utf8.DecodeRuneInString(s[i:])
+		i += w
+		switch r {
+		case '\\':
+			if i >= len(s) {
+				return "", parser.MakeStaticError("Truncated escape sequence in string literal.", *loc)
+			}
+			r2, w := utf8.DecodeRuneInString(s[i:])
+			i += w
+			switch r2 {
+			case '"':
+				buf.WriteRune('"')
+			case '\'':
+				buf.WriteRune('\'')
+			case '\\':
+				buf.WriteRune('\\')
+			case '/':
+				buf.WriteRune('/') // This one is odd, maybe a mistake.
+			case 'b':
+				buf.WriteRune('\b')
+			case 'f':
+				buf.WriteRune('\f')
+			case 'n':
+				buf.WriteRune('\n')
+			case 'r':
+				buf.WriteRune('\r')
+			case 't':
+				buf.WriteRune('\t')
+			case 'u':
+				if i+4 > len(s) {
+					return "", parser.MakeStaticError("Truncated unicode escape sequence in string literal.", *loc)
+				}
+				codeBytes, err := hex.DecodeString(s[i : i+4])
+				if err != nil {
+					return "", parser.MakeStaticError(fmt.Sprintf("Unicode escape sequence was malformed: %s", s[0:4]), *loc)
+				}
+				code := int(codeBytes[0])*256 + int(codeBytes[1])
+				buf.WriteRune(rune(code))
+				i += 4
+			default:
+				return "", parser.MakeStaticError(fmt.Sprintf("Unknown escape sequence in string literal: \\%c", r2), *loc)
+			}
+
+		default:
+			buf.WriteRune(r)
+		}
+	}
+	return buf.String(), nil
+}
+
+func desugarFields(location ast.LocationRange, fields *ast.ObjectFields, objLevel int) error {
+	// Simplify asserts
+	for i := range *fields {
+		field := &(*fields)[i]
+		if field.Kind != ast.ObjectAssert {
+			continue
+		}
+		msg := field.Expr3
+		if msg == nil {
+			msg = buildLiteralString("Object assertion failed.")
+		}
+		field.Expr3 = nil
+		onFailure := &ast.Error{Expr: msg}
+		assertion := &ast.Conditional{
+			Cond:        field.Expr2,
+			BranchTrue:  &ast.LiteralBoolean{Value: true}, // ignored anyway
+			BranchFalse: onFailure,
+		}
+		field.Expr2 = assertion
+	}
+
+	for i := range *fields {
+		field := &((*fields)[i])
+		if field.Method == nil {
+			continue
+		}
+		field.Expr2 = field.Method
+		field.Method = nil
+		// Body of the function already desugared through expr2
+	}
+
+	// Remove object-level locals
+	newFields := []ast.ObjectField{}
+	var binds ast.LocalBinds
+	for _, local := range *fields {
+		if local.Kind != ast.ObjectLocal {
+			continue
+		}
+		binds = append(binds, ast.LocalBind{Variable: *local.Id, Body: local.Expr2})
+	}
+	for _, field := range *fields {
+		if field.Kind == ast.ObjectLocal {
+			continue
+		}
+		if len(binds) > 0 {
+			field.Expr2 = &ast.Local{ast.NewNodeBaseLoc(*field.Expr2.Loc()), binds, field.Expr2}
+		}
+		newFields = append(newFields, field)
+	}
+	*fields = newFields
+
+	// Change all to FIELD_EXPR
+	for i := range *fields {
+		field := &(*fields)[i]
+		switch field.Kind {
+		case ast.ObjectAssert:
+		// Nothing to do.
+
+		case ast.ObjectFieldID:
+			field.Expr1 = makeStr(string(*field.Id))
+			field.Kind = ast.ObjectFieldExpr
+
+		case ast.ObjectFieldExpr:
+		// Nothing to do.
+
+		case ast.ObjectFieldStr:
+			// Just set the flag.
+			field.Kind = ast.ObjectFieldExpr
+
+		case ast.ObjectLocal:
+			return fmt.Errorf("INTERNAL ERROR: Locals should be removed by now")
+		}
+	}
+
+	return nil
+}
+
+func simpleLambda(body ast.Node, paramName ast.Identifier) ast.Node {
+	return &ast.Function{
+		Body:       body,
+		Parameters: ast.Parameters{Required: ast.Identifiers{paramName}},
+	}
+}
+
+func buildAnd(left ast.Node, right ast.Node) ast.Node {
+	return &ast.Binary{Op: ast.BopAnd, Left: left, Right: right}
+}
+
+func desugarForSpec(inside ast.Node, forSpec *ast.ForSpec) (ast.Node, error) {
+	var body ast.Node
+	if len(forSpec.Conditions) > 0 {
+		cond := forSpec.Conditions[0].Expr
+		for i := 1; i < len(forSpec.Conditions); i++ {
+			cond = buildAnd(cond, forSpec.Conditions[i].Expr)
+		}
+		body = &ast.Conditional{
+			Cond:        cond,
+			BranchTrue:  inside,
+			BranchFalse: &ast.Array{},
+		}
+	} else {
+		body = inside
+	}
+	function := simpleLambda(body, forSpec.VarName)
+	current := buildStdCall("flatMap", function, forSpec.Expr)
+	if forSpec.Outer == nil {
+		return current, nil
+	}
+	return desugarForSpec(current, forSpec.Outer)
+}
+
+func wrapInArray(inside ast.Node) ast.Node {
+	return &ast.Array{Elements: ast.Nodes{inside}}
+}
+
+func desugarArrayComp(comp *ast.ArrayComp, objLevel int) (ast.Node, error) {
+	return desugarForSpec(wrapInArray(comp.Body), &comp.Spec)
+}
+
+func desugarObjectComp(comp *ast.ObjectComp, objLevel int) (ast.Node, error) {
+
+	if objLevel == 0 {
+		dollar := ast.Identifier("$")
+		comp.Fields = append(comp.Fields, ast.ObjectFieldLocalNoMethod(&dollar, &ast.Self{}))
+	}
+
+	err := desugarFields(*comp.Loc(), &comp.Fields, objLevel+1)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(comp.Fields) != 1 {
+		panic("Too many fields in object comprehension, it should have been caught during parsing")
+	}
+
+	arrComp := ast.ArrayComp{
+		Body: buildDesugaredObject(comp.NodeBase, comp.Fields),
+		Spec: comp.Spec,
+	}
+
+	desugaredArrayComp, err := desugarArrayComp(&arrComp, objLevel)
+	if err != nil {
+		return nil, err
+	}
+
+	desugaredComp := buildStdCall("$objectFlatMerge", desugaredArrayComp)
+	return desugaredComp, nil
+}
+
+func buildLiteralString(value string) ast.Node {
+	return &ast.LiteralString{
+		Kind:  ast.StringDouble,
+		Value: value,
+	}
+}
+
+func buildSimpleIndex(obj ast.Node, member ast.Identifier) ast.Node {
+	return &ast.Index{
+		Target: obj,
+		Id:     &member,
+	}
+}
+
+func buildStdCall(builtinName ast.Identifier, args ...ast.Node) ast.Node {
+	std := &ast.Var{Id: "std"}
+	builtin := buildSimpleIndex(std, builtinName)
+	return &ast.Apply{
+		Target:    builtin,
+		Arguments: ast.Arguments{Positional: args},
+	}
+}
+
+func buildDesugaredObject(nodeBase ast.NodeBase, fields ast.ObjectFields) *ast.DesugaredObject {
+	var newFields ast.DesugaredObjectFields
+	var newAsserts ast.Nodes
+
+	for _, field := range fields {
+		if field.Kind == ast.ObjectAssert {
+			newAsserts = append(newAsserts, field.Expr2)
+		} else if field.Kind == ast.ObjectFieldExpr {
+			newFields = append(newFields, ast.DesugaredObjectField{field.Hide, field.Expr1, field.Expr2, field.SuperSugar})
+		} else {
+			panic(fmt.Sprintf("INTERNAL ERROR: field should have been desugared: %s", field.Kind))
+		}
+	}
+
+	return &ast.DesugaredObject{nodeBase, newAsserts, newFields}
+}
+
+// Desugar Jsonnet expressions to reduce the number of constructs the rest of the implementation
+// needs to understand.
+
+// Desugaring should happen immediately after parsing, i.e. before static analysis and execution.
+// Temporary variables introduced here should be prefixed with $ to ensure they do not clash with
+// variables used in user code.
+// TODO(sbarzowski) Actually we may want to do some static analysis before desugaring, e.g.
+// warning user about dangerous use of constructs that we desugar.
+func desugar(astPtr *ast.Node, objLevel int) (err error) {
+	node := *astPtr
+
+	if node == nil {
+		return
+	}
+
+	switch node := node.(type) {
+	case *ast.Apply:
+		desugar(&node.Target, objLevel)
+		for i := range node.Arguments.Positional {
+			err = desugar(&node.Arguments.Positional[i], objLevel)
+			if err != nil {
+				return
+			}
+		}
+		for i := range node.Arguments.Named {
+			err = desugar(&node.Arguments.Named[i].Arg, objLevel)
+			if err != nil {
+				return
+			}
+		}
+
+	case *ast.ApplyBrace:
+		err = desugar(&node.Left, objLevel)
+		if err != nil {
+			return
+		}
+		err = desugar(&node.Right, objLevel)
+		if err != nil {
+			return
+		}
+		*astPtr = &ast.Binary{
+			NodeBase: node.NodeBase,
+			Left:     node.Left,
+			Op:       ast.BopPlus,
+			Right:    node.Right,
+		}
+
+	case *ast.Array:
+		for i := range node.Elements {
+			err = desugar(&node.Elements[i], objLevel)
+			if err != nil {
+				return
+			}
+		}
+
+	case *ast.ArrayComp:
+		comp, err := desugarArrayComp(node, objLevel)
+		if err != nil {
+			return err
+		}
+		*astPtr = comp
+		err = desugar(astPtr, objLevel)
+		if err != nil {
+			return err
+		}
+
+	case *ast.Assert:
+		if node.Message == nil {
+			node.Message = buildLiteralString("Assertion failed")
+		}
+		*astPtr = &ast.Conditional{
+			Cond:        node.Cond,
+			BranchTrue:  node.Rest,
+			BranchFalse: &ast.Error{Expr: node.Message},
+		}
+		err = desugar(astPtr, objLevel)
+		if err != nil {
+			return err
+		}
+
+	case *ast.Binary:
+		// some operators get replaced by stdlib functions
+		if funcname, replaced := desugaredBop[node.Op]; replaced {
+			if funcname == "notEquals" {
+				// TODO(sbarzowski) maybe we can handle it in more regular way
+				// but let's be consistent with the spec
+				*astPtr = &ast.Unary{
+					Op:   ast.UopNot,
+					Expr: buildStdCall(desugaredBop[ast.BopManifestEqual], node.Left, node.Right),
+				}
+			} else if node.Op == ast.BopIn {
+				// reversed order of arguments
+				*astPtr = buildStdCall(funcname, node.Right, node.Left)
+			} else {
+				*astPtr = buildStdCall(funcname, node.Left, node.Right)
+			}
+			return desugar(astPtr, objLevel)
+		}
+
+		err = desugar(&node.Left, objLevel)
+		if err != nil {
+			return
+		}
+		err = desugar(&node.Right, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Conditional:
+		err = desugar(&node.Cond, objLevel)
+		if err != nil {
+			return
+		}
+		err = desugar(&node.BranchTrue, objLevel)
+		if err != nil {
+			return
+		}
+		if node.BranchFalse == nil {
+			node.BranchFalse = &ast.LiteralNull{}
+		}
+		err = desugar(&node.BranchFalse, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Dollar:
+		if objLevel == 0 {
+			return parser.MakeStaticError("No top-level object found.", *node.Loc())
+		}
+		*astPtr = &ast.Var{NodeBase: node.NodeBase, Id: ast.Identifier("$")}
+
+	case *ast.Error:
+		err = desugar(&node.Expr, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Function:
+		for i := range node.Parameters.Optional {
+			param := &node.Parameters.Optional[i]
+			err = desugar(&param.DefaultArg, objLevel)
+			if err != nil {
+				return
+			}
+		}
+		err = desugar(&node.Body, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Import:
+		var file ast.Node = node.File
+		err = desugar(&file, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.ImportStr:
+		var file ast.Node = node.File
+		err = desugar(&file, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Index:
+		err = desugar(&node.Target, objLevel)
+		if err != nil {
+			return
+		}
+		if node.Id != nil {
+			if node.Index != nil {
+				panic(fmt.Sprintf("Node with both Id and Index: %#+v", node))
+			}
+			node.Index = makeStr(string(*node.Id))
+			node.Id = nil
+		}
+		err = desugar(&node.Index, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Slice:
+		if node.BeginIndex == nil {
+			node.BeginIndex = &ast.LiteralNull{}
+		}
+		if node.EndIndex == nil {
+			node.EndIndex = &ast.LiteralNull{}
+		}
+		if node.Step == nil {
+			node.Step = &ast.LiteralNull{}
+		}
+		*astPtr = buildStdCall("slice", node.Target, node.BeginIndex, node.EndIndex, node.Step)
+		err = desugar(astPtr, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Local:
+		for i := range node.Binds {
+			if node.Binds[i].Fun != nil {
+				node.Binds[i] = ast.LocalBind{
+					Variable: node.Binds[i].Variable,
+					Body:     node.Binds[i].Fun,
+					Fun:      nil,
+				}
+			}
+			err = desugar(&node.Binds[i].Body, objLevel)
+			if err != nil {
+				return
+			}
+		}
+		err = desugar(&node.Body, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.LiteralBoolean:
+		// Nothing to do.
+
+	case *ast.LiteralNull:
+		// Nothing to do.
+
+	case *ast.LiteralNumber:
+		// Nothing to do.
+
+	case *ast.LiteralString:
+		if node.Kind.FullyEscaped() {
+			unescaped, err := stringUnescape(node.Loc(), node.Value)
+			if err != nil {
+				return err
+			}
+			node.Value = unescaped
+		}
+		node.Kind = ast.StringDouble
+		node.BlockIndent = ""
+	case *ast.Object:
+		// Hidden variable to allow $ binding.
+		if objLevel == 0 {
+			dollar := ast.Identifier("$")
+			node.Fields = append(node.Fields, ast.ObjectFieldLocalNoMethod(&dollar, &ast.Self{}))
+		}
+
+		err = desugarFields(*node.Loc(), &node.Fields, objLevel)
+		if err != nil {
+			return
+		}
+
+		*astPtr = buildDesugaredObject(node.NodeBase, node.Fields)
+		err = desugar(astPtr, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.DesugaredObject:
+		for i := range node.Fields {
+			field := &((node.Fields)[i])
+			if field.Name != nil {
+				err := desugar(&field.Name, objLevel)
+				if err != nil {
+					return err
+				}
+			}
+			err := desugar(&field.Body, objLevel+1)
+			if err != nil {
+				return err
+			}
+		}
+		for i := range node.Asserts {
+			assert := &((node.Asserts)[i])
+			err := desugar(assert, objLevel+1)
+			if err != nil {
+				return err
+			}
+		}
+
+	case *ast.ObjectComp:
+		comp, err := desugarObjectComp(node, objLevel)
+		if err != nil {
+			return err
+		}
+		err = desugar(&comp, objLevel)
+		if err != nil {
+			return err
+		}
+		*astPtr = comp
+
+	case *ast.Self:
+		// Nothing to do.
+
+	case *ast.SuperIndex:
+		if node.Id != nil {
+			node.Index = &ast.LiteralString{Value: string(*node.Id)}
+			node.Id = nil
+		}
+
+	case *ast.InSuper:
+		err := desugar(&node.Index, objLevel)
+		if err != nil {
+			return err
+		}
+	case *ast.Unary:
+		err = desugar(&node.Expr, objLevel)
+		if err != nil {
+			return
+		}
+
+	case *ast.Var:
+		// Nothing to do.
+
+	default:
+		panic(fmt.Sprintf("Desugarer does not recognize ast: %s", reflect.TypeOf(node)))
+	}
+
+	return nil
+}
+
+func desugarFile(ast *ast.Node) error {
+	err := desugar(ast, 0)
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/static_analysis.h b/vendor/github.com/google/go-jsonnet/doc.go
similarity index 54%
rename from vendor/github.com/strickyak/jsonnet_cgo/static_analysis.h
rename to vendor/github.com/google/go-jsonnet/doc.go
index 3368d4e9a78377f6934ba7b5af39eb679da65bdd..94d1b64a432cc53ae123b52b8bb596c7a454cfd7 100644
--- a/vendor/github.com/strickyak/jsonnet_cgo/static_analysis.h
+++ b/vendor/github.com/google/go-jsonnet/doc.go
@@ -1,5 +1,5 @@
 /*
-Copyright 2015 Google Inc. All rights reserved.
+Copyright 2016 Google Inc. All rights reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#ifndef JSONNET_STATIC_ANALYSIS_H
-#define JSONNET_STATIC_ANALYSIS_H
-
-#include "ast.h"
+/*
+Package jsonnet implements a parser and evaluator for jsonnet.
 
-/** Check the ast for appropriate use of self, super, and correctly bound variables.  Also
- * initialize the freeVariables member of function and object ASTs.
- */
-void jsonnet_static_analysis(AST *ast);
+Jsonnet is a domain specific configuration language that helps you define JSON
+data. Jsonnet lets you compute fragments of JSON within the structure, bringing
+the same benefit to structured data that templating languages bring to plain
+text.
 
-#endif
+See http://jsonnet.org/ for a full language description and tutorial.
+*/
+package jsonnet
diff --git a/vendor/github.com/google/go-jsonnet/error_formatter.go b/vendor/github.com/google/go-jsonnet/error_formatter.go
new file mode 100644
index 0000000000000000000000000000000000000000..102b46eada0004ec4652ab5cb7c000dbf4895306
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/error_formatter.go
@@ -0,0 +1,119 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package jsonnet
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/fatih/color"
+	"github.com/google/go-jsonnet/ast"
+	"github.com/google/go-jsonnet/parser"
+)
+
+type ErrorFormatter struct {
+	// MaxStackTraceSize  is the maximum length of stack trace before cropping
+	MaxStackTraceSize int
+
+	// Examples of current state of the art.
+	// http://elm-lang.org/blog/compiler-errors-for-humans
+	// https://clang.llvm.org/diagnostics.html
+	pretty   bool
+	colorful bool
+	SP       *ast.SourceProvider
+}
+
+func (ef *ErrorFormatter) format(err error) string {
+	switch err := err.(type) {
+	case RuntimeError:
+		return ef.formatRuntime(&err)
+	case parser.StaticError:
+		return ef.formatStatic(&err)
+	default:
+		return ef.formatInternal(err)
+	}
+}
+
+func (ef *ErrorFormatter) formatRuntime(err *RuntimeError) string {
+	return err.Error() + "\n" + ef.buildStackTrace(err.StackTrace)
+}
+
+func (ef *ErrorFormatter) formatStatic(err *parser.StaticError) string {
+	var buf bytes.Buffer
+	buf.WriteString(err.Error() + "\n")
+	ef.showCode(&buf, err.Loc)
+	return buf.String()
+}
+
+const bugURL = "https://github.com/google/go-jsonnet/issues"
+
+func (ef *ErrorFormatter) formatInternal(err error) string {
+	return "INTERNAL ERROR: " + err.Error() + "\n" +
+		"Please report a bug here: " + bugURL + "\n"
+}
+
+func (ef *ErrorFormatter) showCode(buf *bytes.Buffer, loc ast.LocationRange) {
+	errFprintf := fmt.Fprintf
+	if ef.colorful {
+		errFprintf = color.New(color.FgRed).Fprintf
+	}
+	if loc.WithCode() {
+		// TODO(sbarzowski) include line numbers
+		// TODO(sbarzowski) underline errors instead of depending only on color
+		fmt.Fprintf(buf, "\n")
+		beginning := ast.LineBeginning(&loc)
+		ending := ast.LineEnding(&loc)
+		fmt.Fprintf(buf, "%v", ef.SP.GetSnippet(beginning))
+		errFprintf(buf, "%v", ef.SP.GetSnippet(loc))
+		fmt.Fprintf(buf, "%v", ef.SP.GetSnippet(ending))
+		buf.WriteByte('\n')
+	}
+	fmt.Fprintf(buf, "\n")
+}
+
+func (ef *ErrorFormatter) frame(frame *TraceFrame, buf *bytes.Buffer) {
+	// TODO(sbarzowski) tabs are probably a bad idea
+	fmt.Fprintf(buf, "\t%v\t%v\n", frame.Loc.String(), frame.Name)
+	if ef.pretty {
+		ef.showCode(buf, frame.Loc)
+	}
+}
+
+func (ef *ErrorFormatter) buildStackTrace(frames []TraceFrame) string {
+	// https://github.com/google/jsonnet/blob/master/core/libjsonnet.cpp#L594
+	maxAbove := ef.MaxStackTraceSize / 2
+	maxBelow := ef.MaxStackTraceSize - maxAbove
+	var buf bytes.Buffer
+	sz := len(frames)
+	for i := 0; i < sz; i++ {
+		// TODO(sbarzowski) make pretty format more readable (it's already useful)
+		if ef.pretty {
+			fmt.Fprintf(&buf, "-------------------------------------------------\n")
+		}
+		if i >= maxAbove && i < sz-maxBelow {
+			if ef.pretty {
+				fmt.Fprintf(&buf, "\t... (skipped %v frames)\n", sz-maxAbove-maxBelow)
+			} else {
+				buf.WriteString("\t...\n")
+			}
+
+			i = sz - maxBelow - 1
+		} else {
+			ef.frame(&frames[sz-i-1], &buf)
+		}
+	}
+	return buf.String()
+}
diff --git a/vendor/github.com/google/go-jsonnet/evaluator.go b/vendor/github.com/google/go-jsonnet/evaluator.go
new file mode 100644
index 0000000000000000000000000000000000000000..5409a85e8dbdfcd5f8cd6acbb8fe1f90b9744c57
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/evaluator.go
@@ -0,0 +1,229 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"fmt"
+
+	"github.com/google/go-jsonnet/ast"
+)
+
+// evaluator is a convenience wrapper for interpreter
+// Most importantly it keeps the context for traces and handles details
+// of error handling.
+type evaluator struct {
+	i     *interpreter
+	trace *TraceElement
+}
+
+func makeEvaluator(i *interpreter, trace *TraceElement) *evaluator {
+	return &evaluator{i: i, trace: trace}
+}
+
+func (e *evaluator) inNewContext(trace *TraceElement) *evaluator {
+	return makeEvaluator(e.i, trace)
+}
+
+func (e *evaluator) evaluate(ph potentialValue) (value, error) {
+	return ph.getValue(e.i, e.trace)
+}
+
+func (e *evaluator) evaluateTailCall(ph potentialValue, tc tailCallStatus) (value, error) {
+	if tc == tailCall {
+		e.i.stack.tailCallTrimStack()
+	}
+	return ph.getValue(e.i, e.trace)
+}
+
+func (e *evaluator) Error(s string) error {
+	err := makeRuntimeError(s, e.i.getCurrentStackTrace(e.trace))
+	return err
+}
+
+func (e *evaluator) typeErrorSpecific(bad value, good value) error {
+	return e.Error(
+		fmt.Sprintf("Unexpected type %v, expected %v", bad.getType().name, good.getType().name),
+	)
+}
+
+func (e *evaluator) typeErrorGeneral(bad value) error {
+	return e.Error(
+		fmt.Sprintf("Unexpected type %v", bad.getType().name),
+	)
+}
+
+func (e *evaluator) getNumber(val value) (*valueNumber, error) {
+	switch v := val.(type) {
+	case *valueNumber:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueNumber{})
+	}
+}
+
+func (e *evaluator) evaluateNumber(pv potentialValue) (*valueNumber, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getNumber(v)
+}
+
+func (e *evaluator) getInt(val value) (int, error) {
+	num, err := e.getNumber(val)
+	if err != nil {
+		return 0, err
+	}
+	// We conservatively convert ot int32, so that it can be machine-sized int
+	// on any machine. And it's used only for indexing anyway.
+	intNum := int(int32(num.value))
+	if float64(intNum) != num.value {
+		return 0, e.Error(fmt.Sprintf("Expected an integer, but got %v", num.value))
+	}
+	return intNum, nil
+}
+
+func (e *evaluator) evaluateInt(pv potentialValue) (int, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return 0, err
+	}
+	return e.getInt(v)
+}
+
+func (e *evaluator) getInt64(val value) (int64, error) {
+	num, err := e.getNumber(val)
+	if err != nil {
+		return 0, err
+	}
+	// We conservatively convert ot int32, so that it can be machine-sized int
+	// on any machine. And it's used only for indexing anyway.
+	intNum := int64(num.value)
+	if float64(intNum) != num.value {
+		return 0, e.Error(fmt.Sprintf("Expected an integer, but got %v", num.value))
+	}
+	return intNum, nil
+}
+
+func (e *evaluator) evaluateInt64(pv potentialValue) (int64, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return 0, err
+	}
+	return e.getInt64(v)
+}
+
+func (e *evaluator) getString(val value) (*valueString, error) {
+	switch v := val.(type) {
+	case *valueString:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueString{})
+	}
+}
+
+func (e *evaluator) evaluateString(pv potentialValue) (*valueString, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getString(v)
+}
+
+func (e *evaluator) getBoolean(val value) (*valueBoolean, error) {
+	switch v := val.(type) {
+	case *valueBoolean:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueBoolean{})
+	}
+}
+
+func (e *evaluator) evaluateBoolean(pv potentialValue) (*valueBoolean, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getBoolean(v)
+}
+
+func (e *evaluator) getArray(val value) (*valueArray, error) {
+	switch v := val.(type) {
+	case *valueArray:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueArray{})
+	}
+}
+
+func (e *evaluator) evaluateArray(pv potentialValue) (*valueArray, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getArray(v)
+}
+
+func (e *evaluator) getFunction(val value) (*valueFunction, error) {
+	switch v := val.(type) {
+	case *valueFunction:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueFunction{})
+	}
+}
+
+func (e *evaluator) evaluateFunction(pv potentialValue) (*valueFunction, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getFunction(v)
+}
+
+func (e *evaluator) getObject(val value) (valueObject, error) {
+	switch v := val.(type) {
+	case valueObject:
+		return v, nil
+	default:
+		return nil, e.typeErrorSpecific(val, &valueSimpleObject{})
+	}
+}
+
+func (e *evaluator) evaluateObject(pv potentialValue) (valueObject, error) {
+	v, err := e.evaluate(pv)
+	if err != nil {
+		return nil, err
+	}
+	return e.getObject(v)
+}
+
+func (e *evaluator) evalInCurrentContext(a ast.Node, tc tailCallStatus) (value, error) {
+	return e.i.evaluate(a, tc)
+}
+
+func (e *evaluator) evalInCleanEnv(env *environment, ast ast.Node, trimmable bool) (value, error) {
+	return e.i.EvalInCleanEnv(e.trace, env, ast, trimmable)
+}
+
+func (e *evaluator) lookUpVar(ident ast.Identifier) potentialValue {
+	th := e.i.stack.lookUpVar(ident)
+	if th == nil {
+		panic(fmt.Sprintf("RUNTIME: Unknown variable: %v (we should have caught this statically)", ident))
+	}
+	return th
+}
diff --git a/vendor/github.com/google/go-jsonnet/imports.go b/vendor/github.com/google/go-jsonnet/imports.go
new file mode 100644
index 0000000000000000000000000000000000000000..5bd2101ebaee112060d8660082883efe53510b59
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/imports.go
@@ -0,0 +1,155 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+)
+
+type ImportedData struct {
+	err       error
+	foundHere string
+	content   string
+}
+
+type Importer interface {
+	Import(codeDir string, importedPath string) *ImportedData
+}
+
+type ImportCacheValue struct {
+	data *ImportedData
+
+	// nil if we have only imported it via importstr
+	asCode potentialValue
+}
+
+type importCacheKey struct {
+	dir          string
+	importedPath string
+}
+
+type importCacheMap map[importCacheKey]ImportCacheValue
+
+type ImportCache struct {
+	cache    importCacheMap
+	importer Importer
+}
+
+func MakeImportCache(importer Importer) *ImportCache {
+	return &ImportCache{importer: importer, cache: make(importCacheMap)}
+}
+
+func (cache *ImportCache) importData(key importCacheKey) *ImportCacheValue {
+	if value, ok := cache.cache[key]; ok {
+		return &value
+	}
+	data := cache.importer.Import(key.dir, key.importedPath)
+	val := ImportCacheValue{
+		data: data,
+	}
+	cache.cache[key] = val
+	return &val
+}
+
+func (cache *ImportCache) ImportString(codeDir, importedPath string, e *evaluator) (*valueString, error) {
+	data := cache.importData(importCacheKey{codeDir, importedPath})
+	if data.data.err != nil {
+		return nil, e.Error(data.data.err.Error())
+	}
+	return makeValueString(data.data.content), nil
+}
+
+func codeToPV(e *evaluator, filename string, code string) potentialValue {
+	node, err := snippetToAST(filename, code)
+	if err != nil {
+		// TODO(sbarzowski) we should wrap (static) error here
+		// within a RuntimeError. Because whether we get this error or not
+		// actually depends on what happens in Runtime (whether import gets
+		// evaluated).
+		// The same thinking applies to external variables.
+		return makeErrorThunk(err)
+	}
+	return makeThunk(makeInitialEnv(filename, e.i.baseStd), node)
+}
+
+func (cache *ImportCache) ImportCode(codeDir, importedPath string, e *evaluator) (value, error) {
+	cached := cache.importData(importCacheKey{codeDir, importedPath})
+	if cached.data.err != nil {
+		return nil, e.Error(cached.data.err.Error())
+	}
+	if cached.asCode == nil {
+		cached.asCode = codeToPV(e, cached.data.foundHere, cached.data.content)
+	}
+	return e.evaluate(cached.asCode)
+}
+
+// Concrete importers
+// -------------------------------------
+
+type FileImporter struct {
+	// TODO(sbarzowski) fill it in
+	JPaths []string
+}
+
+func tryPath(dir, importedPath string) (found bool, content []byte, foundHere string, err error) {
+	var absPath string
+	if path.IsAbs(importedPath) {
+		absPath = importedPath
+	} else {
+		absPath = path.Join(dir, importedPath)
+	}
+	content, err = ioutil.ReadFile(absPath)
+	if os.IsNotExist(err) {
+		return false, nil, "", nil
+	}
+	return true, content, absPath, err
+}
+
+func (importer *FileImporter) Import(dir, importedPath string) *ImportedData {
+	found, content, foundHere, err := tryPath(dir, importedPath)
+	if err != nil {
+		return &ImportedData{err: err}
+	}
+
+	for i := 0; !found && i < len(importer.JPaths); i++ {
+		found, content, foundHere, err = tryPath(importer.JPaths[i], importedPath)
+		if err != nil {
+			return &ImportedData{err: err}
+		}
+	}
+
+	if !found {
+		return &ImportedData{
+			err: fmt.Errorf("Couldn't open import %#v: No match locally or in the Jsonnet library paths.", importedPath),
+		}
+	}
+	return &ImportedData{content: string(content), foundHere: foundHere}
+}
+
+type MemoryImporter struct {
+	data map[string]string
+}
+
+func (importer *MemoryImporter) Import(dir, importedPath string) *ImportedData {
+	if content, ok := importer.data[importedPath]; ok {
+		return &ImportedData{content: content, foundHere: importedPath}
+	}
+	return &ImportedData{err: fmt.Errorf("Import not available %v", importedPath)}
+}
diff --git a/vendor/github.com/google/go-jsonnet/interpreter.go b/vendor/github.com/google/go-jsonnet/interpreter.go
new file mode 100644
index 0000000000000000000000000000000000000000..cf352784aaaa5077e9c8d2babcb80fe7d77a1c83
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/interpreter.go
@@ -0,0 +1,923 @@
+/*
+Copyright 2016 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"path"
+	"reflect"
+	"sort"
+
+	"github.com/google/go-jsonnet/ast"
+)
+
+// TODO(sbarzowski) use it as a pointer in most places b/c it can sometimes be shared
+// for example it can be shared between array elements and function arguments
+type environment struct {
+	sb selfBinding
+
+	// Bindings introduced in this frame. The way previous bindings are treated
+	// depends on the type of a frame.
+	// If isCall == true then previous bindings are ignored (it's a clean
+	// environment with just the variables we have here).
+	// If isCall == false then if this frame doesn't contain a binding
+	// previous bindings will be used.
+	upValues bindingFrame
+}
+
+func makeEnvironment(upValues bindingFrame, sb selfBinding) environment {
+	return environment{
+		upValues: upValues,
+		sb:       sb,
+	}
+}
+
+func callFrameToTraceFrame(frame *callFrame) TraceFrame {
+	return traceElementToTraceFrame(frame.trace)
+}
+
+func (i *interpreter) getCurrentStackTrace(additional *TraceElement) []TraceFrame {
+	var result []TraceFrame
+	for _, f := range i.stack.stack {
+		if f.isCall {
+			result = append(result, callFrameToTraceFrame(f))
+		}
+	}
+	if additional != nil {
+		result = append(result, traceElementToTraceFrame(additional))
+	}
+	return result
+}
+
+type callFrame struct {
+	// True if it switches to a clean environment (function call or array element)
+	// False otherwise, e.g. for local
+	// This makes callFrame a misnomer as it is technically not always a call...
+	isCall bool
+
+	// Tracing information about the place where it was called from.
+	trace *TraceElement
+
+	// Whether this frame can be removed from the stack when it doesn't affect
+	// the evaluation result, but in case of an error, it won't appear on the
+	// stack trace.
+	// It's used for tail call optimization.
+	trimmable bool
+
+	env environment
+}
+
+func dumpCallFrame(c *callFrame) string {
+	var loc ast.LocationRange
+	if c.trace == nil || c.trace.loc == nil {
+		loc = ast.MakeLocationRangeMessage("?")
+	} else {
+		loc = *c.trace.loc
+	}
+	return fmt.Sprintf("<callFrame isCall = %t location = %v trimmable = %t>",
+		c.isCall,
+		loc,
+		c.trimmable,
+	)
+}
+
+type callStack struct {
+	calls int
+	limit int
+	stack []*callFrame
+}
+
+func dumpCallStack(c *callStack) string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "<callStack calls = %d limit = %d stack:\n", c.calls, c.limit)
+	for _, callFrame := range c.stack {
+		fmt.Fprintf(&buf, "  %v\n", dumpCallFrame(callFrame))
+	}
+	buf.WriteString("\n>")
+	return buf.String()
+}
+
+func (s *callStack) top() *callFrame {
+	r := s.stack[len(s.stack)-1]
+	return r
+}
+
+// It might've been popped already by tail call optimization.
+// We check if it was trimmed by comparing the current stack size to the position
+// of the frame we want to pop.
+func (s *callStack) popIfExists(whichFrame int) {
+	if len(s.stack) == whichFrame {
+		if s.top().isCall {
+			s.calls--
+		}
+		s.stack = s.stack[:len(s.stack)-1]
+	}
+}
+
+/** If there is a trimmable frame followed by some locals, pop them all. */
+func (s *callStack) tailCallTrimStack() {
+	for i := len(s.stack) - 1; i >= 0; i-- {
+		if s.stack[i].isCall {
+			if !s.stack[i].trimmable {
+				return
+			}
+			// Remove this stack frame and everything above it
+			s.stack = s.stack[:i]
+			s.calls--
+			return
+		}
+	}
+}
+
+type tailCallStatus int
+
+const (
+	nonTailCall tailCallStatus = iota
+	tailCall
+)
+
+func (i *interpreter) newCall(trace *TraceElement, env environment, trimmable bool) error {
+	s := &i.stack
+	if s.calls >= s.limit {
+		return makeRuntimeError("Max stack frames exceeded.", i.getCurrentStackTrace(trace))
+	}
+	s.stack = append(s.stack, &callFrame{
+		isCall:    true,
+		trace:     trace,
+		env:       env,
+		trimmable: trimmable,
+	})
+	s.calls++
+	return nil
+}
+
+func (i *interpreter) newLocal(vars bindingFrame) {
+	s := &i.stack
+	s.stack = append(s.stack, &callFrame{
+		env: makeEnvironment(vars, selfBinding{}),
+	})
+}
+
+// getSelfBinding resolves the self construct
+func (s *callStack) getSelfBinding() selfBinding {
+	for i := len(s.stack) - 1; i >= 0; i-- {
+		if s.stack[i].isCall {
+			return s.stack[i].env.sb
+		}
+	}
+	panic(fmt.Sprintf("malformed stack %v", dumpCallStack(s)))
+}
+
+// lookUpVar finds for the closest variable in scope that matches the given name.
+func (s *callStack) lookUpVar(id ast.Identifier) potentialValue {
+	for i := len(s.stack) - 1; i >= 0; i-- {
+		bind := s.stack[i].env.upValues[id]
+		if bind != nil {
+			return bind
+		}
+		if s.stack[i].isCall {
+			// Nothing beyond the captured environment of the thunk / closure.
+			break
+		}
+	}
+	return nil
+}
+
+func makeCallStack(limit int) callStack {
+	return callStack{
+		calls: 0,
+		limit: limit,
+	}
+}
+
+// Keeps current execution context and evaluates things
+type interpreter struct {
+	// Current stack. It is used for:
+	// 1) Keeping environment (object we're in, variables)
+	// 2) Diagnostic information in case of failure
+	stack callStack
+
+	// External variables
+	extVars map[string]potentialValue
+
+	// Native functions
+	nativeFuncs map[string]*NativeFunction
+
+	// A part of std object common to all files
+	baseStd valueObject
+
+	// Keeps imports
+	importCache *ImportCache
+}
+
+// Build a binding frame containing specified variables.
+func (i *interpreter) capture(freeVars ast.Identifiers) bindingFrame {
+	env := make(bindingFrame)
+	for _, fv := range freeVars {
+		env[fv] = i.stack.lookUpVar(fv)
+		if env[fv] == nil {
+			panic(fmt.Sprintf("Variable %v vanished", fv))
+		}
+	}
+	return env
+}
+
+func addBindings(a, b bindingFrame) bindingFrame {
+	result := make(bindingFrame)
+
+	for k, v := range a {
+		result[k] = v
+	}
+
+	for k, v := range b {
+		result[k] = v
+	}
+
+	return result
+}
+
+func (i *interpreter) getCurrentEnv(ast ast.Node) environment {
+	return makeEnvironment(
+		i.capture(ast.FreeVariables()),
+		i.stack.getSelfBinding(),
+	)
+}
+
+func (i *interpreter) evaluate(a ast.Node, tc tailCallStatus) (value, error) {
+	e := &evaluator{
+		trace: &TraceElement{
+			loc:     a.Loc(),
+			context: a.Context(),
+		},
+		i: i,
+	}
+
+	switch node := a.(type) {
+	case *ast.Array:
+		sb := i.stack.getSelfBinding()
+		var elements []potentialValue
+		for _, el := range node.Elements {
+			env := makeEnvironment(i.capture(el.FreeVariables()), sb)
+			elThunk := makeThunk(env, el)
+			elements = append(elements, elThunk)
+		}
+		return makeValueArray(elements), nil
+
+	case *ast.Binary:
+		// Some binary operators are lazy, so thunks are needed in general
+		env := i.getCurrentEnv(node)
+		// TODO(sbarzowski) make sure it displays nicely in stack trace (thunk names etc.)
+		// TODO(sbarzowski) it may make sense not to show a line in stack trace for operators
+		// 					at all in many cases. 1 + 2 + 3 + 4 + error "x" will show 5 lines
+		//					of stack trace now, and it's not that nice.
+		left := makeThunk(env, node.Left)
+		right := makeThunk(env, node.Right)
+
+		builtin := bopBuiltins[node.Op]
+
+		result, err := builtin.function(e, left, right)
+		if err != nil {
+			return nil, err
+		}
+		return result, nil
+
+	case *ast.Unary:
+		env := i.getCurrentEnv(node)
+		arg := makeThunk(env, node.Expr)
+
+		builtin := uopBuiltins[node.Op]
+
+		result, err := builtin.function(e, arg)
+		if err != nil {
+			return nil, err
+		}
+		return result, nil
+
+	case *ast.Conditional:
+		cond, err := e.evalInCurrentContext(node.Cond, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		condBool, err := e.getBoolean(cond)
+		if err != nil {
+			return nil, err
+		}
+		if condBool.value {
+			return e.evalInCurrentContext(node.BranchTrue, tc)
+		}
+		return e.evalInCurrentContext(node.BranchFalse, tc)
+
+	case *ast.DesugaredObject:
+		// Evaluate all the field names.  Check for null, dups, etc.
+		fields := make(simpleObjectFieldMap)
+		for _, field := range node.Fields {
+			fieldNameValue, err := e.evalInCurrentContext(field.Name, nonTailCall)
+			if err != nil {
+				return nil, err
+			}
+			var fieldName string
+			switch fieldNameValue := fieldNameValue.(type) {
+			case *valueString:
+				fieldName = fieldNameValue.getString()
+			case *valueNull:
+				// Omitted field.
+				continue
+			default:
+				return nil, e.Error(fmt.Sprintf("Field name must be string, got %v", fieldNameValue.getType().name))
+			}
+
+			if _, ok := fields[fieldName]; ok {
+				return nil, e.Error(duplicateFieldNameErrMsg(fieldName))
+			}
+			var f unboundField = &codeUnboundField{field.Body}
+			if field.PlusSuper {
+				f = &PlusSuperUnboundField{f}
+			}
+			fields[fieldName] = simpleObjectField{field.Hide, f}
+		}
+		var asserts []unboundField
+		for _, assert := range node.Asserts {
+			asserts = append(asserts, &codeUnboundField{assert})
+		}
+		upValues := i.capture(node.FreeVariables())
+		return makeValueSimpleObject(upValues, fields, asserts), nil
+
+	case *ast.Error:
+		msgVal, err := e.evalInCurrentContext(node.Expr, nonTailCall)
+		if err != nil {
+			// error when evaluating error message
+			return nil, err
+		}
+		msg, err := e.getString(msgVal)
+		if err != nil {
+			return nil, err
+		}
+		return nil, e.Error(msg.getString())
+
+	case *ast.Index:
+		targetValue, err := e.evalInCurrentContext(node.Target, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		index, err := e.evalInCurrentContext(node.Index, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		switch target := targetValue.(type) {
+		case valueObject:
+			indexString, err := e.getString(index)
+			if err != nil {
+				return nil, err
+			}
+			return target.index(e, indexString.getString())
+		case *valueArray:
+			indexInt, err := e.getNumber(index)
+			if err != nil {
+				return nil, err
+			}
+			// TODO(https://github.com/google/jsonnet/issues/377): non-integer indexes should be an error
+			return e.evaluateTailCall(target.elements[int(indexInt.value)], tc)
+
+		case *valueString:
+			indexInt, err := e.getNumber(index)
+			if err != nil {
+				return nil, err
+			}
+			// TODO(https://github.com/google/jsonnet/issues/377): non-integer indexes should be an error
+			return target.index(e, int(indexInt.value))
+		}
+
+		return nil, e.Error(fmt.Sprintf("Value non indexable: %v", reflect.TypeOf(targetValue)))
+
+	case *ast.Import:
+		codeDir := path.Dir(node.Loc().FileName)
+		return i.importCache.ImportCode(codeDir, node.File.Value, e)
+
+	case *ast.ImportStr:
+		codeDir := path.Dir(node.Loc().FileName)
+		return i.importCache.ImportString(codeDir, node.File.Value, e)
+
+	case *ast.LiteralBoolean:
+		return makeValueBoolean(node.Value), nil
+
+	case *ast.LiteralNull:
+		return makeValueNull(), nil
+
+	case *ast.LiteralNumber:
+		return makeValueNumber(node.Value), nil
+
+	case *ast.LiteralString:
+		return makeValueString(node.Value), nil
+
+	case *ast.Local:
+		vars := make(bindingFrame)
+		bindEnv := i.getCurrentEnv(a)
+		for _, bind := range node.Binds {
+			th := makeThunk(bindEnv, bind.Body)
+
+			// recursive locals
+			vars[bind.Variable] = th
+			bindEnv.upValues[bind.Variable] = th
+		}
+		i.newLocal(vars)
+		sz := len(i.stack.stack)
+		// Add new stack frame, with new thunk for this variable
+		// execute body WRT stack frame.
+		v, err := e.evalInCurrentContext(node.Body, tc)
+		i.stack.popIfExists(sz)
+
+		return v, err
+
+	case *ast.Self:
+		sb := i.stack.getSelfBinding()
+		return sb.self, nil
+
+	case *ast.Var:
+		return e.evaluateTailCall(e.lookUpVar(node.Id), tc)
+
+	case *ast.SuperIndex:
+		index, err := e.evalInCurrentContext(node.Index, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		indexStr, err := e.getString(index)
+		if err != nil {
+			return nil, err
+		}
+		return objectIndex(e, i.stack.getSelfBinding().super(), indexStr.getString())
+
+	case *ast.InSuper:
+		index, err := e.evalInCurrentContext(node.Index, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		indexStr, err := e.getString(index)
+		if err != nil {
+			return nil, err
+		}
+		field := tryObjectIndex(i.stack.getSelfBinding().super(), indexStr.getString(), withHidden)
+		return makeValueBoolean(field != nil), nil
+
+	case *ast.Function:
+		return &valueFunction{
+			ec: makeClosure(i.getCurrentEnv(a), node),
+		}, nil
+
+	case *ast.Apply:
+		// Eval target
+		target, err := e.evalInCurrentContext(node.Target, nonTailCall)
+		if err != nil {
+			return nil, err
+		}
+		function, err := e.getFunction(target)
+		if err != nil {
+			return nil, err
+		}
+
+		// environment in which we can evaluate arguments
+		argEnv := i.getCurrentEnv(a)
+		arguments := callArguments{
+			positional: make([]potentialValue, len(node.Arguments.Positional)),
+			named:      make([]namedCallArgument, len(node.Arguments.Named)),
+			tailstrict: node.TailStrict,
+		}
+		for i, arg := range node.Arguments.Positional {
+			arguments.positional[i] = makeThunk(argEnv, arg)
+		}
+
+		for i, arg := range node.Arguments.Named {
+			arguments.named[i] = namedCallArgument{name: arg.Name, pv: makeThunk(argEnv, arg.Arg)}
+		}
+		return e.evaluateTailCall(function.call(arguments), tc)
+
+	default:
+		return nil, e.Error(fmt.Sprintf("Executing this AST type not implemented yet: %v", reflect.TypeOf(a)))
+	}
+}
+
+// unparseString Wraps in "" and escapes stuff to make the string JSON-compliant and human-readable.
+func unparseString(v string) string {
+	var buf bytes.Buffer
+	buf.WriteString("\"")
+	for _, c := range v {
+		switch c {
+		case '"':
+			buf.WriteString("\\\"")
+		case '\\':
+			buf.WriteString("\\\\")
+		case '\b':
+			buf.WriteString("\\b")
+		case '\f':
+			buf.WriteString("\\f")
+		case '\n':
+			buf.WriteString("\\n")
+		case '\r':
+			buf.WriteString("\\r")
+		case '\t':
+			buf.WriteString("\\t")
+		case 0:
+			buf.WriteString("\\u0000")
+		default:
+			if c < 0x20 || (c >= 0x7f && c <= 0x9f) {
+				buf.WriteString(fmt.Sprintf("\\u%04x", int(c)))
+			} else {
+				buf.WriteRune(c)
+			}
+		}
+	}
+	buf.WriteString("\"")
+	return buf.String()
+}
+
+func unparseNumber(v float64) string {
+	if v == math.Floor(v) {
+		return fmt.Sprintf("%.0f", v)
+	}
+
+	// See "What Every Computer Scientist Should Know About Floating-Point Arithmetic"
+	// Theorem 15
+	// http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+	return fmt.Sprintf("%.17g", v)
+}
+
+// manifestJSON converts to standard JSON representation as in "encoding/json" package
+func (i *interpreter) manifestJSON(trace *TraceElement, v value) (interface{}, error) {
+	e := &evaluator{i: i, trace: trace}
+	switch v := v.(type) {
+
+	case *valueBoolean:
+		return v.value, nil
+
+	case *valueFunction:
+		return nil, makeRuntimeError("Couldn't manifest function in JSON output.", i.getCurrentStackTrace(trace))
+
+	case *valueNumber:
+		return v.value, nil
+
+	case *valueString:
+		return v.getString(), nil
+
+	case *valueNull:
+		return nil, nil
+
+	case *valueArray:
+		result := make([]interface{}, 0, len(v.elements))
+		for _, th := range v.elements {
+			elVal, err := e.evaluate(th)
+			if err != nil {
+				return nil, err
+			}
+			elem, err := i.manifestJSON(trace, elVal)
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, elem)
+		}
+		return result, nil
+
+	case valueObject:
+		fieldNames := objectFields(v, withoutHidden)
+		sort.Strings(fieldNames)
+
+		err := checkAssertions(e, v)
+		if err != nil {
+			return nil, err
+		}
+
+		result := make(map[string]interface{})
+
+		for _, fieldName := range fieldNames {
+			fieldVal, err := v.index(e, fieldName)
+			if err != nil {
+				return nil, err
+			}
+
+			field, err := i.manifestJSON(trace, fieldVal)
+			if err != nil {
+				return nil, err
+			}
+			result[fieldName] = field
+		}
+
+		return result, nil
+
+	default:
+		return nil, makeRuntimeError(
+			fmt.Sprintf("Manifesting this value not implemented yet: %s", reflect.TypeOf(v)),
+			i.getCurrentStackTrace(trace),
+		)
+
+	}
+}
+
+func serializeJSON(v interface{}, multiline bool, indent string, buf *bytes.Buffer) {
+	switch v := v.(type) {
+	case nil:
+		buf.WriteString("null")
+
+	case []interface{}:
+		if len(v) == 0 {
+			buf.WriteString("[ ]")
+		} else {
+			var prefix string
+			var indent2 string
+			if multiline {
+				prefix = "[\n"
+				indent2 = indent + "   "
+			} else {
+				prefix = "["
+				indent2 = indent
+			}
+			for _, elem := range v {
+				buf.WriteString(prefix)
+				buf.WriteString(indent2)
+				serializeJSON(elem, multiline, indent2, buf)
+				if multiline {
+					prefix = ",\n"
+				} else {
+					prefix = ", "
+				}
+			}
+			if multiline {
+				buf.WriteString("\n")
+			}
+			buf.WriteString(indent)
+			buf.WriteString("]")
+		}
+
+	case bool:
+		if v {
+			buf.WriteString("true")
+		} else {
+			buf.WriteString("false")
+		}
+
+	case float64:
+		buf.WriteString(unparseNumber(v))
+
+	case map[string]interface{}:
+		fieldNames := make([]string, 0, len(v))
+		for name := range v {
+			fieldNames = append(fieldNames, name)
+		}
+		sort.Strings(fieldNames)
+
+		if len(fieldNames) == 0 {
+			buf.WriteString("{ }")
+		} else {
+			var prefix string
+			var indent2 string
+			if multiline {
+				prefix = "{\n"
+				indent2 = indent + "   "
+			} else {
+				prefix = "{"
+				indent2 = indent
+			}
+			for _, fieldName := range fieldNames {
+				fieldVal := v[fieldName]
+
+				buf.WriteString(prefix)
+				buf.WriteString(indent2)
+
+				buf.WriteString(unparseString(fieldName))
+				buf.WriteString(": ")
+
+				serializeJSON(fieldVal, multiline, indent2, buf)
+
+				if multiline {
+					prefix = ",\n"
+				} else {
+					prefix = ", "
+				}
+			}
+
+			if multiline {
+				buf.WriteString("\n")
+			}
+			buf.WriteString(indent)
+			buf.WriteString("}")
+		}
+
+	case string:
+		buf.WriteString(unparseString(v))
+
+	default:
+		panic(fmt.Sprintf("Unsupported value for serialization %#+v", v))
+	}
+}
+
+func (i *interpreter) manifestAndSerializeJSON(trace *TraceElement, v value, multiline bool, indent string) (string, error) {
+	var buf bytes.Buffer
+	manifested, err := i.manifestJSON(trace, v)
+	if err != nil {
+		return "", err
+	}
+	serializeJSON(manifested, multiline, indent, &buf)
+	return buf.String(), nil
+}
+
+func jsonToValue(e *evaluator, v interface{}) (value, error) {
+	switch v := v.(type) {
+	case nil:
+		return &nullValue, nil
+
+	case []interface{}:
+		elems := make([]potentialValue, len(v))
+		for i, elem := range v {
+			val, err := jsonToValue(e, elem)
+			if err != nil {
+				return nil, err
+			}
+			elems[i] = &readyValue{val}
+		}
+		return makeValueArray(elems), nil
+
+	case bool:
+		return makeValueBoolean(v), nil
+	case float64:
+		return makeValueNumber(v), nil
+
+	case map[string]interface{}:
+		fieldMap := map[string]value{}
+		for name, f := range v {
+			val, err := jsonToValue(e, f)
+			if err != nil {
+				return nil, err
+			}
+			fieldMap[name] = val
+		}
+		return buildObject(ast.ObjectFieldInherit, fieldMap), nil
+
+	case string:
+		return makeValueString(v), nil
+
+	default:
+		return nil, e.Error(fmt.Sprintf("Not a json type: %#+v", v))
+	}
+}
+
+func (i *interpreter) EvalInCleanEnv(fromWhere *TraceElement, env *environment, ast ast.Node, trimmable bool) (value, error) {
+	err := i.newCall(fromWhere, *env, trimmable)
+	if err != nil {
+		return nil, err
+	}
+	stackSize := len(i.stack.stack)
+
+	val, err := i.evaluate(ast, tailCall)
+
+	i.stack.popIfExists(stackSize)
+
+	return val, err
+}
+
+func buildStdObject(i *interpreter) (valueObject, error) {
+	objVal, err := evaluateStd(i)
+	if err != nil {
+		return nil, err
+	}
+	obj := objVal.(*valueSimpleObject)
+	builtinFields := map[string]unboundField{}
+	for key, ec := range funcBuiltins {
+		function := valueFunction{ec: ec} // TODO(sbarzowski) better way to build function value
+		builtinFields[key] = &readyValue{&function}
+	}
+
+	for name, value := range builtinFields {
+		obj.fields[name] = simpleObjectField{ast.ObjectFieldHidden, value}
+	}
+	return obj, nil
+}
+
+func evaluateStd(i *interpreter) (value, error) {
+	beforeStdEnv := makeEnvironment(
+		bindingFrame{},
+		makeUnboundSelfBinding(),
+	)
+	evalLoc := ast.MakeLocationRangeMessage("During evaluation of std")
+	evalTrace := &TraceElement{loc: &evalLoc}
+	node, err := snippetToAST("<std>", getStdCode())
+	if err != nil {
+		return nil, err
+	}
+	return i.EvalInCleanEnv(evalTrace, &beforeStdEnv, node, false)
+}
+
+func prepareExtVars(i *interpreter, ext vmExtMap, kind string) map[string]potentialValue {
+	result := make(map[string]potentialValue)
+	for name, content := range ext {
+		if content.isCode {
+			varLoc := ast.MakeLocationRangeMessage("During evaluation")
+			varTrace := &TraceElement{
+				loc: &varLoc,
+			}
+			e := &evaluator{
+				i:     i,
+				trace: varTrace,
+			}
+			result[name] = codeToPV(e, "<"+kind+":"+name+">", content.value)
+		} else {
+			result[name] = &readyValue{makeValueString(content.value)}
+		}
+	}
+	return result
+}
+
+func buildObject(hide ast.ObjectFieldHide, fields map[string]value) valueObject {
+	fieldMap := simpleObjectFieldMap{}
+	for name, v := range fields {
+		fieldMap[name] = simpleObjectField{hide, &readyValue{v}}
+	}
+	return makeValueSimpleObject(bindingFrame{}, fieldMap, nil)
+}
+
+func buildInterpreter(ext vmExtMap, nativeFuncs map[string]*NativeFunction, maxStack int, importer Importer) (*interpreter, error) {
+	i := interpreter{
+		stack:       makeCallStack(maxStack),
+		importCache: MakeImportCache(importer),
+		nativeFuncs: nativeFuncs,
+	}
+
+	stdObj, err := buildStdObject(&i)
+	if err != nil {
+		return nil, err
+	}
+
+	i.baseStd = stdObj
+
+	i.extVars = prepareExtVars(&i, ext, "extvar")
+
+	return &i, nil
+}
+
+func makeInitialEnv(filename string, baseStd valueObject) environment {
+	fileSpecific := buildObject(ast.ObjectFieldHidden, map[string]value{
+		"thisFile": makeValueString(filename),
+	})
+	return makeEnvironment(
+		bindingFrame{
+			"std": &readyValue{makeValueExtendedObject(baseStd, fileSpecific)},
+		},
+		makeUnboundSelfBinding(),
+	)
+}
+
+// TODO(sbarzowski) this function takes far too many arguments - build interpreter in vm instead
+func evaluate(node ast.Node, ext vmExtMap, tla vmExtMap, nativeFuncs map[string]*NativeFunction, maxStack int, importer Importer) (string, error) {
+	i, err := buildInterpreter(ext, nativeFuncs, maxStack, importer)
+	if err != nil {
+		return "", err
+	}
+	evalLoc := ast.MakeLocationRangeMessage("During evaluation")
+	evalTrace := &TraceElement{
+		loc: &evalLoc,
+	}
+	env := makeInitialEnv(node.Loc().FileName, i.baseStd)
+	result, err := i.EvalInCleanEnv(evalTrace, &env, node, false)
+	if err != nil {
+		return "", err
+	}
+	if len(tla) != 0 {
+		// If it's not a function, ignore TLA
+		if f, ok := result.(*valueFunction); ok {
+			toplevelArgMap := prepareExtVars(i, tla, "top-level-arg")
+			args := callArguments{}
+			for argName, pv := range toplevelArgMap {
+				args.named = append(args.named, namedCallArgument{name: ast.Identifier(argName), pv: pv})
+			}
+			funcLoc := ast.MakeLocationRangeMessage("Top-level-function")
+			funcTrace := &TraceElement{
+				loc: &funcLoc,
+			}
+			result, err = f.call(args).getValue(i, funcTrace)
+			if err != nil {
+				return "", err
+			}
+		}
+	}
+	manifestationLoc := ast.MakeLocationRangeMessage("During manifestation")
+	manifestationTrace := &TraceElement{
+		loc: &manifestationLoc,
+	}
+	s, err := i.manifestAndSerializeJSON(manifestationTrace, result, true, "")
+	if err != nil {
+		return "", err
+	}
+	return s, nil
+}
diff --git a/vendor/github.com/google/go-jsonnet/mutually_recursive_defaults.input b/vendor/github.com/google/go-jsonnet/mutually_recursive_defaults.input
new file mode 100644
index 0000000000000000000000000000000000000000..4cb1bf648e9601041e007d0a72b9b89ffae920a5
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/mutually_recursive_defaults.input
@@ -0,0 +1 @@
+(function(a=[1, b[1]], b=[a[0], 2]) [a, b])()
diff --git a/vendor/github.com/google/go-jsonnet/parser/context.go b/vendor/github.com/google/go-jsonnet/parser/context.go
new file mode 100644
index 0000000000000000000000000000000000000000..967a41bc9cbcca666d4e91cf1eb983f6fb88d2de
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/parser/context.go
@@ -0,0 +1,371 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package parser
+
+import (
+	"fmt"
+
+	"github.com/google/go-jsonnet/ast"
+)
+
+var topLevelContext = "$"
+
+const anonymous = "anonymous"
+
+// TODO(sbarzowski) polish children functions and consider moving to AST
+// and exporting
+
+// directChildren are children of AST node that are executed in the same context
+// and environment as their parent
+//
+// They must satisfy the following rules:
+// * (no-delayed-evaluation) They are evaluated when their parent is evaluated or never.
+// * (no-indirect-evaluation) They cannot be evaluated during evaluation of any non-direct children
+// * (same-environment) They must be evaluated in the same environment as their parent
+func directChildren(node ast.Node) []ast.Node {
+	switch node := node.(type) {
+	case *ast.Apply:
+		return []ast.Node{node.Target}
+		// TODO(sbarzowski) tailstrict call arguments (once we have tailstrict)
+	case *ast.ApplyBrace:
+		return []ast.Node{node.Left, node.Right}
+	case *ast.Array:
+		return nil
+	case *ast.Assert:
+		return []ast.Node{node.Cond, node.Message, node.Rest}
+	case *ast.Binary:
+		return []ast.Node{node.Left, node.Right}
+	case *ast.Conditional:
+		return []ast.Node{node.Cond, node.BranchTrue, node.BranchFalse}
+	case *ast.Dollar:
+		return nil
+	case *ast.Error:
+		return []ast.Node{node.Expr}
+	case *ast.Function:
+		return nil
+	case *ast.Import:
+		return nil
+	case *ast.ImportStr:
+		return nil
+	case *ast.Index:
+		return []ast.Node{node.Target, node.Index}
+	case *ast.Slice:
+		return []ast.Node{node.Target, node.BeginIndex, node.EndIndex, node.Step}
+	case *ast.Local:
+		return []ast.Node{node.Body}
+	case *ast.LiteralBoolean:
+		return nil
+	case *ast.LiteralNull:
+		return nil
+	case *ast.LiteralNumber:
+		return nil
+	case *ast.LiteralString:
+		return nil
+	case *ast.Object:
+		return objectFieldsDirectChildren(node.Fields)
+	case *ast.ArrayComp:
+		result := []ast.Node{}
+		spec := &node.Spec
+		for spec != nil {
+			result = append(result, spec.Expr)
+			for _, ifspec := range spec.Conditions {
+				result = append(result, ifspec.Expr)
+			}
+			spec = spec.Outer
+		}
+		return result
+	case *ast.ObjectComp:
+		result := objectFieldsDirectChildren(node.Fields)
+		spec := &node.Spec
+		for spec != nil {
+			result = append(result, spec.Expr)
+			for _, ifspec := range spec.Conditions {
+				result = append(result, ifspec.Expr)
+			}
+			spec = spec.Outer
+		}
+		return result
+	case *ast.Self:
+		return nil
+	case *ast.SuperIndex:
+		return []ast.Node{node.Index}
+	case *ast.InSuper:
+		return []ast.Node{node.Index}
+	case *ast.Unary:
+		return []ast.Node{node.Expr}
+	case *ast.Var:
+		return nil
+	}
+	panic(fmt.Sprintf("directChildren: Unknown node %#v", node))
+}
+
+// thunkChildren are children of AST node that are executed in a new context
+// and capture environment from parent (thunked)
+// TODO(sbarzowski) Make sure it works well with boundary cases like tailstrict arguments,
+//					make it more precise.
+// Rules:
+// * (same-environment) They must be evaluated in the same environment as their parent
+// * (not-direct) If they can be direct children, they should (and cannot be thunked).
+func thunkChildren(node ast.Node) []ast.Node {
+	switch node := node.(type) {
+	case *ast.Apply:
+		var nodes []ast.Node
+		for _, arg := range node.Arguments.Positional {
+			nodes = append(nodes, arg)
+		}
+		for _, arg := range node.Arguments.Named {
+			nodes = append(nodes, arg.Arg)
+		}
+		return nodes
+	case *ast.ApplyBrace:
+		return nil
+	case *ast.Array:
+		return node.Elements
+	case *ast.Assert:
+		return nil
+	case *ast.Binary:
+		return nil
+	case *ast.Conditional:
+		return nil
+	case *ast.Dollar:
+		return nil
+	case *ast.Error:
+		return nil
+	case *ast.Function:
+		return nil
+	case *ast.Import:
+		return nil
+	case *ast.ImportStr:
+		return nil
+	case *ast.Index:
+		return nil
+	case *ast.Slice:
+		return nil
+	case *ast.Local:
+		// TODO(sbarzowski) complicated
+		return nil
+	case *ast.LiteralBoolean:
+		return nil
+	case *ast.LiteralNull:
+		return nil
+	case *ast.LiteralNumber:
+		return nil
+	case *ast.LiteralString:
+		return nil
+	case *ast.Object:
+		return nil
+	case *ast.ArrayComp:
+		return []ast.Node{node.Body}
+	case *ast.ObjectComp:
+		return nil
+	case *ast.Self:
+		return nil
+	case *ast.SuperIndex:
+		return nil
+	case *ast.InSuper:
+		return nil
+	case *ast.Unary:
+		return nil
+	case *ast.Var:
+		return nil
+	}
+	panic(fmt.Sprintf("thunkChildren: Unknown node %#v", node))
+}
+
+func objectFieldsDirectChildren(fields ast.ObjectFields) ast.Nodes {
+	result := ast.Nodes{}
+	for _, field := range fields {
+		if field.Expr1 != nil {
+			result = append(result, field.Expr1)
+		}
+	}
+	return result
+}
+
+func inObjectFieldsChildren(fields ast.ObjectFields) ast.Nodes {
+	result := ast.Nodes{}
+	for _, field := range fields {
+		if field.MethodSugar {
+			result = append(result, field.Method)
+		} else {
+			if field.Expr2 != nil {
+				result = append(result, field.Expr2)
+			}
+			if field.Expr3 != nil {
+				result = append(result, field.Expr3)
+			}
+		}
+	}
+	return result
+}
+
+// children that are neither direct nor thunked, e.g. object field body
+// They are evaluated in a different environment from their parent.
+func specialChildren(node ast.Node) []ast.Node {
+	switch node := node.(type) {
+	case *ast.Apply:
+		return nil
+	case *ast.ApplyBrace:
+		return nil
+	case *ast.Array:
+		return nil
+	case *ast.Assert:
+		return nil
+	case *ast.Binary:
+		return nil
+	case *ast.Conditional:
+		return nil
+	case *ast.Dollar:
+		return nil
+	case *ast.Error:
+		return nil
+	case *ast.Function:
+		// TODO(sbarzowski) this
+		return nil
+	case *ast.Import:
+		return nil
+	case *ast.ImportStr:
+		return nil
+	case *ast.Index:
+		return nil
+	case *ast.Slice:
+		return nil
+	case *ast.Local:
+		return nil
+	case *ast.LiteralBoolean:
+		return nil
+	case *ast.LiteralNull:
+		return nil
+	case *ast.LiteralNumber:
+		return nil
+	case *ast.LiteralString:
+		return nil
+	case *ast.Object:
+		return inObjectFieldsChildren(node.Fields)
+	case *ast.ArrayComp:
+		return []ast.Node{node.Body}
+	case *ast.ObjectComp:
+
+	case *ast.Self:
+		return nil
+	case *ast.SuperIndex:
+		return nil
+	case *ast.InSuper:
+		return nil
+	case *ast.Unary:
+		return nil
+	case *ast.Var:
+		return nil
+	}
+	panic(fmt.Sprintf("specialChildren: Unknown node %#v", node))
+}
+
+func children(node ast.Node) []ast.Node {
+	var result []ast.Node
+	result = append(result, directChildren(node)...)
+	result = append(result, thunkChildren(node)...)
+	result = append(result, specialChildren(node)...)
+	return result
+}
+
+func functionContext(funcName string) *string {
+	r := "function <" + funcName + ">"
+	return &r
+}
+
+func objectContext(objName string) *string {
+	r := "object <" + objName + ">"
+	return &r
+}
+
+// addContext adds context to a node and its whole subtree.
+//
+// context is the surrounding context of a node (e.g. a function it's in)
+//
+// bind is a name that the node is bound to, i.e. if node is a local bind body
+// then bind is its name. For nodes that are not bound to variables `anonymous`
+// should be passed. For example:
+// local x = 2 + 2; x
+// In such case bind for binary node 2 + 2 is "x" and for every other node,
+// including its children, its anonymous.
+func addContext(node ast.Node, context *string, bind string) {
+	if node == nil {
+		return
+	}
+
+	node.SetContext(context)
+
+	switch node := node.(type) {
+	case *ast.Function:
+		funContext := functionContext(bind)
+		addContext(node.Body, funContext, anonymous)
+		for i := range node.Parameters.Optional {
+			// Default arguments have the same context as the function body.
+			addContext(node.Parameters.Optional[i].DefaultArg, funContext, anonymous)
+		}
+	case *ast.Object:
+		// TODO(sbarzowski) include fieldname, maybe even chains
+
+		outOfObject := directChildren(node)
+		for _, f := range outOfObject {
+			// This actually is evaluated outside of object
+			addContext(f, context, anonymous)
+		}
+
+		objContext := objectContext(bind)
+		inObject := inObjectFieldsChildren(node.Fields)
+		for _, f := range inObject {
+			// This actually is evaluated outside of object
+			addContext(f, objContext, anonymous)
+		}
+
+	case *ast.ObjectComp:
+		outOfObject := directChildren(node)
+		for _, f := range outOfObject {
+			// This actually is evaluated outside of object
+			addContext(f, context, anonymous)
+		}
+
+		objContext := objectContext(bind)
+		inObject := inObjectFieldsChildren(node.Fields)
+		for _, f := range inObject {
+			// This actually is evaluated outside of object
+			addContext(f, objContext, anonymous)
+		}
+
+	case *ast.Local:
+		for _, bind := range node.Binds {
+			namedThunkContext := "thunk <" + string(bind.Variable) + "> from <" + *context + ">"
+			if bind.Fun != nil {
+				addContext(bind.Fun, &namedThunkContext, string(bind.Variable))
+			} else {
+				addContext(bind.Body, &namedThunkContext, string(bind.Variable))
+			}
+		}
+		addContext(node.Body, context, bind)
+	default:
+		for _, child := range directChildren(node) {
+			addContext(child, context, anonymous)
+		}
+
+		// TODO(sbarzowski) avoid "thunk from <thunk from..."
+		thunkContext := "thunk from <" + *context + ">"
+		for _, child := range thunkChildren(node) {
+			addContext(child, &thunkContext, anonymous)
+		}
+	}
+}
diff --git a/vendor/github.com/google/go-jsonnet/parser/lexer.go b/vendor/github.com/google/go-jsonnet/parser/lexer.go
index 785fa5d9bb6a73ef0cfe409300ae229697cf2e68..7897df8a76267fd38d213575dec2043563dd8e65 100644
--- a/vendor/github.com/google/go-jsonnet/parser/lexer.go
+++ b/vendor/github.com/google/go-jsonnet/parser/lexer.go
@@ -245,6 +245,7 @@ type position struct {
 type lexer struct {
 	fileName string // The file name being lexed, only used for errors
 	input    string // The input string
+	source   *ast.Source
 
 	pos  position // Current position in input
 	prev position // Previous position in input
@@ -263,6 +264,7 @@ func makeLexer(fn string, input string) *lexer {
 	return &lexer{
 		fileName:      fn,
 		input:         input,
+		source:        ast.BuildSource(input),
 		pos:           position{byteNo: 0, lineNo: 1, lineStart: 0},
 		prev:          position{byteNo: lexEOF, lineNo: 0, lineStart: 0},
 		tokenStartLoc: ast.Location{Line: 1, Column: 1},
@@ -337,7 +339,7 @@ func (l *lexer) emitFullToken(kind tokenKind, data, stringBlockIndent, stringBlo
 		data:                  data,
 		stringBlockIndent:     stringBlockIndent,
 		stringBlockTermIndent: stringBlockTermIndent,
-		loc: ast.MakeLocationRange(l.fileName, l.tokenStartLoc, l.location()),
+		loc: ast.MakeLocationRange(l.fileName, l.source, l.tokenStartLoc, l.location()),
 	})
 	l.fodder = fodder{}
 }
@@ -367,6 +369,10 @@ func (l *lexer) addFodder(kind fodderKind, data string) {
 	l.fodder = append(l.fodder, fodderElement{kind: kind, data: data})
 }
 
+func (l *lexer) makeStaticErrorPoint(msg string, loc ast.Location) StaticError {
+	return StaticError{Msg: msg, Loc: ast.MakeLocationRange(l.fileName, l.source, loc, loc)}
+}
+
 // lexNumber will consume a number and emit a token.  It is assumed
 // that the next rune to be served by the lexer will be a leading digit.
 func (l *lexer) lexNumber() error {
@@ -431,9 +437,9 @@ outerLoop:
 			case r >= '0' && r <= '9':
 				state = numAfterDigit
 			default:
-				return MakeStaticErrorPoint(
+				return l.makeStaticErrorPoint(
 					fmt.Sprintf("Couldn't lex number, junk after decimal point: %v", strconv.QuoteRuneToASCII(r)),
-					l.fileName, l.prevLocation())
+					l.prevLocation())
 			}
 		case numAfterDigit:
 			switch {
@@ -451,17 +457,17 @@ outerLoop:
 			case r >= '0' && r <= '9':
 				state = numAfterExpDigit
 			default:
-				return MakeStaticErrorPoint(
+				return l.makeStaticErrorPoint(
 					fmt.Sprintf("Couldn't lex number, junk after 'E': %v", strconv.QuoteRuneToASCII(r)),
-					l.fileName, l.prevLocation())
+					l.prevLocation())
 			}
 		case numAfterExpSign:
 			if r >= '0' && r <= '9' {
 				state = numAfterExpDigit
 			} else {
-				return MakeStaticErrorPoint(
+				return l.makeStaticErrorPoint(
 					fmt.Sprintf("Couldn't lex number, junk after exponent sign: %v", strconv.QuoteRuneToASCII(r)),
-					l.fileName, l.prevLocation())
+					l.prevLocation())
 			}
 
 		case numAfterExpDigit:
@@ -558,8 +564,8 @@ func (l *lexer) lexSymbol() error {
 		l.resetTokenStart() // Throw out the leading /*
 		for r = l.next(); ; r = l.next() {
 			if r == lexEOF {
-				return MakeStaticErrorPoint("Multi-line comment has no terminating */",
-					l.fileName, commentStartLoc)
+				return l.makeStaticErrorPoint("Multi-line comment has no terminating */",
+					commentStartLoc)
 			}
 			if r == '*' && l.peek() == '/' {
 				commentData := l.input[l.tokenStart : l.pos.byteNo-1] // Don't include trailing */
@@ -584,8 +590,8 @@ func (l *lexer) lexSymbol() error {
 		numWhiteSpace := checkWhitespace(l.input[l.pos.byteNo:], l.input[l.pos.byteNo:])
 		stringBlockIndent := l.input[l.pos.byteNo : l.pos.byteNo+numWhiteSpace]
 		if numWhiteSpace == 0 {
-			return MakeStaticErrorPoint("Text block's first line must start with whitespace",
-				l.fileName, commentStartLoc)
+			return l.makeStaticErrorPoint("Text block's first line must start with whitespace",
+				commentStartLoc)
 		}
 
 		for {
@@ -595,8 +601,7 @@ func (l *lexer) lexSymbol() error {
 			l.acceptN(numWhiteSpace)
 			for r = l.next(); r != '\n'; r = l.next() {
 				if r == lexEOF {
-					return MakeStaticErrorPoint("Unexpected EOF",
-						l.fileName, commentStartLoc)
+					return l.makeStaticErrorPoint("Unexpected EOF", commentStartLoc)
 				}
 				cb.WriteRune(r)
 			}
@@ -618,8 +623,7 @@ func (l *lexer) lexSymbol() error {
 				}
 				l.backup()
 				if !strings.HasPrefix(l.input[l.pos.byteNo:], "|||") {
-					return MakeStaticErrorPoint("Text block not terminated with |||",
-						l.fileName, commentStartLoc)
+					return l.makeStaticErrorPoint("Text block not terminated with |||", commentStartLoc)
 				}
 				l.acceptN(3) // Skip '|||'
 				l.emitFullToken(tokenStringBlock, cb.String(),
@@ -710,7 +714,7 @@ func Lex(fn string, input string) (tokens, error) {
 			l.resetTokenStart() // Don't include the quotes in the token data
 			for r = l.next(); ; r = l.next() {
 				if r == lexEOF {
-					return nil, MakeStaticErrorPoint("Unterminated String", l.fileName, stringStartLoc)
+					return nil, l.makeStaticErrorPoint("Unterminated String", stringStartLoc)
 				}
 				if r == '"' {
 					l.backup()
@@ -728,7 +732,7 @@ func Lex(fn string, input string) (tokens, error) {
 			l.resetTokenStart() // Don't include the quotes in the token data
 			for r = l.next(); ; r = l.next() {
 				if r == lexEOF {
-					return nil, MakeStaticErrorPoint("Unterminated String", l.fileName, stringStartLoc)
+					return nil, l.makeStaticErrorPoint("Unterminated String", stringStartLoc)
 				}
 				if r == '\'' {
 					l.backup()
@@ -757,15 +761,14 @@ func Lex(fn string, input string) (tokens, error) {
 			} else if quot == '\'' {
 				kind = tokenVerbatimStringSingle
 			} else {
-				return nil, MakeStaticErrorPoint(
+				return nil, l.makeStaticErrorPoint(
 					fmt.Sprintf("Couldn't lex verbatim string, junk after '@': %v", quot),
-					l.fileName,
 					stringStartLoc,
 				)
 			}
 			for r = l.next(); ; r = l.next() {
 				if r == lexEOF {
-					return nil, MakeStaticErrorPoint("Unterminated String", l.fileName, stringStartLoc)
+					return nil, l.makeStaticErrorPoint("Unterminated String", stringStartLoc)
 				} else if r == quot {
 					if l.peek() == quot {
 						l.next()
@@ -799,9 +802,9 @@ func Lex(fn string, input string) (tokens, error) {
 					return nil, err
 				}
 			} else {
-				return nil, MakeStaticErrorPoint(
+				return nil, l.makeStaticErrorPoint(
 					fmt.Sprintf("Could not lex the character %s", strconv.QuoteRuneToASCII(r)),
-					l.fileName, l.prevLocation())
+					l.prevLocation())
 			}
 
 		}
diff --git a/vendor/github.com/google/go-jsonnet/parser/parser.go b/vendor/github.com/google/go-jsonnet/parser/parser.go
index 720be3216e20b3d3a32cf32779f398d2ee6f1e43..538d9d30d6fb89d856a82b6b80fee61ce98dbafc 100644
--- a/vendor/github.com/google/go-jsonnet/parser/parser.go
+++ b/vendor/github.com/google/go-jsonnet/parser/parser.go
@@ -61,11 +61,11 @@ func makeUnexpectedError(t *token, while string) error {
 }
 
 func locFromTokens(begin, end *token) ast.LocationRange {
-	return ast.MakeLocationRange(begin.loc.FileName, begin.loc.Begin, end.loc.End)
+	return ast.LocationRangeBetween(&begin.loc, &end.loc)
 }
 
 func locFromTokenAST(begin *token, end ast.Node) ast.LocationRange {
-	return ast.MakeLocationRange(begin.loc.FileName, begin.loc.Begin, end.Loc().End)
+	return ast.LocationRangeBetween(&begin.loc, end.Loc())
 }
 
 // ---------------------------------------------------------------------------
@@ -115,54 +115,99 @@ func (p *parser) peek() *token {
 	return &p.t[p.currT]
 }
 
-func (p *parser) parseIdentifierList(elementKind string) (ast.Identifiers, bool, error) {
-	_, exprs, gotComma, err := p.parseCommaList(tokenParenR, elementKind)
-	if err != nil {
-		return ast.Identifiers{}, false, err
+func (p *parser) doublePeek() *token {
+	return &p.t[p.currT+1]
+}
+
+// in some cases it's convenient to parse something as an expression, and later
+// decide that it should be just an identifer
+func astVarToIdentifier(node ast.Node) (*ast.Identifier, bool) {
+	v, ok := node.(*ast.Var)
+	if ok {
+		return &v.Id, true
 	}
-	var ids ast.Identifiers
-	for _, n := range exprs {
-		v, ok := n.(*ast.Var)
-		if !ok {
-			return ast.Identifiers{}, false, MakeStaticError(fmt.Sprintf("Expected simple identifier but got a complex expression."), *n.Loc())
-		}
-		ids = append(ids, v.Id)
+	return nil, false
+}
+
+func (p *parser) parseArgument() (*ast.Identifier, ast.Node, error) {
+	var id *ast.Identifier
+	if p.peek().kind == tokenIdentifier && p.doublePeek().kind == tokenOperator && p.doublePeek().data == "=" {
+		ident := p.pop()
+		var tmpID = ast.Identifier(ident.data)
+		id = &tmpID
+		p.pop() // "=" token
+	}
+	expr, err := p.parse(maxPrecedence)
+	if err != nil {
+		return nil, nil, err
 	}
-	return ids, gotComma, nil
+	return id, expr, nil
 }
 
-func (p *parser) parseCommaList(end tokenKind, elementKind string) (*token, ast.Nodes, bool, error) {
-	var exprs ast.Nodes
+// TODO(sbarzowski) - this returned bool is weird
+// TODO(sbarzowski) - name - it's also used for parameters
+func (p *parser) parseArguments(elementKind string) (*token, *ast.Arguments, bool, error) {
+	args := &ast.Arguments{}
 	gotComma := false
+	namedArgumentAdded := false
 	first := true
 	for {
 		next := p.peek()
-		if !first && !gotComma {
-			if next.kind == tokenComma {
-				p.pop()
-				next = p.peek()
-				gotComma = true
-			}
-		}
-		if next.kind == end {
+
+		if next.kind == tokenParenR {
 			// gotComma can be true or false here.
-			return p.pop(), exprs, gotComma, nil
+			return p.pop(), args, gotComma, nil
 		}
 
 		if !first && !gotComma {
-			return nil, nil, false, MakeStaticError(fmt.Sprintf("Expected a comma before next %s.", elementKind), next.loc)
+			return nil, nil, false, MakeStaticError(fmt.Sprintf("Expected a comma before next %s, got %s.", elementKind, next), next.loc)
 		}
 
-		expr, err := p.parse(maxPrecedence)
+		id, expr, err := p.parseArgument()
 		if err != nil {
 			return nil, nil, false, err
 		}
-		exprs = append(exprs, expr)
-		gotComma = false
+		if id == nil {
+			if namedArgumentAdded {
+				return nil, nil, false, MakeStaticError("Positional argument after a named argument is not allowed", next.loc)
+			}
+			args.Positional = append(args.Positional, expr)
+		} else {
+			namedArgumentAdded = true
+			args.Named = append(args.Named, ast.NamedArgument{Name: *id, Arg: expr})
+		}
+
+		if p.peek().kind == tokenComma {
+			p.pop()
+			gotComma = true
+		} else {
+			gotComma = false
+		}
+
 		first = false
 	}
 }
 
+// TODO(sbarzowski) - this returned bool is weird
+func (p *parser) parseParameters(elementKind string) (*ast.Parameters, bool, error) {
+	_, args, trailingComma, err := p.parseArguments(elementKind)
+	if err != nil {
+		return nil, false, err
+	}
+	var params ast.Parameters
+	for _, arg := range args.Positional {
+		id, ok := astVarToIdentifier(arg)
+		if !ok {
+			return nil, false, MakeStaticError(fmt.Sprintf("Expected simple identifier but got a complex expression."), *arg.Loc())
+		}
+		params.Required = append(params.Required, *id)
+	}
+	for _, arg := range args.Named {
+		params.Optional = append(params.Optional, ast.NamedParameter{Name: arg.Name, DefaultArg: arg.Arg})
+	}
+	return &params, trailingComma, nil
+}
+
 func (p *parser) parseBind(binds *ast.LocalBinds) error {
 	varID, err := p.popExpect(tokenIdentifier)
 	if err != nil {
@@ -174,36 +219,36 @@ func (p *parser) parseBind(binds *ast.LocalBinds) error {
 		}
 	}
 
+	var fun *ast.Function
 	if p.peek().kind == tokenParenL {
 		p.pop()
-		params, gotComma, err := p.parseIdentifierList("function parameter")
+		params, gotComma, err := p.parseParameters("function parameter")
 		if err != nil {
 			return err
 		}
-		_, err = p.popExpectOp("=")
-		if err != nil {
-			return err
-		}
-		body, err := p.parse(maxPrecedence)
-		if err != nil {
-			return err
+		fun = &ast.Function{
+			Parameters:    *params,
+			TrailingComma: gotComma,
 		}
+	}
+
+	_, err = p.popExpectOp("=")
+	if err != nil {
+		return err
+	}
+	body, err := p.parse(maxPrecedence)
+	if err != nil {
+		return err
+	}
+
+	if fun != nil {
+		fun.Body = body
 		*binds = append(*binds, ast.LocalBind{
-			Variable:      ast.Identifier(varID.data),
-			Body:          body,
-			FunctionSugar: true,
-			Params:        params,
-			TrailingComma: gotComma,
+			Variable: ast.Identifier(varID.data),
+			Body:     body,
+			Fun:      fun,
 		})
 	} else {
-		_, err = p.popExpectOp("=")
-		if err != nil {
-			return err
-		}
-		body, err := p.parse(maxPrecedence)
-		if err != nil {
-			return err
-		}
 		*binds = append(*binds, ast.LocalBind{
 			Variable: ast.Identifier(varID.data),
 			Body:     body,
@@ -254,6 +299,7 @@ func (p *parser) parseObjectAssignmentOp() (plusSugar bool, hide ast.ObjectField
 // +gen set
 type LiteralField string
 
+// Parse object or object comprehension without leading brace
 func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 	var fields ast.ObjectFields
 	literalFields := make(literalFieldSet)
@@ -308,7 +354,7 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 			if field.Kind != ast.ObjectFieldExpr {
 				return nil, nil, MakeStaticError("Object comprehensions can only have [e] fields.", next.loc)
 			}
-			specs, last, err := p.parseComprehensionSpecs(tokenBraceR)
+			spec, last, err := p.parseComprehensionSpecs(tokenBraceR)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -316,7 +362,7 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				NodeBase:      ast.NewNodeBaseLoc(locFromTokens(tok, last)),
 				Fields:        fields,
 				TrailingComma: gotComma,
-				Specs:         *specs,
+				Spec:          *spec,
 			}, last, nil
 		}
 
@@ -326,7 +372,8 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 		first = false
 
 		switch next.kind {
-		case tokenBracketL, tokenIdentifier, tokenStringDouble, tokenStringSingle, tokenStringBlock:
+		case tokenBracketL, tokenIdentifier, tokenStringDouble, tokenStringSingle,
+			tokenStringBlock, tokenVerbatimStringDouble, tokenVerbatimStringSingle:
 			var kind ast.ObjectFieldKind
 			var expr1 ast.Node
 			var id *ast.Identifier
@@ -334,30 +381,10 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 			case tokenIdentifier:
 				kind = ast.ObjectFieldID
 				id = (*ast.Identifier)(&next.data)
-			case tokenStringDouble:
-				kind = ast.ObjectFieldStr
-				expr1 = &ast.LiteralString{
-					NodeBase: ast.NewNodeBaseLoc(next.loc),
-					Value:    next.data,
-					Kind:     ast.StringDouble,
-				}
-			case tokenStringSingle:
+			case tokenStringDouble, tokenStringSingle,
+				tokenStringBlock, tokenVerbatimStringDouble, tokenVerbatimStringSingle:
 				kind = ast.ObjectFieldStr
-				expr1 = &ast.LiteralString{
-					NodeBase: ast.NewNodeBaseLoc(next.loc),
-					Value:    next.data,
-					Kind:     ast.StringSingle,
-				}
-			case tokenStringBlock:
-				kind = ast.ObjectFieldStr
-				expr1 = &ast.LiteralString{
-					NodeBase:    ast.NewNodeBaseLoc(next.loc),
-					Value:       next.data,
-					Kind:        ast.StringBlock,
-					BlockIndent: next.stringBlockIndent,
-				}
-			// TODO(sbarzowski) are verbatim string literals allowed here?
-			// if so, maybe it's time we extracted string literal creation somewhere...
+				expr1 = tokenStringToAst(next)
 			default:
 				kind = ast.ObjectFieldExpr
 				var err error
@@ -373,11 +400,11 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 
 			isMethod := false
 			methComma := false
-			var params ast.Identifiers
+			var params *ast.Parameters
 			if p.peek().kind == tokenParenL {
 				p.pop()
 				var err error
-				params, methComma, err = p.parseIdentifierList("method parameter")
+				params, methComma, err = p.parseParameters("method parameter")
 				if err != nil {
 					return nil, nil, err
 				}
@@ -406,14 +433,24 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				return nil, nil, err
 			}
 
+			var method *ast.Function
+			if isMethod {
+				method = &ast.Function{
+					Parameters:    *params,
+					TrailingComma: methComma,
+					Body:          body,
+				}
+			}
+
 			fields = append(fields, ast.ObjectField{
 				Kind:          kind,
 				Hide:          hide,
 				SuperSugar:    plusSugar,
 				MethodSugar:   isMethod,
+				Method:        method,
 				Expr1:         expr1,
 				Id:            id,
-				Ids:           params,
+				Params:        params,
 				TrailingComma: methComma,
 				Expr2:         body,
 			})
@@ -430,13 +467,15 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				return nil, nil, MakeStaticError(fmt.Sprintf("Duplicate local var: %v", id), varID.loc)
 			}
 
+			// TODO(sbarzowski) Can we reuse regular local bind parsing here?
+
 			isMethod := false
 			funcComma := false
-			var params ast.Identifiers
+			var params *ast.Parameters
 			if p.peek().kind == tokenParenL {
 				p.pop()
 				isMethod = true
-				params, funcComma, err = p.parseIdentifierList("function parameter")
+				params, funcComma, err = p.parseParameters("function parameter")
 				if err != nil {
 					return nil, nil, err
 				}
@@ -451,6 +490,15 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				return nil, nil, err
 			}
 
+			var method *ast.Function
+			if isMethod {
+				method = &ast.Function{
+					Parameters:    *params,
+					TrailingComma: funcComma,
+					Body:          body,
+				}
+			}
+
 			binds.Add(id)
 
 			fields = append(fields, ast.ObjectField{
@@ -458,8 +506,9 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				Hide:          ast.ObjectFieldVisible,
 				SuperSugar:    false,
 				MethodSugar:   isMethod,
+				Method:        method,
 				Id:            &id,
-				Ids:           params,
+				Params:        params,
 				TrailingComma: funcComma,
 				Expr2:         body,
 			})
@@ -492,9 +541,11 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 }
 
 /* parses for x in expr for y in expr if expr for z in expr ... */
-func (p *parser) parseComprehensionSpecs(end tokenKind) (*ast.CompSpecs, *token, error) {
-	var specs ast.CompSpecs
-	for {
+func (p *parser) parseComprehensionSpecs(end tokenKind) (*ast.ForSpec, *token, error) {
+	var parseComprehensionSpecsHelper func(outer *ast.ForSpec) (*ast.ForSpec, *token, error)
+	parseComprehensionSpecsHelper = func(outer *ast.ForSpec) (*ast.ForSpec, *token, error) {
+		var ifSpecs []ast.IfSpec
+
 		varID, err := p.popExpect(tokenIdentifier)
 		if err != nil {
 			return nil, nil, err
@@ -508,11 +559,11 @@ func (p *parser) parseComprehensionSpecs(end tokenKind) (*ast.CompSpecs, *token,
 		if err != nil {
 			return nil, nil, err
 		}
-		specs = append(specs, ast.CompSpec{
-			Kind:    ast.CompFor,
-			VarName: &id,
+		forSpec := &ast.ForSpec{
+			VarName: id,
 			Expr:    arr,
-		})
+			Outer:   outer,
+		}
 
 		maybeIf := p.pop()
 		for ; maybeIf.kind == tokenIf; maybeIf = p.pop() {
@@ -520,14 +571,13 @@ func (p *parser) parseComprehensionSpecs(end tokenKind) (*ast.CompSpecs, *token,
 			if err != nil {
 				return nil, nil, err
 			}
-			specs = append(specs, ast.CompSpec{
-				Kind:    ast.CompIf,
-				VarName: nil,
-				Expr:    cond,
+			ifSpecs = append(ifSpecs, ast.IfSpec{
+				Expr: cond,
 			})
 		}
+		forSpec.Conditions = ifSpecs
 		if maybeIf.kind == end {
-			return &specs, maybeIf, nil
+			return forSpec, maybeIf, nil
 		}
 
 		if maybeIf.kind != tokenFor {
@@ -535,7 +585,9 @@ func (p *parser) parseComprehensionSpecs(end tokenKind) (*ast.CompSpecs, *token,
 				fmt.Sprintf("Expected for, if or %v after for clause, got: %v", end, maybeIf), maybeIf.loc)
 		}
 
+		return parseComprehensionSpecsHelper(forSpec)
 	}
+	return parseComprehensionSpecsHelper(nil)
 }
 
 // Assumes that the leading '[' has already been consumed and passed as tok.
@@ -564,7 +616,7 @@ func (p *parser) parseArray(tok *token) (ast.Node, error) {
 	if next.kind == tokenFor {
 		// It's a comprehension
 		p.pop()
-		specs, last, err := p.parseComprehensionSpecs(tokenBracketR)
+		spec, last, err := p.parseComprehensionSpecs(tokenBracketR)
 		if err != nil {
 			return nil, err
 		}
@@ -572,7 +624,7 @@ func (p *parser) parseArray(tok *token) (ast.Node, error) {
 			NodeBase:      ast.NewNodeBaseLoc(locFromTokens(tok, last)),
 			Body:          first,
 			TrailingComma: gotComma,
-			Specs:         *specs,
+			Spec:          *spec,
 		}, nil
 	}
 	// Not a comprehension: It can have more elements.
@@ -609,6 +661,44 @@ func (p *parser) parseArray(tok *token) (ast.Node, error) {
 	}, nil
 }
 
+func tokenStringToAst(tok *token) *ast.LiteralString {
+	switch tok.kind {
+	case tokenStringSingle:
+		return &ast.LiteralString{
+			NodeBase: ast.NewNodeBaseLoc(tok.loc),
+			Value:    tok.data,
+			Kind:     ast.StringSingle,
+		}
+	case tokenStringDouble:
+		return &ast.LiteralString{
+			NodeBase: ast.NewNodeBaseLoc(tok.loc),
+			Value:    tok.data,
+			Kind:     ast.StringDouble,
+		}
+	case tokenStringBlock:
+		return &ast.LiteralString{
+			NodeBase:    ast.NewNodeBaseLoc(tok.loc),
+			Value:       tok.data,
+			Kind:        ast.StringBlock,
+			BlockIndent: tok.stringBlockIndent,
+		}
+	case tokenVerbatimStringDouble:
+		return &ast.LiteralString{
+			NodeBase: ast.NewNodeBaseLoc(tok.loc),
+			Value:    tok.data,
+			Kind:     ast.VerbatimStringDouble,
+		}
+	case tokenVerbatimStringSingle:
+		return &ast.LiteralString{
+			NodeBase: ast.NewNodeBaseLoc(tok.loc),
+			Value:    tok.data,
+			Kind:     ast.VerbatimStringSingle,
+		}
+	default:
+		panic(fmt.Sprintf("Not a string token %#+v", tok))
+	}
+}
+
 func (p *parser) parseTerminal() (ast.Node, error) {
 	tok := p.pop()
 	switch tok.kind {
@@ -651,37 +741,9 @@ func (p *parser) parseTerminal() (ast.Node, error) {
 			Value:          num,
 			OriginalString: tok.data,
 		}, nil
-	case tokenStringSingle:
-		return &ast.LiteralString{
-			NodeBase: ast.NewNodeBaseLoc(tok.loc),
-			Value:    tok.data,
-			Kind:     ast.StringSingle,
-		}, nil
-	case tokenStringDouble:
-		return &ast.LiteralString{
-			NodeBase: ast.NewNodeBaseLoc(tok.loc),
-			Value:    tok.data,
-			Kind:     ast.StringDouble,
-		}, nil
-	case tokenStringBlock:
-		return &ast.LiteralString{
-			NodeBase:    ast.NewNodeBaseLoc(tok.loc),
-			Value:       tok.data,
-			Kind:        ast.StringDouble,
-			BlockIndent: tok.stringBlockIndent,
-		}, nil
-	case tokenVerbatimStringDouble:
-		return &ast.LiteralString{
-			NodeBase: ast.NewNodeBaseLoc(tok.loc),
-			Value:    tok.data,
-			Kind:     ast.VerbatimStringDouble,
-		}, nil
-	case tokenVerbatimStringSingle:
-		return &ast.LiteralString{
-			NodeBase: ast.NewNodeBaseLoc(tok.loc),
-			Value:    tok.data,
-			Kind:     ast.VerbatimStringSingle,
-		}, nil
+	case tokenStringDouble, tokenStringSingle,
+		tokenStringBlock, tokenVerbatimStringDouble, tokenVerbatimStringSingle:
+		return tokenStringToAst(tok), nil
 	case tokenFalse:
 		return &ast.LiteralBoolean{
 			NodeBase: ast.NewNodeBaseLoc(tok.loc),
@@ -830,7 +892,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 		p.pop()
 		next := p.pop()
 		if next.kind == tokenParenL {
-			params, gotComma, err := p.parseIdentifierList("function parameter")
+			params, gotComma, err := p.parseParameters("function parameter")
 			if err != nil {
 				return nil, err
 			}
@@ -840,7 +902,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 			}
 			return &ast.Function{
 				NodeBase:      ast.NewNodeBaseLoc(locFromTokenAST(begin, body)),
-				Parameters:    params,
+				Parameters:    *params,
 				TrailingComma: gotComma,
 				Body:          body,
 			}, nil
@@ -854,9 +916,12 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 			return nil, err
 		}
 		if lit, ok := body.(*ast.LiteralString); ok {
+			if lit.Kind == ast.StringBlock {
+				return nil, MakeStaticError("Block string literals not allowed in imports", *body.Loc())
+			}
 			return &ast.Import{
 				NodeBase: ast.NewNodeBaseLoc(locFromTokenAST(begin, body)),
-				File:     lit.Value,
+				File:     lit,
 			}, nil
 		}
 		return nil, MakeStaticError("Computed imports are not allowed", *body.Loc())
@@ -868,9 +933,12 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 			return nil, err
 		}
 		if lit, ok := body.(*ast.LiteralString); ok {
+			if lit.Kind == ast.StringBlock {
+				return nil, MakeStaticError("Block string literals not allowed in imports", *body.Loc())
+			}
 			return &ast.ImportStr{
 				NodeBase: ast.NewNodeBaseLoc(locFromTokenAST(begin, body)),
-				File:     lit.Value,
+				File:     lit,
 			}, nil
 		}
 		return nil, MakeStaticError("Computed imports are not allowed", *body.Loc())
@@ -1048,7 +1116,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 					Id:       &id,
 				}
 			case tokenParenL:
-				end, args, gotComma, err := p.parseCommaList(tokenParenR, "function argument")
+				end, args, gotComma, err := p.parseArguments("function argument")
 				if err != nil {
 					return nil, err
 				}
@@ -1060,7 +1128,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 				lhs = &ast.Apply{
 					NodeBase:      ast.NewNodeBaseLoc(locFromTokens(begin, end)),
 					Target:        lhs,
-					Arguments:     args,
+					Arguments:     *args,
 					TrailingComma: gotComma,
 					TailStrict:    tailStrict,
 				}
@@ -1111,5 +1179,7 @@ func Parse(t tokens) (ast.Node, error) {
 		return nil, MakeStaticError(fmt.Sprintf("Did not expect: %v", p.peek()), p.peek().loc)
 	}
 
+	addContext(expr, &topLevelContext, anonymous)
+
 	return expr, nil
 }
diff --git a/vendor/github.com/google/go-jsonnet/parser/static_error.go b/vendor/github.com/google/go-jsonnet/parser/static_error.go
index 9a826aeb8d67c01f4c5b0d8f9294b4fb4abedb58..c74edbbd8c40747a34adf8b54ddc57856c3c8d51 100644
--- a/vendor/github.com/google/go-jsonnet/parser/static_error.go
+++ b/vendor/github.com/google/go-jsonnet/parser/static_error.go
@@ -36,10 +36,6 @@ func MakeStaticErrorMsg(msg string) StaticError {
 	return StaticError{Msg: msg}
 }
 
-func MakeStaticErrorPoint(msg string, fn string, l ast.Location) StaticError {
-	return StaticError{Msg: msg, Loc: ast.MakeLocationRange(fn, l, l)}
-}
-
 func MakeStaticError(msg string, lr ast.LocationRange) StaticError {
 	return StaticError{Msg: msg, Loc: lr}
 }
diff --git a/vendor/github.com/google/go-jsonnet/runtime_error.go b/vendor/github.com/google/go-jsonnet/runtime_error.go
new file mode 100644
index 0000000000000000000000000000000000000000..1b14b6340b14fa6d2afb7b164d5a850808bb754d
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/runtime_error.go
@@ -0,0 +1,62 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import "github.com/google/go-jsonnet/ast"
+
+// RuntimeError is an error discovered during evaluation of the program
+type RuntimeError struct {
+	StackTrace []TraceFrame
+	Msg        string
+}
+
+func makeRuntimeError(msg string, stackTrace []TraceFrame) RuntimeError {
+	return RuntimeError{
+		Msg:        msg,
+		StackTrace: stackTrace,
+	}
+}
+
+func (err RuntimeError) Error() string {
+	return "RUNTIME ERROR: " + err.Msg
+}
+
+// The stack
+
+// TraceFrame is tracing information about a single frame of the call stack.
+// TODO(sbarzowski) the difference from TraceElement. Do we even need this?
+type TraceFrame struct {
+	Loc  ast.LocationRange
+	Name string
+}
+
+func traceElementToTraceFrame(trace *TraceElement) TraceFrame {
+	tf := TraceFrame{Loc: *trace.loc}
+	if trace.context != nil {
+		// TODO(sbarzowski) maybe it should never be nil
+		tf.Name = *trace.context
+	} else {
+		tf.Name = ""
+	}
+	return tf
+}
+
+// TODO(sbarzowski) better name
+type TraceElement struct {
+	loc     *ast.LocationRange
+	context ast.Context
+}
diff --git a/vendor/github.com/google/go-jsonnet/static_analyzer.go b/vendor/github.com/google/go-jsonnet/static_analyzer.go
new file mode 100644
index 0000000000000000000000000000000000000000..e64268a7d8825f4c6cead7289056521f3668f95d
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/static_analyzer.go
@@ -0,0 +1,154 @@
+/*
+Copyright 2016 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"fmt"
+
+	"github.com/google/go-jsonnet/ast"
+	"github.com/google/go-jsonnet/parser"
+)
+
+type analysisState struct {
+	err      error
+	freeVars ast.IdentifierSet
+}
+
+func visitNext(a ast.Node, inObject bool, vars ast.IdentifierSet, state *analysisState) {
+	if state.err != nil {
+		return
+	}
+	state.err = analyzeVisit(a, inObject, vars)
+	state.freeVars.Append(a.FreeVariables())
+}
+
+func analyzeVisit(a ast.Node, inObject bool, vars ast.IdentifierSet) error {
+	s := &analysisState{freeVars: ast.NewIdentifierSet()}
+
+	// TODO(sbarzowski) Test somehow that we're visiting all the nodes
+	switch a := a.(type) {
+	case *ast.Apply:
+		visitNext(a.Target, inObject, vars, s)
+		for _, arg := range a.Arguments.Positional {
+			visitNext(arg, inObject, vars, s)
+		}
+		for _, arg := range a.Arguments.Named {
+			visitNext(arg.Arg, inObject, vars, s)
+		}
+	case *ast.Array:
+		for _, elem := range a.Elements {
+			visitNext(elem, inObject, vars, s)
+		}
+	case *ast.Binary:
+		visitNext(a.Left, inObject, vars, s)
+		visitNext(a.Right, inObject, vars, s)
+	case *ast.Conditional:
+		visitNext(a.Cond, inObject, vars, s)
+		visitNext(a.BranchTrue, inObject, vars, s)
+		visitNext(a.BranchFalse, inObject, vars, s)
+	case *ast.Error:
+		visitNext(a.Expr, inObject, vars, s)
+	case *ast.Function:
+		newVars := vars.Clone()
+		for _, param := range a.Parameters.Required {
+			newVars.Add(param)
+		}
+		for _, param := range a.Parameters.Optional {
+			newVars.Add(param.Name)
+		}
+		for _, param := range a.Parameters.Optional {
+			visitNext(param.DefaultArg, inObject, newVars, s)
+		}
+		visitNext(a.Body, inObject, newVars, s)
+		// Parameters are free inside the body, but not visible here or outside
+		for _, param := range a.Parameters.Required {
+			s.freeVars.Remove(param)
+		}
+		for _, param := range a.Parameters.Optional {
+			s.freeVars.Remove(param.Name)
+		}
+	case *ast.Import:
+		//nothing to do here
+	case *ast.ImportStr:
+		//nothing to do here
+	case *ast.InSuper:
+		if !inObject {
+			return parser.MakeStaticError("Can't use super outside of an object.", *a.Loc())
+		}
+		visitNext(a.Index, inObject, vars, s)
+	case *ast.SuperIndex:
+		if !inObject {
+			return parser.MakeStaticError("Can't use super outside of an object.", *a.Loc())
+		}
+		visitNext(a.Index, inObject, vars, s)
+	case *ast.Index:
+		visitNext(a.Target, inObject, vars, s)
+		visitNext(a.Index, inObject, vars, s)
+	case *ast.Local:
+		newVars := vars.Clone()
+		for _, bind := range a.Binds {
+			newVars.Add(bind.Variable)
+		}
+		// Binds in local can be mutually or even self recursive
+		for _, bind := range a.Binds {
+			visitNext(bind.Body, inObject, newVars, s)
+		}
+		visitNext(a.Body, inObject, newVars, s)
+
+		// Any usage of newly created variables inside are considered free
+		// but they are not here or outside
+		for _, bind := range a.Binds {
+			s.freeVars.Remove(bind.Variable)
+		}
+	case *ast.LiteralBoolean:
+		//nothing to do here
+	case *ast.LiteralNull:
+		//nothing to do here
+	case *ast.LiteralNumber:
+		//nothing to do here
+	case *ast.LiteralString:
+		//nothing to do here
+	case *ast.DesugaredObject:
+		for _, field := range a.Fields {
+			// Field names are calculated *outside* of the object
+			visitNext(field.Name, inObject, vars, s)
+			visitNext(field.Body, true, vars, s)
+		}
+		for _, assert := range a.Asserts {
+			visitNext(assert, true, vars, s)
+		}
+	case *ast.Self:
+		if !inObject {
+			return parser.MakeStaticError("Can't use self outside of an object.", *a.Loc())
+		}
+	case *ast.Unary:
+		visitNext(a.Expr, inObject, vars, s)
+	case *ast.Var:
+		if !vars.Contains(a.Id) {
+			return parser.MakeStaticError(fmt.Sprintf("Unknown variable: %v", a.Id), *a.Loc())
+		}
+		s.freeVars.Add(a.Id)
+	default:
+		panic(fmt.Sprintf("Unexpected node %#v", a))
+	}
+	a.SetFreeVariables(s.freeVars.ToSlice())
+	return s.err
+}
+
+func analyze(node ast.Node) error {
+	return analyzeVisit(node, false, ast.NewIdentifierSet("std"))
+}
diff --git a/vendor/github.com/google/go-jsonnet/std.go b/vendor/github.com/google/go-jsonnet/std.go
new file mode 100644
index 0000000000000000000000000000000000000000..b75e910a715994cdc0859a7c06deea9543663bda
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/std.go
@@ -0,0 +1,342 @@
+// This file is automatically generated using github.com/mjibson/esc.
+
+package jsonnet
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/base64"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+	"sync"
+	"time"
+)
+
+type _escLocalFS struct{}
+
+var _escLocal _escLocalFS
+
+type _escStaticFS struct{}
+
+var _escStatic _escStaticFS
+
+type _escDirectory struct {
+	fs   http.FileSystem
+	name string
+}
+
+type _escFile struct {
+	compressed string
+	size       int64
+	modtime    int64
+	local      string
+	isDir      bool
+
+	once sync.Once
+	data []byte
+	name string
+}
+
+func (_escLocalFS) Open(name string) (http.File, error) {
+	f, present := _escData[path.Clean(name)]
+	if !present {
+		return nil, os.ErrNotExist
+	}
+	return os.Open(f.local)
+}
+
+func (_escStaticFS) prepare(name string) (*_escFile, error) {
+	f, present := _escData[path.Clean(name)]
+	if !present {
+		return nil, os.ErrNotExist
+	}
+	var err error
+	f.once.Do(func() {
+		f.name = path.Base(name)
+		if f.size == 0 {
+			return
+		}
+		var gr *gzip.Reader
+		b64 := base64.NewDecoder(base64.StdEncoding, bytes.NewBufferString(f.compressed))
+		gr, err = gzip.NewReader(b64)
+		if err != nil {
+			return
+		}
+		f.data, err = ioutil.ReadAll(gr)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
+func (fs _escStaticFS) Open(name string) (http.File, error) {
+	f, err := fs.prepare(name)
+	if err != nil {
+		return nil, err
+	}
+	return f.File()
+}
+
+func (dir _escDirectory) Open(name string) (http.File, error) {
+	return dir.fs.Open(dir.name + name)
+}
+
+func (f *_escFile) File() (http.File, error) {
+	type httpFile struct {
+		*bytes.Reader
+		*_escFile
+	}
+	return &httpFile{
+		Reader:   bytes.NewReader(f.data),
+		_escFile: f,
+	}, nil
+}
+
+func (f *_escFile) Close() error {
+	return nil
+}
+
+func (f *_escFile) Readdir(count int) ([]os.FileInfo, error) {
+	return nil, nil
+}
+
+func (f *_escFile) Stat() (os.FileInfo, error) {
+	return f, nil
+}
+
+func (f *_escFile) Name() string {
+	return f.name
+}
+
+func (f *_escFile) Size() int64 {
+	return f.size
+}
+
+func (f *_escFile) Mode() os.FileMode {
+	return 0
+}
+
+func (f *_escFile) ModTime() time.Time {
+	return time.Unix(f.modtime, 0)
+}
+
+func (f *_escFile) IsDir() bool {
+	return f.isDir
+}
+
+func (f *_escFile) Sys() interface{} {
+	return f
+}
+
+// FS returns a http.Filesystem for the embedded assets. If useLocal is true,
+// the filesystem's contents are instead used.
+func FS(useLocal bool) http.FileSystem {
+	if useLocal {
+		return _escLocal
+	}
+	return _escStatic
+}
+
+// Dir returns a http.Filesystem for the embedded assets on a given prefix dir.
+// If useLocal is true, the filesystem's contents are instead used.
+func Dir(useLocal bool, name string) http.FileSystem {
+	if useLocal {
+		return _escDirectory{fs: _escLocal, name: name}
+	}
+	return _escDirectory{fs: _escStatic, name: name}
+}
+
+// FSByte returns the named file from the embedded assets. If useLocal is
+// true, the filesystem's contents are instead used.
+func FSByte(useLocal bool, name string) ([]byte, error) {
+	if useLocal {
+		f, err := _escLocal.Open(name)
+		if err != nil {
+			return nil, err
+		}
+		b, err := ioutil.ReadAll(f)
+		_ = f.Close()
+		return b, err
+	}
+	f, err := _escStatic.prepare(name)
+	if err != nil {
+		return nil, err
+	}
+	return f.data, nil
+}
+
+// FSMustByte is the same as FSByte, but panics if name is not present.
+func FSMustByte(useLocal bool, name string) []byte {
+	b, err := FSByte(useLocal, name)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+// FSString is the string version of FSByte.
+func FSString(useLocal bool, name string) (string, error) {
+	b, err := FSByte(useLocal, name)
+	return string(b), err
+}
+
+// FSMustString is the string version of FSMustByte.
+func FSMustString(useLocal bool, name string) string {
+	return string(FSMustByte(useLocal, name))
+}
+
+var _escData = map[string]*_escFile{
+
+	"/std/std.jsonnet": {
+		local:   "std/std.jsonnet",
+		size:    41755,
+		modtime: 1502146172,
+		compressed: `
+H4sIAAAAAAAA/+x9/XPbNrbo7/4rTvnWqRTTsqwk3taNM5Mm6W72tsneJt3dPlmjgUhQgk2BLADJcpv8
+72/wwW+ApOzk7ebO1XRSWQTOOTjfAA7Ak4cHL5L0lpHlSsBkfPoE/pIkyxjDaxqM4Hkcg3rEgWGO2RaH
+o4ODH0mAKcchbGiIGYgVhucpClYYzBMf/oEZJwmFyWgMA9nAM4+84XcHt8kG1ugWaCJgwzGIFeEQkRgD
+3gU4FUAoBMk6jQmiAYYbIlYKiQExOvjVAEgWAhEKCIIkvYUkKrcCJA4OAABWQqTnJyc3NzcjpKgcJWx5
+EutW/OTH1y9evXn36ngyGh8c/EJjzOVYf9sQhkNY3AJK05gEaBFjiNENJAzQkmEcgkgknTeMCEKXPvAk
+EjeI4YOQcMHIYiMqDMqoIhzKDRIKiIL3/B28fufB98/fvX7nH/zz9fu/vv3lPfzz+c8/P3/z/vWrd/D2
+Z3jx9s3L1+9fv33zDt7+AM/f/Ar/9frNSx8wESvMAO9SJmlPGBDJOimpdxhXkEeJJoanOCARCSBGdLlB
+SwzLZIsZJXQJKWZrwqXwOCAaHsRkTQQS6u/GcEYHD08ODk4ewnspQsLVs7/xhFIsgAtEQ8RCiMmCIXbr
+AxIQY8SFapYiJrgUGpF/IwGIYcVOgankrAEzOoCHByAxYIZVG56sMVAkyBbDGotVEnJAHG5wHPtwsyLB
+SjULcUQoDiUoiY5QgVnKsMBMjgtQGGohSu2TCKQCjgBeCzkOireYAcUB5hyxWyXsdZowOapwdKVJ8yXp
+hANeL7CCRqiCV0MmJHSpzyTGx4Kssca/EckaCRKgOL41wDMQKI4hUVLNeJmyZMnQmktunBz8oTU7TgIU
+S4LgAjiOI1//LJJ3ghG6HKDh+bn6RX5IpEgXtykeoCFcXIDHVTNPUiyNCMccg+fBESADiW8WXLABF8yH
+iCVrH2JMXUC5YEP4qgY2byk/mLGEgaehQkQYF1IL0Frxia+STRzCAgMCDcKHZSJAElRBksNUBJdJkDRq
+GuhmvcCskwaOg4SGDiI0DAsRCo2bCsmjfYgQK8L2pkEiaZAQYwpPYXx3hEuGkVAmjij8jllSYI5LICW+
+CnxlFAmhA8/z1R9rdI2fM4ZuJaE+RBsaSBcyIEMp2ymBI6VQs+EwUzUh3cE/iVgNkA8Li5LFmC7l0yE8
+Lf+9GDaHG6EygVZqjWojH8Z+FZyyjYUhC9Pw30JUFfZxFXYbwdpyXqwQ48pYSiRX5VICIdtZZDTLZJMi
+xvFrKuoAtf9BYfiSLIkYoOWS4SUS2IdQ/jCEi8oISaR/Vyr64YP54xl82+RVobMDL8OuNFEPz3j5MMFc
+JRFrJIIVMLzEO5iOj7+dHXnDqv7XuS0/p2N4CDnRcKQJ+q42PJGo0Wlu1kY0lUwMkhCnCaFiEKwQy4RV
+/OqNvaGKvPKxjEZK0jUxzb6rahabjmfKRx9b3MexhBAlcRgPMub7FTqnp+ezoQ/jYbu6tYFQ3TOdSmMi
+dBQI7u/95eglwM8RAIJ9aWgNAE4iAjsJxpw0Eaf3wL5CWwwaGpxW8ec4OjyJhP+jTN2M3Hw4Pq3Is/pw
+jXbqV/7p5KsQ/CcIWRPyb5V0Owl7i7vCjkJ0/ZKOKk13Sj4KlG4tNMFhs9M6FuKYrH0gPiDGfNjWXWnR
+JZDZrIo/3zlakAlcgEwhTpstSAQEnl1ALbzZQ4z8IMbgCKbbWTMAGU4H0hEr+uHBAygGL38+PpWRrByt
+GZO5QEkobsx13kz8ghofPG8IApFY6mYgrNTtA9aHLRxBUIZZ5V7eL1A50VSTYFwGQ3SpE18ZJtxZhUjg
+WGV2UjrVnCLL+XIvJKfgA0JDvJOzax/UV1+mXDLBwWkz1SB0i1hNcU5OIE6SVD8jiAq9XhDiCG1iwfX8
+HYeVPn801SYj47z46ttbnVu5LvVOPpVKQTdxrCdVY2tbrVhqtE2x0tCJANOwCr6kdznVQzdKydnGU8lp
+J0b5sIry1A1eNm7C1/Sd22ltNpf+5bzwNK6mHyv5kpL9SPPfJJf6J8mxyg9qQC1TpIEnnd30kJ+r/2aw
+2AigMkEkW1zRUDmHl9C4WmyQWSjfpHoS79l4dAjTEpl+QaBfIm1m8/NaBB0kH3JFqmq93nDRmM2NPTjU
+ZuUOJQW3KxH2wQNnEySt3hlsBjraSEMHFAQ4lfaY5fAJA0RBAfAV7ctEnMMh13Q20HWGmsWGxOFAIfMh
+2DSSdaMrwYbJ+FDox4cP1d9MIHa6bYWhvzvWZFkfQVl75XAbqzLObjkhcFTWfsmpabBhzWDWSWcd6tQG
+dtY02OwjeXhUUmVrQ3f00Wxq5wZ4ntZZGZtK5GURJUg2VAxUrNsNz8+rOUA4ikgsMBvkMWk7hK3EsVPx
+MV+JWCeha7ZfXjzL8qyycSyqjxoSVLEyCTdxojG4LdGyQmeZvrE1EhZItrTvbYoZEgmDQwgQle5qgWHD
+9RK0RMmrKR4awhF4ystVfl+o30dexiyUKoZqFjo4Jhtod5HxvsNjrFFanjjkDi3rbluTkzjaGMpYxWOV
+xZY/65hSFMSVM/mcOgUZTtyTCaVl7fM26/qM7FfNpeR3+fOUFCtoav2N47QhiiITV6ZBfM1bH9iGUkKX
+lnWaegqtOGR1SAZGY7VFQtEEVvKHRv+CLJMx1khzZMAZCq0l/SCjmOMcMhwZ8lpR7A+U49QK+ju7L6lp
+pWvSJmXbOoPVUdSqcW6b4DjtcDP5cMc+CLbBakrQA6BrOE1401m371Kjdy8klPIJBxskXcZKYkIxH9Qs
+pFi+vqRePgnzvHwF1LhaNT3aolitkuS9T9o+pVbwd8S43pBbE0qO8823Sqs2WPWlSXY7V6uj8zVKU0KX
+82t8q4kkPYzaPS82fH/PNjRAAodm/BAkIR553VbSPZHPptXeoCXRMWASyjdrrMd15Vg6KMG92mv6f4ch
+dw7fzYorCytq5AfKHwx75H+gUp4yc7RP0vP89tF2kS0/fwA5z2Gew7Y86XLSYPyi5zUJcCJViIhCogLF
+x+/cmh5EMVpyh5LvoTB7K8qeCuIcbD+FyO3j/3Qogl0B/gAUi3PlYuFjy4pAjmZ8RzS/Y5bsg8e2ndEH
+T4yjvcYDd8SziBG93gfR0R0RcbKk3XicYLVt2u2yao9+pgwmVdESM39otpo/zNjNX5pA9Qd8HLZYZERw
+HM5vSKhNyBV7njZMTaXgWYboPXQwUjuH3AvJdh97R6C+oeNOYeMOIaNVpv1DRW+zBacGPoTTMRyVtwht
+tBaYTu+L6bQvpsl9MU36Ynp0X0yP+mJ6fF9Mj/tienJfTE/6Yjq7L6azvpj+fF9Mf+6L6Zv7YvqmL6Zv
+74vp23ZMrYDbokcDMfFh3Ob/U4YDwklCv7CZx6hFAm3Rze7L7pTcnpzA6yVNGA59xSYBeEe44CMnszUD
+5+skJBHB7Atj+cpTq+3qe1z6/mOLKBS/+7ObNDTVzBsSup1nxQVfEMvCEptI6fumhWX1lCn0fAhQyvN0
+zsrOAmeyB+xkT9i7PWDv9oT9rzvB1jl4B2i8B2i8J9mv7gS7F9nRHqCjPcn+4U6we5HdtvtVB73ck+y/
+3Al2L7KDPUAHe5LN94DN94R9uAfsw16w21ZQfqEMB8mSEo5DmWlszVERvfPvwREE3x0cNNZNQyCUCIJi
+OPSBJjdqHZVhLurBMvP34X+Qq19f41u4aF+wdVU76RWvSu/yIpgEPXL3jm4qPRvpjAbVAkCmdxUQtXwv
+umnpHGMqc5VKf2sKI4G2wAn0frA9lhskls7NOh/5Ieca3ojYd7OlaM8dfeVHcvxc833bsh+uGHueMbil
+ZXRzLrnY0kJy51zzqA2jtiA9trZ2ynx1M/nd3vJj8+da6qq3M1BmEWYbZhAkVCCitsNoQjEkDNYJw3CY
+NRRoyYduq+X5tCPZCGslx14GnGwEHEGzKOK+iVmb09RgWElhw/LyuEVTISuzL7OAjTQTDP3yB/n0HrWB
+TS5rz55xulkhWBOT6loZlwFUVAxWnXfnptgPRilWGLYo3mDeYzusooa/cBxtYtgIEhNBMG8oVhgSuhzc
++MDt+wVos5NPXdsEN/DUWn2Vfbb92a8wwXG2ScOHzQrMm4yHpRE+D0PgYI6WxTgSkKgzAsATfXKOCJ7V
+DxNenLK7aRpZOJf9tchsHMm5VT1zog8E8KHaVGUt1OlzpPcgTwFw0yfBHnVRWaXvZ6xOLSKqTuUtMYMB
+Hi1HPoQ4IGsUSweVBALFDZ/EVM85oWJA53Mf1oTOgxViXH9Vx0W4WTfXC+Y+MBSSnV5ll5EyIju70tE5
+aAeGFlxCr6lCoZnUoZbUURSYfUoU7KegqrQoThI2oHCixzOUgh9QODR/2mgNVZpgqgFM//mwIFItVqu8
+s4ZkPrTCo3gJF0Dnc3gKY1uD31O4KEQCxzCQXMFLOUdWIlGV2WRJTeGqRj62Ivs9nRhxrNFu8HtaFrBr
+tBPlBo1BhTjwJRRfDrPWI6NLc+HYK+omcuK8o+JXTbv+GbzsVKaUgETapduEwgrvkNFth0av8K6/RqMw
+nEtl2qnEnwgUO/wo3awxQ7EMD9OxL53cxIdHPjz24YkPZz782YdvfPjWXZyoPkcqxhpMmg9T77nng/e9
+/OeF/Oel/OeV/OcHrwOcLhj0kGy8kP/ImZdaElGTaS/yZlb1+9z26e2xZ9w0y9MzZZMZy6fSNk/PrCNZ
+4d2XYZguOWoAuRrqXpNPas4rvJM9LHgGDWX0xv/KrHK884a5gbrV8KjwEyu8+/x+Qo6mkbnJhC6dC4ZI
+LCeecoi2I421YzuNyTMU+7mfSLnNeUezDdy1o1lQJvOoO+ycl87ZZomrLSnP8dQnGceqqcUJR3GChLpB
+ISFU3WGRJRhy3mN3xKrPPMSBdsc6ZqOw5oEx5RuG56nwIZOfnjHfI7W4WSUxNu1ye7dGukTMOfkdax+i
+VwOk63jwAL7KCTOnXbQSnjqdQjY+ONaAjnPoti4y17uoJWFwIof3UJMvLUkJsMKt07FJocsQK6RbFUxn
+luqUTWVQ3ii3rb7zx4ihoMLaAZ3DsaZ5CA/VgzS5GUhKtRiPYDx6YpkWkiiXuHSaCvCzNsMrCJg32Cd/
+1QgV00ydh/mflWtV3khOKA59ldNkTiE1PUtGgXGP2Z/9vUJjmuG0Mh4QTIW6zqTL0HhA9jc0tUTSYm54
+lyYUU1GRuPIayXJQNsOhqg3Xv5+O7cGVb6LIBCKJ16jgq0wFcXuYKQk7o0plYIW0ddGtVdhmpRJRQThH
+JsSfVJQ1A9oSdEsmXvacmyiqdWp4wAyziY99PeCR4pk9LdYrCvpAoDprtCCCIXZbWcStKYx+pJdstij2
+VSMfohuNcJ6wOd3Esbv6MFuuVcD1XzZ2RalZWTWuKQMMX5WP21WeKB04swEjd4PlTt+k/umFSylQ5ezN
+32r9QcGLbqxQZFc19OIMjyOmq/rs7LKaLYqbdzZYgIUOYOU6dAmr/TB0jkQv75tFqPzeJ90PkAB36a+a
+qUi3aCk4bwwG2nxdyWyVxsmoRrSfNkw3xmD+qsS5Pjxzbeh+wTwzulosclSUFsWiNrfxPHtouxvvv6mu
+8PSRgWvj+wuWQWk1YQ/eFSJyb1GYj2YhSnkvDrs2u798DhdBMudzhcFdfDTcdEjBJAU6IPXitKsa4n8K
+p2We+Bk5nav1Xkx3FUV8wUzfI4GWgNsT6BI/cohP4fixnDjlPzy7yBKv1lWGntpwZ8dWfMra0dCLOy5x
+mIm7Wu6aL3CU6OlssSJ2WqTyLfuRDUa4HdAnZkQ++voYehmKqwynYSitZ7Wzj7rMa4WYW7XtgDuP8Vev
+Esr6WS4TKn+2KN5fH4ytHwZS6jgQOITTY05+x2G2aa+uXqjdObSfKVtwGF9SORB93uEurPDzwqFrmtxQ
+U5+hCoVywTvmf6muHKpWKBTTQYbUrbF637llIsjniLGB+mbu0iH28ySWygTVy1GboI6dPO130BpKx9Df
+J4mcqN9mO+YiMdQ2hKjgKVedi0W2uNpDstu+y15ypGbey121E8XFWkmIexpKuyB0AcOVOfaooN6lMsIU
+Wq+zya/UrOimfDKppSLoKjsn6WwR3ZzbDhm1izsnWuv/m0QApslmueond7c/6DofgBibXjnu+viofV47
+M9oZYZjrgG8PRrl8JiUBZUu6/UQk1umoQ0y60IpEpu0XIyxF7j0Epvp3sSVn+R0EdyXFJqU3umprtkVx
+x+HuyT7+MvsofZ7c41KcbqFar+2T1LUNl7cPtpbXtFWcZR/v8B5n1R1Ln1I5ohtfi09P768m7eOap/p6
+7R7Dq60qthJYKhAqyPKgZVG8c8xFSVQVYqsyP/rkcrua3H0IVxP7VYjQN3Y+MuVoRmqOAsDeeVWyuMKB
+6JlYJYurjKZkcaUSq/tmVf9ZCUtjgKVLGu6ZrUQ91FBXnrfdwFNBqP3cT7o6Ha7xbfEyhPvcgpGT0mZW
+Mt3qHE81J+szmBf6uqsNx+qSfxyHoOrftb5qZb332KKbtpHpPKVzbPV0Zu/R5aX5n3RsEuq9gra0IU3L
+XxF/HscDZQhRj8CdLK6m0aeI28A3wUpLX6df0Zcfl7MtScnKf3s0/rSRuD0K9/WvHQGttmzD26+uckVS
+2VPtsI87LscqUGhb6MJRGliOo46gF4VT2X1WojG/1CoOWXF7n68OWNkvjis1Mled+UDCRmmzDNThzl0a
+5rosrtGwhrO47i7czYrL4RQNao3UetFaDYgcnd+YO8jeJX7En4Mf971Lrxd7cjoyPhn2HO3FHnXnv+aG
+ui3zJ5QO9Le5brtG6bz7wseix173PuY49779sYSw9ar09D5EWW99bKEqR7fHvZQ9SSld2169f/Ku106m
+g0Ky5ctSy7Iv35KKOMdMvPptg2LbbalIvZOkORrBNi3vQDHh+rmCLdOYCJEYhyM1HqQuJJWsgqP8dSeq
+tsqlhn1fw6O3mOoL1xZO0hY2qpLvrDYPqJb0Mc3vSd11XSrbl9Q12lXMo5ts1KJ/i/0QV0ygG3PbxbRK
+S54ZJcleP5XJdU3o//LLwq+nDn5FMRICU3V1rLrektfvtyyim7pEVjFX2dRCGTZXV3Hm2kpJhLl4TcmA
+UNKMgYskvJ3rqzTl1yFcwNQ75HBh7u+eXvuqzfR6NlPvvrnOXnyjc58fZCJu+jaWLTlWJBr4nKI19oEX
+eKaHfKaQqEezmRxDQY9uWIe5RoTO5ZPiKEQ+I5FD9MGTTTwdmcvwCCUj+chUsk4b5KI4nhuS1dGXKvnX
+KrKOsgbT61n7zYzQwq4yoPIbg2rXlxZjPTIb6hXdKJE7rF1zinmAUqwL8v7G9QnveVP6urK4Ur2nGjZe
+ncQQ5YNgZUmLgpXKhC89x9zJu7y8tBRcl7tetnS9bO+6cHddtPd01Rh5l5dRe09bmmF60vaert1p7/KS
+tfe0zTFMT9H/mprUCLv8oit7rXqQwlN4NIEPH2AQpDLvPZ2cwYMH6sEFnD75tmXO711ebg7Hj3fKtIPU
+/j4Wa89gVVDjXXqHXKrVYcksPB+mhTLqd3E538RlM4a/34qVNoe6W7WZjA3C94ivPrs5fe2S99eX6r8e
+Mq/w8utD/vUn5uTLJI5Ng8/Kij+5WPGnP+3JhdbgqQnJXslX50B5tp3FVKUkamE8e0VB+cmrnX7mg6eo
+tfUu2hAaYuqYom59SJFY+RCYVk1WqbcfqJtt7KySj+wORvXUF8DYu6pnLX3dy9GefGTvWSyl9KjdUS8y
+bW4F2OC0LuhbjXxrL0SqA26ZYUL5bhmi30SbCTmfU6o6PHV8UKx6IXRNIqE4D4PoMjv3pV/qVH3/5TY7
+4WbvTvHNXOsTXGSapV77Ib84b4GRmZBO3S5p13ldk7QodzP1fNlhjyqy6bRE4ZE2hCmZaVtQbzWZ+aVB
+DLuIKX+ktyPS2Sm+deZxMrWSUf+oxCdvVj9tDPW3pypm9VMv5zoiWFj/x+dnfV0f5IAvlR1e66/nrVWl
+FnK0/K5L8pPf63j2lqI9vd4O7ybTjz1lWl16My68+pq1zAP8itbxO8EwWuehwjoN1g/7vEGiCRkSGt+C
+QNeY66Ujbq/n3eCWSal3fHysGVKehOgfff1+1ErgwzppwFIACvZMzkG+vqSj0eiSfp0tPmZ9TN6VuMaf
+dBiC2VhU8jVz1OwVU9O6Yze4rod+JSpnJMiZW7ueuTUrGdY0xPvjkH/MqdBs88HzDaklRA3bT9o9fWl2
+XIU8tQ1qosWRTCTZyawHXmes9NrZmvSA3bkg65lXFzUCpdcJu/WdTHmymTRXfhJ3kuS9ryRIlR6O5Mj7
+oZoYVfrYkyLvTUKx59sM4x8y0QwSGjVTwC1i3LYqY9ECCUBpd4sGKyTuJQeFrVhLOCjoWCCOzx7PBVqo
+4+be8+9fvHz1w1/++vpv//XjT2/e/v2/f373/pd//PNfv/5ftAhCHC1X5Oo6XtMk/Y1xsdne7G5/H59O
+Hj1+cvbnb749OvH8JnBCt3ABf8C0jGxKZrNzIEXUrmQ8Z4+G8NHwVPcaEJpuLLn04lbg+n5w9Z15slu/
+PDJ7W5aaRATD+qx6KDN6Ca17gqLaNe54KL/jqc+taS1bUdYERO2t9oZRmtJZ/ebJCZzBT+++hyQCYm1R
+kad53xU8gMmTyRCePYPJDI5ckCfw4x0gPxrC06fw2AXXu7iwHCOsvBPqkQ9M35LV+e4q2XzypXHTh8c5
+liP7y0DbeQsfQP8mdUnhfzxW+J1cPzmBxzn+/jgz+KdPFGLn8LxPJdP/FVkZf1lkPkwKCuyVjj0EWCZj
+oh58q9lw1kLGWUHGPogV/LNH9bwN+qlG8/IdRIm4zQ64VReTmA9oCEy9WxrBU5g8ORv6OuzoA4PDyrvj
+vjKwXCnSC0R1Zq8HBpiqMkcdmzicmFxf3dFH6DLGGtXIcyf5csSGnryApBQ5X2KJ4XvZoL5CWj3jpLh0
+CI/lfMX5OltVZI2q1OfnlMqLu8xNcP0SI0s0hLu8K3yP+0tOTgDFMZzBgghuzHDSZYZmjeVUJm5FbjPV
+1yPNciOoP1KGMlMGaVNYsBnk4w57NKRMuir7cnORCdCFOYYxbS/Zg6lrCLmxP3aMc6LHOWkZ56Rk8X5d
+CEeP2kbbUdedEfHoE4x2Misc7Bl8AEuTR7OZY5SlS7CO4LF2QfRU/jOR/zzq8ZL3cXm/t2zHdROuZMHK
+VOxWb5sbeH4z7V0MiyOVi8zR5WUlJyfw3xsSXPOE6QArv9Rf12iWtqCROTVeslnOquxXP01nXW4kJdtE
+wIWqqxpbb9hjciqana7N3t8a63tey29tLaKa9QIdVXV5Uam+yTrvhrCDpxeaFl8htILQ16+2wHjWAkLt
+YEh2S0LU1rBqOzOLO+qRQpAJa0PJb3bZRGaLxDptyoTiEokSy6J5W7OqgJhWIRzLFMFeaiQ/qDtJQ3Kg
+i5l1v8eUxhWGwnFDGWVzxYicR+UyKY7FT3i9wGywa1TMnZzA+7cv3w7CQJXuDc/he0IRu4VglaRq3vp2
+ECdLoEMIknUa4x0RtxW8pZdbcyxeUynv6W5mKrXgGYwLMn6h+c5VjXo1KDiCRYloDaveujTL9GGRnYJF
+QeNmLNtccwgfPjQOQC4c0RYFQY9JsNQHfW/gYno1c8ftEsXmyIv+HwoCKX0JxP0eYKioH5nB072xGR7d
+5aRHldk52e6STt14nHn4UrtCui9JFH1q4fYWo+0crFMN7KzsFtpn05fPrib9FfL/k76sMVvivyMRrAYC
+sSUWajMmWLnW5PXDPuvyGtzcnBez5uc5VN22CdYAMWdcy28oaODJtgF64DE0WdA1VkZrHUyRmJUOuonj
+ebEZcd2y3mqYSCLN6+l1/hp1awaySMSqgGycuvb4lcH7LkzDGsHN08LT69m5VePUnLRST6dA+nDdccCn
+wrnptT2LzkyqhqLStxuVSs0KPdYX+GWcbTU06Dq6UgNdH1RPNBVNyDx0Sap+WXmq68Mf3QmsFoSWbG1D
+qpYDlJ++2g0Sc2Hk0NJZHeDq7q9WLirdpdwkYHvfv6IMsRV3dnKsV/8ybvzbBsXcEe0EysqNdN1vo85o
+UX6+qK/EiHCUMrImgmzxK41HIB+ELZypMblFZXyQDZzZ62tdF45RbTZkL9CzkhwjvxqLW4ypOgrnaKrE
+lWJSx7vbVV4Ro+6zZ5VzBDZy8jD8lQz2pCUOtw+tDLO1ey2cu6fgzQ5jd7mHVR9MQGpViEowqNi+TTWM
+ElU6GXUwLseqTqb9VxYsrozOzelPrESGtk+jSfl5azPkKZl9B2gaGfWKvjT1avSw6ZpymdlSL8M8ibcy
+yK3kvNgy50csq93kaUyEbOWdeNZ1oZN8YShbLakv1tjXTlSxyJTl0/GUbah02w1aCH+RUIGpGDQWIYxj
+d/l10Dq0aC9SbAoz0xTRWYdXnfY8g3ELnNYKr25AjS5S2RsxzhUCJRVtg5karZEy2OlCkp1MYZAywlwC
+f8qbDKFZA9IcZy33nO5m55DBQNNdrUYrx2rxc1U6CmIVlALMR8uOh3/w8eD/BQAA//+qVt5kG6MAAA==
+`,
+	},
+
+	"/": {
+		isDir: true,
+		local: "",
+	},
+
+	"/std": {
+		isDir: true,
+		local: "std",
+	},
+}
diff --git a/vendor/github.com/google/go-jsonnet/std.thisFile.jsonnet b/vendor/github.com/google/go-jsonnet/std.thisFile.jsonnet
new file mode 100644
index 0000000000000000000000000000000000000000..f413f6e22ffcb320853aeb8daea096928f7ca4f8
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/std.thisFile.jsonnet
@@ -0,0 +1 @@
+std.thisFile
diff --git a/vendor/github.com/google/go-jsonnet/tests.sh b/vendor/github.com/google/go-jsonnet/tests.sh
new file mode 100755
index 0000000000000000000000000000000000000000..593e22365a91bac6d88d7169a6e2c7aac4ddbe48
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/tests.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+(cd jsonnet; go build)
+source tests_path.source
+export DISABLE_LIB_TESTS=true
+export DISABLE_FMT_TESTS=true
+export DISABLE_ERROR_TESTS=true
+export JSONNET_BIN="$PWD/jsonnet/jsonnet"
+cd "$TESTS_PATH"
+./tests.sh
diff --git a/vendor/github.com/google/go-jsonnet/thunks.go b/vendor/github.com/google/go-jsonnet/thunks.go
new file mode 100644
index 0000000000000000000000000000000000000000..b1cd48db7d1b8126996067e33cc9416a19c20668
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/thunks.go
@@ -0,0 +1,330 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import "github.com/google/go-jsonnet/ast"
+
+// readyValue
+// -------------------------------------
+
+// readyValue is a wrapper which allows to use a concrete value where normally
+// some evaluation would be expected (e.g. object fields). It's not part
+// of the value interface for increased type safety (it would be very easy
+// to "overevaluate" otherwise) and conveniently it also saves us from implementing
+// these methods for all value types.
+type readyValue struct {
+	content value
+}
+
+func (rv *readyValue) getValue(i *interpreter, t *TraceElement) (value, error) {
+	return rv.content, nil
+}
+
+func (rv *readyValue) bindToObject(sb selfBinding, origBinding bindingFrame, fieldName string) potentialValue {
+	return rv
+}
+
+func (rv *readyValue) aPotentialValue() {}
+
+// potentialValues
+// -------------------------------------
+
+// evaluable is something that can be evaluated and the result is always the same
+// It may require computation every time evaluation is requested (in contrast with
+// potentialValue which guarantees that computation happens at most once).
+type evaluable interface {
+	// fromWhere keeps the information from where the evaluation was requested.
+	getValue(i *interpreter, fromWhere *TraceElement) (value, error)
+}
+
+// thunk holds code and environment in which the code is supposed to be evaluated
+type thunk struct {
+	env  environment
+	body ast.Node
+}
+
+// TODO(sbarzowski) feedback from dcunnin:
+//					makeThunk returning a cachedThunk is weird.
+//					Maybe call thunk 'exprThunk' (or astThunk but then it looks like an AST node).
+//					Then call cachedThunk just thunk?
+//					Or, call this makeCachedExprThunk because that's what it really is.
+func makeThunk(env environment, body ast.Node) *cachedThunk {
+	return makeCachedThunk(&thunk{
+		env:  env,
+		body: body,
+	})
+}
+
+func (t *thunk) getValue(i *interpreter, trace *TraceElement) (value, error) {
+	return i.EvalInCleanEnv(trace, &t.env, t.body, false)
+}
+
+// callThunk represents a concrete, but not yet evaluated call to a function
+type callThunk struct {
+	function evalCallable
+	args     callArguments
+}
+
+func makeCallThunk(ec evalCallable, args callArguments) potentialValue {
+	return makeCachedThunk(&callThunk{function: ec, args: args})
+}
+
+func call(ec evalCallable, arguments ...potentialValue) potentialValue {
+	return makeCallThunk(ec, args(arguments...))
+}
+
+func (th *callThunk) getValue(i *interpreter, trace *TraceElement) (value, error) {
+	evaluator := makeEvaluator(i, trace)
+	err := checkArguments(evaluator, th.args, th.function.Parameters())
+	if err != nil {
+		return nil, err
+	}
+	return th.function.EvalCall(th.args, evaluator)
+}
+
+// deferredThunk allows deferring creation of evaluable until it's actually needed.
+// It's useful for self-recursive structures.
+type deferredThunk func() evaluable
+
+func (th deferredThunk) getValue(i *interpreter, trace *TraceElement) (value, error) {
+	return th().getValue(i, trace)
+}
+
+func makeDeferredThunk(th deferredThunk) potentialValue {
+	return makeCachedThunk(th)
+}
+
+// cachedThunk is a wrapper that caches the value of a potentialValue after
+// the first evaluation.
+// Note: All potentialValues are required to provide the same value every time,
+// so it's only there for efficiency.
+// TODO(sbarzowski) investigate efficiency of various representations
+type cachedThunk struct {
+	pv evaluable
+}
+
+func makeCachedThunk(pv evaluable) *cachedThunk {
+	return &cachedThunk{pv}
+}
+
+func (t *cachedThunk) getValue(i *interpreter, trace *TraceElement) (value, error) {
+	v, err := t.pv.getValue(i, trace)
+	if err != nil {
+		// TODO(sbarzowski) perhaps cache errors as well
+		// may be necessary if we allow handling them in any way
+		return nil, err
+	}
+	t.pv = &readyValue{v}
+	return v, nil
+}
+
+func (t *cachedThunk) aPotentialValue() {}
+
+// errorThunk can be used when potentialValue is expected, but we already
+// know that something went wrong
+type errorThunk struct {
+	err error
+}
+
+func (th *errorThunk) getValue(i *interpreter, trace *TraceElement) (value, error) {
+	return nil, th.err
+}
+
+func makeErrorThunk(err error) *errorThunk {
+	return &errorThunk{err}
+}
+
+func (th *errorThunk) aPotentialValue() {}
+
+// unboundFields
+// -------------------------------------
+
+type codeUnboundField struct {
+	body ast.Node
+}
+
+func (f *codeUnboundField) bindToObject(sb selfBinding, origBindings bindingFrame, fieldName string) potentialValue {
+	// TODO(sbarzowski) better object names (perhaps include a field name too?)
+	return makeThunk(makeEnvironment(origBindings, sb), f.body)
+}
+
+// Provide additional bindings for a field. It shadows bindings from the object.
+type bindingsUnboundField struct {
+	inner unboundField
+	// in addition to "generic" binding frame from the object
+	bindings bindingFrame
+}
+
+func (f *bindingsUnboundField) bindToObject(sb selfBinding, origBindings bindingFrame, fieldName string) potentialValue {
+	var upValues bindingFrame
+	upValues = make(bindingFrame)
+	for variable, pvalue := range origBindings {
+		upValues[variable] = pvalue
+	}
+	for variable, pvalue := range f.bindings {
+		upValues[variable] = pvalue
+	}
+	return f.inner.bindToObject(sb, upValues, fieldName)
+}
+
+type PlusSuperUnboundField struct {
+	inner unboundField
+}
+
+func (f *PlusSuperUnboundField) bindToObject(sb selfBinding, origBinding bindingFrame, fieldName string) potentialValue {
+	left := tryObjectIndex(sb.super(), fieldName, withHidden)
+	right := f.inner.bindToObject(sb, origBinding, fieldName)
+	if left != nil {
+		return call(bopBuiltins[ast.BopPlus], left, right)
+	}
+	return right
+}
+
+// evalCallables
+// -------------------------------------
+
+type closure struct {
+	// base environment of a closure
+	// arguments should be added to it, before executing it
+	env      environment
+	function *ast.Function
+	params   Parameters
+}
+
+func forceThunks(e *evaluator, args bindingFrame) error {
+	for _, arg := range args {
+		_, err := e.evaluate(arg)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (closure *closure) EvalCall(arguments callArguments, e *evaluator) (value, error) {
+	argThunks := make(bindingFrame)
+	parameters := closure.Parameters()
+	for i, arg := range arguments.positional {
+		var name ast.Identifier
+		if i < len(parameters.required) {
+			name = parameters.required[i]
+		} else {
+			name = parameters.optional[i-len(parameters.required)].name
+		}
+		argThunks[name] = arg
+	}
+
+	for _, arg := range arguments.named {
+		argThunks[arg.name] = arg.pv
+	}
+
+	var calledEnvironment environment
+
+	for i := range parameters.optional {
+		param := &parameters.optional[i]
+		if _, exists := argThunks[param.name]; !exists {
+			argThunks[param.name] = makeDeferredThunk(func() evaluable {
+				// Default arguments are evaluated in the same environment as function body
+				return param.defaultArg.inEnv(&calledEnvironment)
+			})
+		}
+	}
+
+	if arguments.tailstrict {
+		err := forceThunks(e, argThunks)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	calledEnvironment = makeEnvironment(
+		addBindings(closure.env.upValues, argThunks),
+		closure.env.sb,
+	)
+	return e.evalInCleanEnv(&calledEnvironment, closure.function.Body, arguments.tailstrict)
+}
+
+func (closure *closure) Parameters() Parameters {
+	return closure.params
+
+}
+
+func prepareClosureParameters(parameters ast.Parameters, env environment) Parameters {
+	optionalParameters := make([]namedParameter, 0, len(parameters.Optional))
+	for _, named := range parameters.Optional {
+		optionalParameters = append(optionalParameters, namedParameter{
+			name: named.Name,
+			defaultArg: &defaultArgument{
+				body: named.DefaultArg,
+			},
+		})
+	}
+	return Parameters{
+		required: parameters.Required,
+		optional: optionalParameters,
+	}
+}
+
+func makeClosure(env environment, function *ast.Function) *closure {
+	return &closure{
+		env:      env,
+		function: function,
+		params:   prepareClosureParameters(function.Parameters, env),
+	}
+}
+
+type NativeFunction struct {
+	Func   func([]interface{}) (interface{}, error)
+	Params ast.Identifiers
+	Name   string
+}
+
+func (native *NativeFunction) EvalCall(arguments callArguments, e *evaluator) (value, error) {
+	flatArgs := flattenArgs(arguments, native.Parameters())
+	nativeArgs := make([]interface{}, 0, len(flatArgs))
+	for _, arg := range flatArgs {
+		v, err := e.evaluate(arg)
+		if err != nil {
+			return nil, err
+		}
+		json, err := e.i.manifestJSON(e.trace, v)
+		if err != nil {
+			return nil, err
+		}
+		nativeArgs = append(nativeArgs, json)
+	}
+	resultJSON, err := native.Func(nativeArgs)
+	if err != nil {
+		return nil, err
+	}
+	return jsonToValue(e, resultJSON)
+}
+
+func (native *NativeFunction) Parameters() Parameters {
+	return Parameters{required: native.Params}
+}
+
+// partialPotentialValue
+// -------------------------------------
+
+type defaultArgument struct {
+	body ast.Node
+}
+
+func (da *defaultArgument) inEnv(env *environment) potentialValue {
+	return makeThunk(*env, da.body)
+}
diff --git a/vendor/github.com/google/go-jsonnet/value.go b/vendor/github.com/google/go-jsonnet/value.go
new file mode 100644
index 0000000000000000000000000000000000000000..69874ce0b2d51457e3717f1b35174e9713849011
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/value.go
@@ -0,0 +1,656 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package jsonnet
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/google/go-jsonnet/ast"
+)
+
+// value represents a concrete jsonnet value of a specific type.
+// Various operations on values are allowed, depending on their type.
+// All values are of course immutable.
+type value interface {
+	aValue()
+
+	getType() *valueType
+}
+
+type valueType struct {
+	name string
+}
+
+var stringType = &valueType{"string"}
+var numberType = &valueType{"number"}
+var functionType = &valueType{"function"}
+var objectType = &valueType{"object"}
+var booleanType = &valueType{"boolean"}
+var nullType = &valueType{"null"}
+var arrayType = &valueType{"array"}
+
+// potentialValue is something that may be evaluated to a concrete value.
+// The result of the evaluation may *NOT* depend on the current state
+// of the interpreter. The evaluation may fail.
+//
+// It can be used to represent lazy values (e.g. variables values in jsonnet
+// are not calculated before they are used). It is also a useful abstraction
+// in other cases like error handling.
+//
+// It may or may not require arbitrary computation when getValue is called the
+// first time, but any subsequent calls will immediately return.
+//
+// TODO(sbarzowski) perhaps call it just "Thunk"?
+type potentialValue interface {
+	// fromWhere keeps the information from where the evaluation was requested.
+	getValue(i *interpreter, fromWhere *TraceElement) (value, error)
+
+	aPotentialValue()
+}
+
+// A set of variables with associated potentialValues.
+type bindingFrame map[ast.Identifier]potentialValue
+
+type valueBase struct{}
+
+func (v *valueBase) aValue() {}
+
+// Primitive values
+// -------------------------------------
+
+type valueString struct {
+	valueBase
+	// We use rune slices instead of strings for quick indexing
+	value []rune
+}
+
+func (s *valueString) index(e *evaluator, index int) (value, error) {
+	if 0 <= index && index < s.length() {
+		return makeValueString(string(s.value[index])), nil
+	}
+	return nil, e.Error(fmt.Sprintf("Index %d out of bounds, not within [0, %v)", index, s.length()))
+}
+
+func concatStrings(a, b *valueString) *valueString {
+	result := make([]rune, 0, len(a.value)+len(b.value))
+	for _, r := range a.value {
+		result = append(result, r)
+	}
+	for _, r := range b.value {
+		result = append(result, r)
+	}
+	return &valueString{value: result}
+}
+
+func stringLessThan(a, b *valueString) bool {
+	var length int
+	if len(a.value) < len(b.value) {
+		length = len(a.value)
+	} else {
+		length = len(b.value)
+	}
+	for i := 0; i < length; i++ {
+		if a.value[i] != b.value[i] {
+			return a.value[i] < b.value[i]
+		}
+	}
+	return len(a.value) < len(b.value)
+}
+
+func stringEqual(a, b *valueString) bool {
+	if len(a.value) != len(b.value) {
+		return false
+	}
+	for i := 0; i < len(a.value); i++ {
+		if a.value[i] != b.value[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *valueString) length() int {
+	return len(s.value)
+}
+
+func (s *valueString) getString() string {
+	return string(s.value)
+}
+
+func makeValueString(v string) *valueString {
+	return &valueString{value: []rune(v)}
+}
+
+func (*valueString) getType() *valueType {
+	return stringType
+}
+
+type valueBoolean struct {
+	valueBase
+	value bool
+}
+
+func (*valueBoolean) getType() *valueType {
+	return booleanType
+}
+
+func makeValueBoolean(v bool) *valueBoolean {
+	return &valueBoolean{value: v}
+}
+
+func (b *valueBoolean) not() *valueBoolean {
+	return makeValueBoolean(!b.value)
+}
+
+type valueNumber struct {
+	valueBase
+	value float64
+}
+
+func (*valueNumber) getType() *valueType {
+	return numberType
+}
+
+func makeValueNumber(v float64) *valueNumber {
+	return &valueNumber{value: v}
+}
+
+func intToValue(i int) *valueNumber {
+	return makeValueNumber(float64(i))
+}
+
+func int64ToValue(i int64) *valueNumber {
+	return makeValueNumber(float64(i))
+}
+
+type valueNull struct {
+	valueBase
+}
+
+var nullValue valueNull
+
+func makeValueNull() *valueNull {
+	return &nullValue
+}
+
+func (*valueNull) getType() *valueType {
+	return nullType
+}
+
+// ast.Array
+// -------------------------------------
+
+type valueArray struct {
+	valueBase
+	elements []potentialValue
+}
+
+func (arr *valueArray) length() int {
+	return len(arr.elements)
+}
+
+func makeValueArray(elements []potentialValue) *valueArray {
+	// We don't want to keep a bigger array than necessary
+	// so we create a new one with minimal capacity
+	var arrayElems []potentialValue
+	if len(elements) == cap(elements) {
+		arrayElems = elements
+	} else {
+		arrayElems = make([]potentialValue, len(elements))
+		for i := range elements {
+			arrayElems[i] = elements[i]
+		}
+	}
+	return &valueArray{
+		elements: arrayElems,
+	}
+}
+
+func concatArrays(a, b *valueArray) *valueArray {
+	result := make([]potentialValue, 0, len(a.elements)+len(b.elements))
+	for _, r := range a.elements {
+		result = append(result, r)
+	}
+	for _, r := range b.elements {
+		result = append(result, r)
+	}
+	return &valueArray{elements: result}
+}
+
+func (*valueArray) getType() *valueType {
+	return arrayType
+}
+
+// ast.Function
+// -------------------------------------
+
+type valueFunction struct {
+	valueBase
+	ec evalCallable
+}
+
+// TODO(sbarzowski) better name?
+type evalCallable interface {
+	EvalCall(args callArguments, e *evaluator) (value, error)
+	Parameters() Parameters
+}
+
+type partialPotentialValue interface {
+	inEnv(env *environment) potentialValue
+}
+
+func (f *valueFunction) call(args callArguments) potentialValue {
+	return makeCallThunk(f.ec, args)
+}
+
+func (f *valueFunction) parameters() Parameters {
+	return f.ec.Parameters()
+}
+
+func checkArguments(e *evaluator, args callArguments, params Parameters) error {
+	received := make(map[ast.Identifier]bool)
+	accepted := make(map[ast.Identifier]bool)
+
+	numPassed := len(args.positional)
+	numExpected := len(params.required) + len(params.optional)
+
+	if numPassed > numExpected {
+		return e.Error(fmt.Sprintf("Function expected %v positional argument(s), but got %v", numExpected, numPassed))
+	}
+
+	for _, param := range params.required {
+		accepted[param] = true
+	}
+
+	for _, param := range params.optional {
+		accepted[param.name] = true
+	}
+
+	for i := range args.positional {
+		if i < len(params.required) {
+			received[params.required[i]] = true
+		} else {
+			received[params.optional[i-len(params.required)].name] = true
+		}
+	}
+
+	for _, arg := range args.named {
+		if _, present := received[arg.name]; present {
+			return e.Error(fmt.Sprintf("Argument %v already provided", arg.name))
+		}
+		if _, present := accepted[arg.name]; !present {
+			return e.Error(fmt.Sprintf("Function has no parameter %v", arg.name))
+		}
+		received[arg.name] = true
+	}
+
+	for _, param := range params.required {
+		if _, present := received[param]; !present {
+			return e.Error(fmt.Sprintf("Missing argument: %v", param))
+		}
+	}
+
+	return nil
+}
+
+func (f *valueFunction) getType() *valueType {
+	return functionType
+}
+
+type Parameters struct {
+	required ast.Identifiers
+	optional []namedParameter
+}
+
+type namedParameter struct {
+	name       ast.Identifier
+	defaultArg potentialValueInEnv
+}
+
+type potentialValueInEnv interface {
+	inEnv(env *environment) potentialValue
+}
+
+type callArguments struct {
+	positional []potentialValue
+	named      []namedCallArgument
+	tailstrict bool
+}
+
+type namedCallArgument struct {
+	name ast.Identifier
+	pv   potentialValue
+}
+
+func args(xs ...potentialValue) callArguments {
+	return callArguments{positional: xs}
+}
+
+// Objects
+// -------------------------------------
+
+// Object is a value that allows indexing (taking a value of a field)
+// and combining through mixin inheritence (operator +).
+//
+// Note that every time a field is indexed it evaluates it again, there is
+// no caching of field values. See: https://github.com/google/go-jsonnet/issues/113
+type valueObject interface {
+	value
+	inheritanceSize() int
+	index(e *evaluator, field string) (value, error)
+	assertionsChecked() bool
+	setAssertionsCheckResult(err error)
+	getAssertionsCheckResult() error
+}
+
+type selfBinding struct {
+	// self is the lexically nearest object we are in, or nil.  Note
+	// that this is not the same as context, because we could be inside a function,
+	// inside an object and then context would be the function, but self would still point
+	// to the object.
+	self valueObject
+
+	// superDepth is the "super" level of self.  Sometimes, we look upwards in the
+	// inheritance tree, e.g. via an explicit use of super, or because a given field
+	// has been inherited.  When evaluating a field from one of these super objects,
+	// we need to bind self to the concrete object (so self must point
+	// there) but uses of super should be resolved relative to the object whose
+	// field we are evaluating.  Thus, we keep a second field for that.  This is
+	// usually 0, unless we are evaluating a super object's field.
+	// TODO(sbarzowski) provide some examples
+	// TODO(sbarzowski) provide somewhere a complete explanation of the object model
+	superDepth int
+}
+
+func makeUnboundSelfBinding() selfBinding {
+	return selfBinding{
+		nil,
+		123456789, // poison value
+	}
+}
+
+func objectBinding(obj valueObject) selfBinding {
+	return selfBinding{self: obj, superDepth: 0}
+}
+
+func (sb selfBinding) super() selfBinding {
+	return selfBinding{self: sb.self, superDepth: sb.superDepth + 1}
+}
+
+type Hidden int
+
+const (
+	withHidden Hidden = iota
+	withoutHidden
+)
+
+func withHiddenFromBool(with bool) Hidden {
+	if with {
+		return withHidden
+	} else {
+		return withoutHidden
+	}
+}
+
+// Hack - we need to distinguish not-checked-yet and no error situations
+// so we have a special value for no error and nil means that we don't know yet.
+var errNoErrorInObjectInvariants = errors.New("No error - assertions passed")
+
+type valueObjectBase struct {
+	valueBase
+	assertionError error
+}
+
+func (*valueObjectBase) getType() *valueType {
+	return objectType
+}
+
+func (obj *valueObjectBase) assertionsChecked() bool {
+	// nil - not checked yet
+	// errNoErrorInObjectInvariants - we checked and there is no error (or checking in progress)
+	return obj.assertionError != nil
+}
+
+func (obj *valueObjectBase) setAssertionsCheckResult(err error) {
+	if err != nil {
+		obj.assertionError = err
+	} else {
+		obj.assertionError = errNoErrorInObjectInvariants
+	}
+}
+
+func (obj *valueObjectBase) getAssertionsCheckResult() error {
+	if obj.assertionError == nil {
+		panic("Assertions not checked yet")
+	}
+	if obj.assertionError == errNoErrorInObjectInvariants {
+		return nil
+	}
+	return obj.assertionError
+}
+
+// valueSimpleObject represents a flat object (no inheritance).
+// Note that it can be used as part of extended objects
+// in inheritance using operator +.
+//
+// Fields are late bound (to object), so they are not values or potentialValues.
+// This is important for inheritance, for example:
+// Let a = {x: 42} and b = {y: self.x}. Evaluating b.y is an error,
+// but (a+b).y evaluates to 42.
+type valueSimpleObject struct {
+	valueObjectBase
+	upValues bindingFrame
+	fields   simpleObjectFieldMap
+	asserts  []unboundField
+}
+
+func checkAssertionsHelper(e *evaluator, obj valueObject, curr valueObject, superDepth int) error {
+	switch curr := curr.(type) {
+	case *valueExtendedObject:
+		err := checkAssertionsHelper(e, obj, curr.right, superDepth)
+		if err != nil {
+			return err
+		}
+		err = checkAssertionsHelper(e, obj, curr.left, superDepth+curr.right.inheritanceSize())
+		if err != nil {
+			return err
+		}
+		return nil
+	case *valueSimpleObject:
+		for _, assert := range curr.asserts {
+			_, err := e.evaluate(assert.bindToObject(selfBinding{self: obj, superDepth: superDepth}, curr.upValues, ""))
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	default:
+		panic(fmt.Sprintf("Unknown object type %#v", obj))
+	}
+}
+
+func checkAssertions(e *evaluator, obj valueObject) error {
+	if !obj.assertionsChecked() {
+		// Assertions may refer to the object that will normally
+		// trigger checking of assertions, resulting in an endless recursion.
+		// To avoid that, while we check them, we treat them as already passed.
+		obj.setAssertionsCheckResult(errNoErrorInObjectInvariants)
+		obj.setAssertionsCheckResult(checkAssertionsHelper(e, obj, obj, 0))
+	}
+	return obj.getAssertionsCheckResult()
+}
+
+func (o *valueSimpleObject) index(e *evaluator, field string) (value, error) {
+	return objectIndex(e, objectBinding(o), field)
+}
+
+func (*valueSimpleObject) inheritanceSize() int {
+	return 1
+}
+
+func makeValueSimpleObject(b bindingFrame, fields simpleObjectFieldMap, asserts []unboundField) *valueSimpleObject {
+	return &valueSimpleObject{
+		upValues: b,
+		fields:   fields,
+		asserts:  asserts,
+	}
+}
+
+type simpleObjectFieldMap map[string]simpleObjectField
+
+type simpleObjectField struct {
+	hide  ast.ObjectFieldHide
+	field unboundField
+}
+
+// unboundField is a field that doesn't know yet in which object it is.
+type unboundField interface {
+	bindToObject(sb selfBinding, origBinding bindingFrame, fieldName string) potentialValue
+}
+
+// valueExtendedObject represents an object created through inheritence (left + right).
+// We represent it as the pair of objects. This results in a tree-like structure.
+// Example:
+// (A + B) + C
+//
+//        +
+//       / \
+//      +   C
+//     / \
+//    A   B
+//
+// It is possible to create an arbitrary binary tree.
+// Note however, that because + is associative the only thing that matters
+// is the order of leafs.
+//
+// This represenation allows us to implement "+" in O(1),
+// but requires going through the tree and trying subsequent leafs for field access.
+//
+type valueExtendedObject struct {
+	valueObjectBase
+	left, right          valueObject
+	totalInheritanceSize int
+}
+
+func (o *valueExtendedObject) index(e *evaluator, field string) (value, error) {
+	return objectIndex(e, objectBinding(o), field)
+}
+
+func (o *valueExtendedObject) inheritanceSize() int {
+	return o.totalInheritanceSize
+}
+
+func makeValueExtendedObject(left, right valueObject) *valueExtendedObject {
+	return &valueExtendedObject{
+		left:                 left,
+		right:                right,
+		totalInheritanceSize: left.inheritanceSize() + right.inheritanceSize(),
+	}
+}
+
+// findField returns a field in object curr, with superDepth at least minSuperDepth
+// It also returns an associated bindingFrame and actual superDepth that the field
+// was found at.
+func findField(curr value, minSuperDepth int, f string) (*simpleObjectField, bindingFrame, int) {
+	switch curr := curr.(type) {
+	case *valueExtendedObject:
+		if curr.right.inheritanceSize() > minSuperDepth {
+			field, frame, counter := findField(curr.right, minSuperDepth, f)
+			if field != nil {
+				return field, frame, counter
+			}
+		}
+		field, frame, counter := findField(curr.left, minSuperDepth-curr.right.inheritanceSize(), f)
+		return field, frame, counter + curr.right.inheritanceSize()
+
+	case *valueSimpleObject:
+		if minSuperDepth <= 0 {
+			if field, ok := curr.fields[f]; ok {
+				return &field, curr.upValues, 0
+			}
+		}
+		return nil, nil, 0
+	default:
+		panic(fmt.Sprintf("Unknown object type %#v", curr))
+	}
+}
+
+func objectIndex(e *evaluator, sb selfBinding, fieldName string) (value, error) {
+	err := checkAssertions(e, sb.self)
+	if err != nil {
+		return nil, err
+	}
+	if sb.superDepth >= sb.self.inheritanceSize() {
+		return nil, e.Error("Attempt to use super when there is no super class.")
+	}
+	objp := tryObjectIndex(sb, fieldName, withHidden)
+	if objp == nil {
+		return nil, e.Error(fmt.Sprintf("Field does not exist: %s", fieldName))
+	}
+	return e.evaluate(objp)
+}
+
+func tryObjectIndex(sb selfBinding, fieldName string, h Hidden) potentialValue {
+	field, upValues, foundAt := findField(sb.self, sb.superDepth, fieldName)
+	if field == nil || (h == withoutHidden && field.hide == ast.ObjectFieldHidden) {
+		return nil
+	}
+	fieldSelfBinding := selfBinding{self: sb.self, superDepth: foundAt}
+
+	return field.field.bindToObject(fieldSelfBinding, upValues, fieldName)
+}
+
+type fieldHideMap map[string]ast.ObjectFieldHide
+
+func objectFieldsVisibility(obj valueObject) fieldHideMap {
+	r := make(fieldHideMap)
+	switch obj := obj.(type) {
+	case *valueExtendedObject:
+		r = objectFieldsVisibility(obj.left)
+		rightMap := objectFieldsVisibility(obj.right)
+		for k, v := range rightMap {
+			if v == ast.ObjectFieldInherit {
+				if _, alreadyExists := r[k]; !alreadyExists {
+					r[k] = v
+				}
+			} else {
+				r[k] = v
+			}
+		}
+		return r
+
+	case *valueSimpleObject:
+		for fieldName, field := range obj.fields {
+			r[fieldName] = field.hide
+		}
+	}
+	return r
+}
+
+func objectFields(obj valueObject, h Hidden) []string {
+	var r []string
+	for fieldName, hide := range objectFieldsVisibility(obj) {
+		if h == withHidden || hide != ast.ObjectFieldHidden {
+			r = append(r, fieldName)
+		}
+	}
+	return r
+}
+
+func duplicateFieldNameErrMsg(fieldName string) string {
+	return fmt.Sprintf("Duplicate field name: %s", unparseString(fieldName))
+}
diff --git a/vendor/github.com/google/go-jsonnet/vm.go b/vendor/github.com/google/go-jsonnet/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..820f3ae8347c10783989e92506c6a34be8487190
--- /dev/null
+++ b/vendor/github.com/google/go-jsonnet/vm.go
@@ -0,0 +1,147 @@
+/*
+Copyright 2017 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package jsonnet
+
+import (
+	"errors"
+	"fmt"
+	"runtime/debug"
+
+	"github.com/google/go-jsonnet/ast"
+	"github.com/google/go-jsonnet/parser"
+)
+
+// Note: There are no garbage collection params because we're using the native
+// Go garbage collector.
+
+// VM is the core interpreter and is the touchpoint used to parse and execute
+// Jsonnet.
+type VM struct {
+	MaxStack    int
+	MaxTrace    int // The number of lines of stack trace to display (0 for all of them).
+	ext         vmExtMap
+	tla         vmExtMap
+	nativeFuncs map[string]*NativeFunction
+	importer    Importer
+	ef          ErrorFormatter
+}
+
+// External variable or top level argument provided before execution
+type vmExt struct {
+	// jsonnet code to evaluate or string to pass
+	value string
+	// isCode determines whether it should be evaluated as jsonnet code or
+	// treated as string.
+	isCode bool
+}
+
+type vmExtMap map[string]vmExt
+
+// MakeVM creates a new VM with default parameters.
+func MakeVM() *VM {
+	return &VM{
+		MaxStack:    500,
+		ext:         make(vmExtMap),
+		tla:         make(vmExtMap),
+		nativeFuncs: make(map[string]*NativeFunction),
+		ef:          ErrorFormatter{pretty: true, colorful: true, MaxStackTraceSize: 20},
+		importer:    &FileImporter{},
+	}
+}
+
+// ExtVar binds a Jsonnet external var to the given value.
+func (vm *VM) ExtVar(key string, val string) {
+	vm.ext[key] = vmExt{value: val, isCode: false}
+}
+
+// ExtCode binds a Jsonnet external code var to the given code.
+func (vm *VM) ExtCode(key string, val string) {
+	vm.ext[key] = vmExt{value: val, isCode: true}
+}
+
+// TLAVar binds a Jsonnet top level argument to the given value.
+func (vm *VM) TLAVar(key string, val string) {
+	vm.tla[key] = vmExt{value: val, isCode: false}
+}
+
+// TLACode binds a Jsonnet top level argument to the given code.
+func (vm *VM) TLACode(key string, val string) {
+	vm.tla[key] = vmExt{value: val, isCode: true}
+}
+
+// Importer sets Importer to use during evaluation (import callback)
+func (vm *VM) Importer(i Importer) {
+	vm.importer = i
+}
+
+func (vm *VM) evaluateSnippet(filename string, snippet string) (output string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("(CRASH) %v\n%s", r, debug.Stack())
+		}
+	}()
+	node, err := snippetToAST(filename, snippet)
+	if err != nil {
+		return "", err
+	}
+	output, err = evaluate(node, vm.ext, vm.tla, vm.nativeFuncs, vm.MaxStack, vm.importer)
+	if err != nil {
+		return "", err
+	}
+	return output, nil
+}
+
+// NativeFunction registers a native function
+func (vm *VM) NativeFunction(f *NativeFunction) {
+	vm.nativeFuncs[f.Name] = f
+}
+
+// EvaluateSnippet evaluates a string containing Jsonnet code, return a JSON
+// string.
+//
+// The filename parameter is only used for error messages.
+func (vm *VM) EvaluateSnippet(filename string, snippet string) (json string, formattedErr error) {
+	json, err := vm.evaluateSnippet(filename, snippet)
+	if err != nil {
+		return "", errors.New(vm.ef.format(err))
+	}
+	return json, nil
+}
+
+func snippetToAST(filename string, snippet string) (ast.Node, error) {
+	tokens, err := parser.Lex(filename, snippet)
+	if err != nil {
+		return nil, err
+	}
+	node, err := parser.Parse(tokens)
+	if err != nil {
+		return nil, err
+	}
+	err = desugarFile(&node)
+	if err != nil {
+		return nil, err
+	}
+	err = analyze(node)
+	if err != nil {
+		return nil, err
+	}
+	return node, nil
+}
+
+func Version() string {
+	return "v0.9.5"
+}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE b/vendor/github.com/mattn/go-colorable/LICENSE
similarity index 96%
rename from vendor/github.com/strickyak/jsonnet_cgo/LICENSE
rename to vendor/github.com/mattn/go-colorable/LICENSE
index adea0b8660b0e64ecfb6905fc4380bb387ca7875..91b5cef30ebdf08cb6efe669497a96f58c66035d 100644
--- a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE
+++ b/vendor/github.com/mattn/go-colorable/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Strick Yak
+Copyright (c) 2016 Yasuhiro Matsumoto
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +19,3 @@ 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/vendor/github.com/mattn/go-colorable/README.md b/vendor/github.com/mattn/go-colorable/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..56729a92ca627e3775b1b22d8bac67b1a5eb8aa5
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/README.md
@@ -0,0 +1,48 @@
+# go-colorable
+
+[![Godoc Reference](https://godoc.org/github.com/mattn/go-colorable?status.svg)](http://godoc.org/github.com/mattn/go-colorable)
+[![Build Status](https://travis-ci.org/mattn/go-colorable.svg?branch=master)](https://travis-ci.org/mattn/go-colorable)
+[![Coverage Status](https://coveralls.io/repos/github/mattn/go-colorable/badge.svg?branch=master)](https://coveralls.io/github/mattn/go-colorable?branch=master)
+[![Go Report Card](https://goreportcard.com/badge/mattn/go-colorable)](https://goreportcard.com/report/mattn/go-colorable)
+
+Colorable writer for windows.
+
+For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
+This package is possible to handle escape sequence for ansi color on windows.
+
+## Too Bad!
+
+![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/bad.png)
+
+
+## So Good!
+
+![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/good.png)
+
+## Usage
+
+```go
+logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
+logrus.SetOutput(colorable.NewColorableStdout())
+
+logrus.Info("succeeded")
+logrus.Warn("not correct")
+logrus.Error("something error")
+logrus.Fatal("panic")
+```
+
+You can compile above code on non-windows OSs.
+
+## Installation
+
+```
+$ go get github.com/mattn/go-colorable
+```
+
+# License
+
+MIT
+
+# Author
+
+Yasuhiro Matsumoto (a.k.a mattn)
diff --git a/vendor/github.com/mattn/go-colorable/colorable_others.go b/vendor/github.com/mattn/go-colorable/colorable_others.go
new file mode 100644
index 0000000000000000000000000000000000000000..887f203dc7faaad4ab0ca4fb3f383c2a517089ba
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/colorable_others.go
@@ -0,0 +1,30 @@
+// +build !windows
+// +build !appengine
+
+package colorable
+
+import (
+	"io"
+	"os"
+
+	_ "github.com/mattn/go-isatty"
+)
+
+// NewColorable return new instance of Writer which handle escape sequence.
+func NewColorable(file *os.File) io.Writer {
+	if file == nil {
+		panic("nil passed instead of *os.File to NewColorable()")
+	}
+
+	return file
+}
+
+// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
+func NewColorableStdout() io.Writer {
+	return os.Stdout
+}
+
+// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
+func NewColorableStderr() io.Writer {
+	return os.Stderr
+}
diff --git a/vendor/github.com/mattn/go-colorable/colorable_windows.go b/vendor/github.com/mattn/go-colorable/colorable_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..15a014fd309774e3f7596b2b6220f9f283932b43
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/colorable_windows.go
@@ -0,0 +1,968 @@
+// +build windows
+// +build !appengine
+
+package colorable
+
+import (
+	"bytes"
+	"io"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/mattn/go-isatty"
+)
+
+const (
+	foregroundBlue      = 0x1
+	foregroundGreen     = 0x2
+	foregroundRed       = 0x4
+	foregroundIntensity = 0x8
+	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
+	backgroundBlue      = 0x10
+	backgroundGreen     = 0x20
+	backgroundRed       = 0x40
+	backgroundIntensity = 0x80
+	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
+)
+
+const (
+	genericRead  = 0x80000000
+	genericWrite = 0x40000000
+)
+
+const (
+	consoleTextmodeBuffer = 0x1
+)
+
+type wchar uint16
+type short int16
+type dword uint32
+type word uint16
+
+type coord struct {
+	x short
+	y short
+}
+
+type smallRect struct {
+	left   short
+	top    short
+	right  short
+	bottom short
+}
+
+type consoleScreenBufferInfo struct {
+	size              coord
+	cursorPosition    coord
+	attributes        word
+	window            smallRect
+	maximumWindowSize coord
+}
+
+type consoleCursorInfo struct {
+	size    dword
+	visible int32
+}
+
+var (
+	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
+	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
+	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
+	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
+	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
+	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
+	procCreateConsoleScreenBuffer  = kernel32.NewProc("CreateConsoleScreenBuffer")
+)
+
+// Writer provide colorable Writer to the console
+type Writer struct {
+	out       io.Writer
+	handle    syscall.Handle
+	althandle syscall.Handle
+	oldattr   word
+	oldpos    coord
+	rest      bytes.Buffer
+}
+
+// NewColorable return new instance of Writer which handle escape sequence from File.
+func NewColorable(file *os.File) io.Writer {
+	if file == nil {
+		panic("nil passed instead of *os.File to NewColorable()")
+	}
+
+	if isatty.IsTerminal(file.Fd()) {
+		var csbi consoleScreenBufferInfo
+		handle := syscall.Handle(file.Fd())
+		procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+		return &Writer{out: file, handle: handle, oldattr: csbi.attributes, oldpos: coord{0, 0}}
+	}
+	return file
+}
+
+// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
+func NewColorableStdout() io.Writer {
+	return NewColorable(os.Stdout)
+}
+
+// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
+func NewColorableStderr() io.Writer {
+	return NewColorable(os.Stderr)
+}
+
+var color256 = map[int]int{
+	0:   0x000000,
+	1:   0x800000,
+	2:   0x008000,
+	3:   0x808000,
+	4:   0x000080,
+	5:   0x800080,
+	6:   0x008080,
+	7:   0xc0c0c0,
+	8:   0x808080,
+	9:   0xff0000,
+	10:  0x00ff00,
+	11:  0xffff00,
+	12:  0x0000ff,
+	13:  0xff00ff,
+	14:  0x00ffff,
+	15:  0xffffff,
+	16:  0x000000,
+	17:  0x00005f,
+	18:  0x000087,
+	19:  0x0000af,
+	20:  0x0000d7,
+	21:  0x0000ff,
+	22:  0x005f00,
+	23:  0x005f5f,
+	24:  0x005f87,
+	25:  0x005faf,
+	26:  0x005fd7,
+	27:  0x005fff,
+	28:  0x008700,
+	29:  0x00875f,
+	30:  0x008787,
+	31:  0x0087af,
+	32:  0x0087d7,
+	33:  0x0087ff,
+	34:  0x00af00,
+	35:  0x00af5f,
+	36:  0x00af87,
+	37:  0x00afaf,
+	38:  0x00afd7,
+	39:  0x00afff,
+	40:  0x00d700,
+	41:  0x00d75f,
+	42:  0x00d787,
+	43:  0x00d7af,
+	44:  0x00d7d7,
+	45:  0x00d7ff,
+	46:  0x00ff00,
+	47:  0x00ff5f,
+	48:  0x00ff87,
+	49:  0x00ffaf,
+	50:  0x00ffd7,
+	51:  0x00ffff,
+	52:  0x5f0000,
+	53:  0x5f005f,
+	54:  0x5f0087,
+	55:  0x5f00af,
+	56:  0x5f00d7,
+	57:  0x5f00ff,
+	58:  0x5f5f00,
+	59:  0x5f5f5f,
+	60:  0x5f5f87,
+	61:  0x5f5faf,
+	62:  0x5f5fd7,
+	63:  0x5f5fff,
+	64:  0x5f8700,
+	65:  0x5f875f,
+	66:  0x5f8787,
+	67:  0x5f87af,
+	68:  0x5f87d7,
+	69:  0x5f87ff,
+	70:  0x5faf00,
+	71:  0x5faf5f,
+	72:  0x5faf87,
+	73:  0x5fafaf,
+	74:  0x5fafd7,
+	75:  0x5fafff,
+	76:  0x5fd700,
+	77:  0x5fd75f,
+	78:  0x5fd787,
+	79:  0x5fd7af,
+	80:  0x5fd7d7,
+	81:  0x5fd7ff,
+	82:  0x5fff00,
+	83:  0x5fff5f,
+	84:  0x5fff87,
+	85:  0x5fffaf,
+	86:  0x5fffd7,
+	87:  0x5fffff,
+	88:  0x870000,
+	89:  0x87005f,
+	90:  0x870087,
+	91:  0x8700af,
+	92:  0x8700d7,
+	93:  0x8700ff,
+	94:  0x875f00,
+	95:  0x875f5f,
+	96:  0x875f87,
+	97:  0x875faf,
+	98:  0x875fd7,
+	99:  0x875fff,
+	100: 0x878700,
+	101: 0x87875f,
+	102: 0x878787,
+	103: 0x8787af,
+	104: 0x8787d7,
+	105: 0x8787ff,
+	106: 0x87af00,
+	107: 0x87af5f,
+	108: 0x87af87,
+	109: 0x87afaf,
+	110: 0x87afd7,
+	111: 0x87afff,
+	112: 0x87d700,
+	113: 0x87d75f,
+	114: 0x87d787,
+	115: 0x87d7af,
+	116: 0x87d7d7,
+	117: 0x87d7ff,
+	118: 0x87ff00,
+	119: 0x87ff5f,
+	120: 0x87ff87,
+	121: 0x87ffaf,
+	122: 0x87ffd7,
+	123: 0x87ffff,
+	124: 0xaf0000,
+	125: 0xaf005f,
+	126: 0xaf0087,
+	127: 0xaf00af,
+	128: 0xaf00d7,
+	129: 0xaf00ff,
+	130: 0xaf5f00,
+	131: 0xaf5f5f,
+	132: 0xaf5f87,
+	133: 0xaf5faf,
+	134: 0xaf5fd7,
+	135: 0xaf5fff,
+	136: 0xaf8700,
+	137: 0xaf875f,
+	138: 0xaf8787,
+	139: 0xaf87af,
+	140: 0xaf87d7,
+	141: 0xaf87ff,
+	142: 0xafaf00,
+	143: 0xafaf5f,
+	144: 0xafaf87,
+	145: 0xafafaf,
+	146: 0xafafd7,
+	147: 0xafafff,
+	148: 0xafd700,
+	149: 0xafd75f,
+	150: 0xafd787,
+	151: 0xafd7af,
+	152: 0xafd7d7,
+	153: 0xafd7ff,
+	154: 0xafff00,
+	155: 0xafff5f,
+	156: 0xafff87,
+	157: 0xafffaf,
+	158: 0xafffd7,
+	159: 0xafffff,
+	160: 0xd70000,
+	161: 0xd7005f,
+	162: 0xd70087,
+	163: 0xd700af,
+	164: 0xd700d7,
+	165: 0xd700ff,
+	166: 0xd75f00,
+	167: 0xd75f5f,
+	168: 0xd75f87,
+	169: 0xd75faf,
+	170: 0xd75fd7,
+	171: 0xd75fff,
+	172: 0xd78700,
+	173: 0xd7875f,
+	174: 0xd78787,
+	175: 0xd787af,
+	176: 0xd787d7,
+	177: 0xd787ff,
+	178: 0xd7af00,
+	179: 0xd7af5f,
+	180: 0xd7af87,
+	181: 0xd7afaf,
+	182: 0xd7afd7,
+	183: 0xd7afff,
+	184: 0xd7d700,
+	185: 0xd7d75f,
+	186: 0xd7d787,
+	187: 0xd7d7af,
+	188: 0xd7d7d7,
+	189: 0xd7d7ff,
+	190: 0xd7ff00,
+	191: 0xd7ff5f,
+	192: 0xd7ff87,
+	193: 0xd7ffaf,
+	194: 0xd7ffd7,
+	195: 0xd7ffff,
+	196: 0xff0000,
+	197: 0xff005f,
+	198: 0xff0087,
+	199: 0xff00af,
+	200: 0xff00d7,
+	201: 0xff00ff,
+	202: 0xff5f00,
+	203: 0xff5f5f,
+	204: 0xff5f87,
+	205: 0xff5faf,
+	206: 0xff5fd7,
+	207: 0xff5fff,
+	208: 0xff8700,
+	209: 0xff875f,
+	210: 0xff8787,
+	211: 0xff87af,
+	212: 0xff87d7,
+	213: 0xff87ff,
+	214: 0xffaf00,
+	215: 0xffaf5f,
+	216: 0xffaf87,
+	217: 0xffafaf,
+	218: 0xffafd7,
+	219: 0xffafff,
+	220: 0xffd700,
+	221: 0xffd75f,
+	222: 0xffd787,
+	223: 0xffd7af,
+	224: 0xffd7d7,
+	225: 0xffd7ff,
+	226: 0xffff00,
+	227: 0xffff5f,
+	228: 0xffff87,
+	229: 0xffffaf,
+	230: 0xffffd7,
+	231: 0xffffff,
+	232: 0x080808,
+	233: 0x121212,
+	234: 0x1c1c1c,
+	235: 0x262626,
+	236: 0x303030,
+	237: 0x3a3a3a,
+	238: 0x444444,
+	239: 0x4e4e4e,
+	240: 0x585858,
+	241: 0x626262,
+	242: 0x6c6c6c,
+	243: 0x767676,
+	244: 0x808080,
+	245: 0x8a8a8a,
+	246: 0x949494,
+	247: 0x9e9e9e,
+	248: 0xa8a8a8,
+	249: 0xb2b2b2,
+	250: 0xbcbcbc,
+	251: 0xc6c6c6,
+	252: 0xd0d0d0,
+	253: 0xdadada,
+	254: 0xe4e4e4,
+	255: 0xeeeeee,
+}
+
+// `\033]0;TITLESTR\007`
+func doTitleSequence(er *bytes.Reader) error {
+	var c byte
+	var err error
+
+	c, err = er.ReadByte()
+	if err != nil {
+		return err
+	}
+	if c != '0' && c != '2' {
+		return nil
+	}
+	c, err = er.ReadByte()
+	if err != nil {
+		return err
+	}
+	if c != ';' {
+		return nil
+	}
+	title := make([]byte, 0, 80)
+	for {
+		c, err = er.ReadByte()
+		if err != nil {
+			return err
+		}
+		if c == 0x07 || c == '\n' {
+			break
+		}
+		title = append(title, c)
+	}
+	if len(title) > 0 {
+		title8, err := syscall.UTF16PtrFromString(string(title))
+		if err == nil {
+			procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
+		}
+	}
+	return nil
+}
+
+// Write write data on console
+func (w *Writer) Write(data []byte) (n int, err error) {
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+
+	handle := w.handle
+
+	var er *bytes.Reader
+	if w.rest.Len() > 0 {
+		var rest bytes.Buffer
+		w.rest.WriteTo(&rest)
+		w.rest.Reset()
+		rest.Write(data)
+		er = bytes.NewReader(rest.Bytes())
+	} else {
+		er = bytes.NewReader(data)
+	}
+	var bw [1]byte
+loop:
+	for {
+		c1, err := er.ReadByte()
+		if err != nil {
+			break loop
+		}
+		if c1 != 0x1b {
+			bw[0] = c1
+			w.out.Write(bw[:])
+			continue
+		}
+		c2, err := er.ReadByte()
+		if err != nil {
+			break loop
+		}
+
+		if c2 == ']' {
+			w.rest.WriteByte(c1)
+			w.rest.WriteByte(c2)
+			er.WriteTo(&w.rest)
+			if bytes.IndexByte(w.rest.Bytes(), 0x07) == -1 {
+				break loop
+			}
+			er = bytes.NewReader(w.rest.Bytes()[2:])
+			err := doTitleSequence(er)
+			if err != nil {
+				break loop
+			}
+			w.rest.Reset()
+			continue
+		}
+		if c2 != 0x5b {
+			continue
+		}
+
+		w.rest.WriteByte(c1)
+		w.rest.WriteByte(c2)
+		er.WriteTo(&w.rest)
+
+		var buf bytes.Buffer
+		var m byte
+		for i, c := range w.rest.Bytes()[2:] {
+			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
+				m = c
+				er = bytes.NewReader(w.rest.Bytes()[2+i+1:])
+				w.rest.Reset()
+				break
+			}
+			buf.Write([]byte(string(c)))
+		}
+		if m == 0 {
+			break loop
+		}
+
+		switch m {
+		case 'A':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.y -= short(n)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'B':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.y += short(n)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'C':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.x += short(n)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'D':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.x -= short(n)
+			if csbi.cursorPosition.x < 0 {
+				csbi.cursorPosition.x = 0
+			}
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'E':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.x = 0
+			csbi.cursorPosition.y += short(n)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'F':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.x = 0
+			csbi.cursorPosition.y -= short(n)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'G':
+			n, err = strconv.Atoi(buf.String())
+			if err != nil {
+				continue
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			csbi.cursorPosition.x = short(n - 1)
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'H', 'f':
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			if buf.Len() > 0 {
+				token := strings.Split(buf.String(), ";")
+				switch len(token) {
+				case 1:
+					n1, err := strconv.Atoi(token[0])
+					if err != nil {
+						continue
+					}
+					csbi.cursorPosition.y = short(n1 - 1)
+				case 2:
+					n1, err := strconv.Atoi(token[0])
+					if err != nil {
+						continue
+					}
+					n2, err := strconv.Atoi(token[1])
+					if err != nil {
+						continue
+					}
+					csbi.cursorPosition.x = short(n2 - 1)
+					csbi.cursorPosition.y = short(n1 - 1)
+				}
+			} else {
+				csbi.cursorPosition.y = 0
+			}
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+		case 'J':
+			n := 0
+			if buf.Len() > 0 {
+				n, err = strconv.Atoi(buf.String())
+				if err != nil {
+					continue
+				}
+			}
+			var count, written dword
+			var cursor coord
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			switch n {
+			case 0:
+				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
+				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
+			case 1:
+				cursor = coord{x: csbi.window.left, y: csbi.window.top}
+				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
+			case 2:
+				cursor = coord{x: csbi.window.left, y: csbi.window.top}
+				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
+			}
+			procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputAttribute.Call(uintptr(handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+		case 'K':
+			n := 0
+			if buf.Len() > 0 {
+				n, err = strconv.Atoi(buf.String())
+				if err != nil {
+					continue
+				}
+			}
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			var cursor coord
+			var count, written dword
+			switch n {
+			case 0:
+				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
+				count = dword(csbi.size.x - csbi.cursorPosition.x)
+			case 1:
+				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
+				count = dword(csbi.size.x - csbi.cursorPosition.x)
+			case 2:
+				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
+				count = dword(csbi.size.x)
+			}
+			procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputAttribute.Call(uintptr(handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+		case 'm':
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			attr := csbi.attributes
+			cs := buf.String()
+			if cs == "" {
+				procSetConsoleTextAttribute.Call(uintptr(handle), uintptr(w.oldattr))
+				continue
+			}
+			token := strings.Split(cs, ";")
+			for i := 0; i < len(token); i++ {
+				ns := token[i]
+				if n, err = strconv.Atoi(ns); err == nil {
+					switch {
+					case n == 0 || n == 100:
+						attr = w.oldattr
+					case 1 <= n && n <= 5:
+						attr |= foregroundIntensity
+					case n == 7:
+						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+					case n == 22 || n == 25:
+						attr |= foregroundIntensity
+					case n == 27:
+						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
+					case 30 <= n && n <= 37:
+						attr &= backgroundMask
+						if (n-30)&1 != 0 {
+							attr |= foregroundRed
+						}
+						if (n-30)&2 != 0 {
+							attr |= foregroundGreen
+						}
+						if (n-30)&4 != 0 {
+							attr |= foregroundBlue
+						}
+					case n == 38: // set foreground color.
+						if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") {
+							if n256, err := strconv.Atoi(token[i+2]); err == nil {
+								if n256foreAttr == nil {
+									n256setup()
+								}
+								attr &= backgroundMask
+								attr |= n256foreAttr[n256]
+								i += 2
+							}
+						} else if len(token) == 5 && token[i+1] == "2" {
+							var r, g, b int
+							r, _ = strconv.Atoi(token[i+2])
+							g, _ = strconv.Atoi(token[i+3])
+							b, _ = strconv.Atoi(token[i+4])
+							i += 4
+							if r > 127 {
+								attr |= foregroundRed
+							}
+							if g > 127 {
+								attr |= foregroundGreen
+							}
+							if b > 127 {
+								attr |= foregroundBlue
+							}
+						} else {
+							attr = attr & (w.oldattr & backgroundMask)
+						}
+					case n == 39: // reset foreground color.
+						attr &= backgroundMask
+						attr |= w.oldattr & foregroundMask
+					case 40 <= n && n <= 47:
+						attr &= foregroundMask
+						if (n-40)&1 != 0 {
+							attr |= backgroundRed
+						}
+						if (n-40)&2 != 0 {
+							attr |= backgroundGreen
+						}
+						if (n-40)&4 != 0 {
+							attr |= backgroundBlue
+						}
+					case n == 48: // set background color.
+						if i < len(token)-2 && token[i+1] == "5" {
+							if n256, err := strconv.Atoi(token[i+2]); err == nil {
+								if n256backAttr == nil {
+									n256setup()
+								}
+								attr &= foregroundMask
+								attr |= n256backAttr[n256]
+								i += 2
+							}
+						} else if len(token) == 5 && token[i+1] == "2" {
+							var r, g, b int
+							r, _ = strconv.Atoi(token[i+2])
+							g, _ = strconv.Atoi(token[i+3])
+							b, _ = strconv.Atoi(token[i+4])
+							i += 4
+							if r > 127 {
+								attr |= backgroundRed
+							}
+							if g > 127 {
+								attr |= backgroundGreen
+							}
+							if b > 127 {
+								attr |= backgroundBlue
+							}
+						} else {
+							attr = attr & (w.oldattr & foregroundMask)
+						}
+					case n == 49: // reset foreground color.
+						attr &= foregroundMask
+						attr |= w.oldattr & backgroundMask
+					case 90 <= n && n <= 97:
+						attr = (attr & backgroundMask)
+						attr |= foregroundIntensity
+						if (n-90)&1 != 0 {
+							attr |= foregroundRed
+						}
+						if (n-90)&2 != 0 {
+							attr |= foregroundGreen
+						}
+						if (n-90)&4 != 0 {
+							attr |= foregroundBlue
+						}
+					case 100 <= n && n <= 107:
+						attr = (attr & foregroundMask)
+						attr |= backgroundIntensity
+						if (n-100)&1 != 0 {
+							attr |= backgroundRed
+						}
+						if (n-100)&2 != 0 {
+							attr |= backgroundGreen
+						}
+						if (n-100)&4 != 0 {
+							attr |= backgroundBlue
+						}
+					}
+					procSetConsoleTextAttribute.Call(uintptr(handle), uintptr(attr))
+				}
+			}
+		case 'h':
+			var ci consoleCursorInfo
+			cs := buf.String()
+			if cs == "5>" {
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+				ci.visible = 0
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?25" {
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+				ci.visible = 1
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?1049" {
+				if w.althandle == 0 {
+					h, _, _ := procCreateConsoleScreenBuffer.Call(uintptr(genericRead|genericWrite), 0, 0, uintptr(consoleTextmodeBuffer), 0, 0)
+					w.althandle = syscall.Handle(h)
+					if w.althandle != 0 {
+						handle = w.althandle
+					}
+				}
+			}
+		case 'l':
+			var ci consoleCursorInfo
+			cs := buf.String()
+			if cs == "5>" {
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+				ci.visible = 1
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?25" {
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+				ci.visible = 0
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?1049" {
+				if w.althandle != 0 {
+					syscall.CloseHandle(w.althandle)
+					w.althandle = 0
+					handle = w.handle
+				}
+			}
+		case 's':
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			w.oldpos = csbi.cursorPosition
+		case 'u':
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
+		}
+	}
+
+	return len(data), nil
+}
+
+type consoleColor struct {
+	rgb       int
+	red       bool
+	green     bool
+	blue      bool
+	intensity bool
+}
+
+func (c consoleColor) foregroundAttr() (attr word) {
+	if c.red {
+		attr |= foregroundRed
+	}
+	if c.green {
+		attr |= foregroundGreen
+	}
+	if c.blue {
+		attr |= foregroundBlue
+	}
+	if c.intensity {
+		attr |= foregroundIntensity
+	}
+	return
+}
+
+func (c consoleColor) backgroundAttr() (attr word) {
+	if c.red {
+		attr |= backgroundRed
+	}
+	if c.green {
+		attr |= backgroundGreen
+	}
+	if c.blue {
+		attr |= backgroundBlue
+	}
+	if c.intensity {
+		attr |= backgroundIntensity
+	}
+	return
+}
+
+var color16 = []consoleColor{
+	{0x000000, false, false, false, false},
+	{0x000080, false, false, true, false},
+	{0x008000, false, true, false, false},
+	{0x008080, false, true, true, false},
+	{0x800000, true, false, false, false},
+	{0x800080, true, false, true, false},
+	{0x808000, true, true, false, false},
+	{0xc0c0c0, true, true, true, false},
+	{0x808080, false, false, false, true},
+	{0x0000ff, false, false, true, true},
+	{0x00ff00, false, true, false, true},
+	{0x00ffff, false, true, true, true},
+	{0xff0000, true, false, false, true},
+	{0xff00ff, true, false, true, true},
+	{0xffff00, true, true, false, true},
+	{0xffffff, true, true, true, true},
+}
+
+type hsv struct {
+	h, s, v float32
+}
+
+func (a hsv) dist(b hsv) float32 {
+	dh := a.h - b.h
+	switch {
+	case dh > 0.5:
+		dh = 1 - dh
+	case dh < -0.5:
+		dh = -1 - dh
+	}
+	ds := a.s - b.s
+	dv := a.v - b.v
+	return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv)))
+}
+
+func toHSV(rgb int) hsv {
+	r, g, b := float32((rgb&0xFF0000)>>16)/256.0,
+		float32((rgb&0x00FF00)>>8)/256.0,
+		float32(rgb&0x0000FF)/256.0
+	min, max := minmax3f(r, g, b)
+	h := max - min
+	if h > 0 {
+		if max == r {
+			h = (g - b) / h
+			if h < 0 {
+				h += 6
+			}
+		} else if max == g {
+			h = 2 + (b-r)/h
+		} else {
+			h = 4 + (r-g)/h
+		}
+	}
+	h /= 6.0
+	s := max - min
+	if max != 0 {
+		s /= max
+	}
+	v := max
+	return hsv{h: h, s: s, v: v}
+}
+
+type hsvTable []hsv
+
+func toHSVTable(rgbTable []consoleColor) hsvTable {
+	t := make(hsvTable, len(rgbTable))
+	for i, c := range rgbTable {
+		t[i] = toHSV(c.rgb)
+	}
+	return t
+}
+
+func (t hsvTable) find(rgb int) consoleColor {
+	hsv := toHSV(rgb)
+	n := 7
+	l := float32(5.0)
+	for i, p := range t {
+		d := hsv.dist(p)
+		if d < l {
+			l, n = d, i
+		}
+	}
+	return color16[n]
+}
+
+func minmax3f(a, b, c float32) (min, max float32) {
+	if a < b {
+		if b < c {
+			return a, c
+		} else if a < c {
+			return a, b
+		} else {
+			return c, b
+		}
+	} else {
+		if a < c {
+			return b, c
+		} else if b < c {
+			return b, a
+		} else {
+			return c, a
+		}
+	}
+}
+
+var n256foreAttr []word
+var n256backAttr []word
+
+func n256setup() {
+	n256foreAttr = make([]word, 256)
+	n256backAttr = make([]word, 256)
+	t := toHSVTable(color16)
+	for i, rgb := range color256 {
+		c := t.find(rgb)
+		n256foreAttr[i] = c.foregroundAttr()
+		n256backAttr[i] = c.backgroundAttr()
+	}
+}
diff --git a/vendor/github.com/mattn/go-colorable/noncolorable.go b/vendor/github.com/mattn/go-colorable/noncolorable.go
new file mode 100644
index 0000000000000000000000000000000000000000..9721e16f4bf4b6131fdd1050add2e0456304916c
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/noncolorable.go
@@ -0,0 +1,55 @@
+package colorable
+
+import (
+	"bytes"
+	"io"
+)
+
+// NonColorable hold writer but remove escape sequence.
+type NonColorable struct {
+	out io.Writer
+}
+
+// NewNonColorable return new instance of Writer which remove escape sequence from Writer.
+func NewNonColorable(w io.Writer) io.Writer {
+	return &NonColorable{out: w}
+}
+
+// Write write data on console
+func (w *NonColorable) Write(data []byte) (n int, err error) {
+	er := bytes.NewReader(data)
+	var bw [1]byte
+loop:
+	for {
+		c1, err := er.ReadByte()
+		if err != nil {
+			break loop
+		}
+		if c1 != 0x1b {
+			bw[0] = c1
+			w.out.Write(bw[:])
+			continue
+		}
+		c2, err := er.ReadByte()
+		if err != nil {
+			break loop
+		}
+		if c2 != 0x5b {
+			continue
+		}
+
+		var buf bytes.Buffer
+		for {
+			c, err := er.ReadByte()
+			if err != nil {
+				break loop
+			}
+			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
+				break
+			}
+			buf.Write([]byte(string(c)))
+		}
+	}
+
+	return len(data), nil
+}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/COMPARE-jsonnet.sh b/vendor/github.com/strickyak/jsonnet_cgo/COMPARE-jsonnet.sh
deleted file mode 100644
index f33e7ae36607e34ef75f9b061f5ece651d09e83e..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/COMPARE-jsonnet.sh
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/bin/bash
-
-# To help me keep up-to-date with jsonnet,
-# this will compare our copies of jsonnet files
-# with the ones in a jsonnet directory.
-# See "Usage:" a few lines below.
-
-case "$#/$1" in
-	0/ )
-		set ../../google/jsonnet/
-		;;
-	1/*/jsonnet/ )
-		: ok
-		;;
-	* )
-		echo >&2 '
-Usage:
-	sh  $0  ?/path/to/jsonnet/?
-
-This command takes one argument, the jsonnet repository directory,
-ending in /jsonnet/.  The default is ../../google/jsonnet/.
-'
-		exit 13
-		;;
-esac
-
-J="$1"
-test -d "$J"
-
-for x in \
-	ast.h \
-	desugarer.cpp \
-	desugarer.h \
-	formatter.cpp \
-	formatter.h \
-	json.h \
-	lexer.cpp \
-	lexer.h \
-	libjsonnet.cpp \
-	libjsonnet.h \
-	md5.cpp \
-	md5.h \
-	parser.cpp \
-	parser.h \
-	pass.cpp \
-	pass.h \
-	state.h \
-	static_analysis.cpp \
-	static_analysis.h \
-	static_error.h \
-	std.jsonnet.h \
-	string_utils.cpp \
-	string_utils.h \
-	unicode.h \
-	vm.cpp \
-	vm.h \
-	#
-do
-	ok=false
-	for subdir in core cpp third_party/md5 include
-	do
-		if cmp "$J/$subdir/$x" "./$x" 2>/dev/null
-		then
-	    		ok=true
-			break
-		fi
-	done
-
-	if $ok
-	then
-		echo "ok: $x"
-	else
-		echo "******** NOT OK: $x"
-	fi
-done
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.jsonnet b/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.jsonnet
deleted file mode 100644
index d645695673349e3947e8e5ae42332d0ac3164cd7..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.jsonnet
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.md5 b/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.md5
deleted file mode 100644
index e1ec4b8defc5999e6ac6113cff6edbd11a004028..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/LICENSE.md5
+++ /dev/null
@@ -1,29 +0,0 @@
-MD5
-Converted to C++ class by Frank Thilo (thilo@unix-ag.org)
-for bzflag (http://www.bzflag.org)
- 
-based on:
-
-md5.h and md5.c
-reference implementation of RFC 1321
- 
-Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-rights reserved.
- 
-License to copy and use this software is granted provided that it
-is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-Algorithm" in all material mentioning or referencing this software
-or this function.
- 
-License is also granted to make and use derivative works provided
-that such works are identified as "derived from the RSA Data
-Security, Inc. MD5 Message-Digest Algorithm" in all material
-mentioning or referencing the derived work.
- 
-RSA Data Security, Inc. makes no representations concerning either
-the merchantability of this software or the suitability of this
-software for any particular purpose. It is provided "as is"
-without express or implied warranty of any kind.
- 
-These notices must be retained in any copies of any part of this
-documentation and/or software.
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/README.md b/vendor/github.com/strickyak/jsonnet_cgo/README.md
deleted file mode 100644
index 7633a565cc458efae11caddd2935229701b8d039..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-jsonnet_cgo
-===========
-
-Simple golang cgo wrapper around JSonnet VM.
-
-Everything in libjsonnet.h is covered except the multi-file evaluators.
-
-See jsonnet_test.go for how to use it.
-
-Quick example:
-
-        vm := jsonnet.Make()
-        vm.ExtVar("color", "purple")
-
-        x, err := vm.EvaluateSnippet(`Test_Demo`, `"dark " + std.extVar("color")`)
-
-        if err != nil {
-                panic(err)
-        }
-        if x != "\"dark purple\"\n" {
-                panic("fail: we got " + x)
-        }
-
-        vm.Destroy()
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/ast.h b/vendor/github.com/strickyak/jsonnet_cgo/ast.h
deleted file mode 100644
index 499821404df3493cf400ebe000285076d0bd0efb..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/ast.h
+++ /dev/null
@@ -1,898 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_AST_H
-#define JSONNET_AST_H
-
-#include <cstdlib>
-#include <cassert>
-
-#include <iostream>
-#include <string>
-#include <map>
-#include <vector>
-
-#include "lexer.h"
-#include "unicode.h"
-
-enum ASTType {
-    AST_APPLY,
-    AST_ARRAY,
-    AST_ARRAY_COMPREHENSION,
-    AST_ARRAY_COMPREHENSION_SIMPLE,
-    AST_ASSERT,
-    AST_BINARY,
-    AST_BUILTIN_FUNCTION,
-    AST_CONDITIONAL,
-    AST_DESUGARED_OBJECT,
-    AST_DOLLAR,
-    AST_ERROR,
-    AST_FUNCTION,
-    AST_IMPORT,
-    AST_IMPORTSTR,
-    AST_INDEX,
-    AST_IN_SUPER,
-    AST_LITERAL_BOOLEAN,
-    AST_LITERAL_NULL,
-    AST_LITERAL_NUMBER,
-    AST_LITERAL_STRING,
-    AST_LOCAL,
-    AST_OBJECT,
-    AST_OBJECT_COMPREHENSION,
-    AST_OBJECT_COMPREHENSION_SIMPLE,
-    AST_PARENS,
-    AST_SELF,
-    AST_SUPER_INDEX,
-    AST_UNARY,
-    AST_VAR
-};
-
-/** Represents a variable / parameter / field name. */
-struct Identifier {
-    UString name;
-    Identifier(const UString &name)
-      : name(name)
-    { }
-};
-
-static inline std::ostream &operator<<(std::ostream &o, const Identifier *id)
-{
-    o << encode_utf8(id->name);
-    return o;
-}
-
-typedef std::vector<const Identifier *> Identifiers;
-
-
-/** All AST nodes are subtypes of this class.
- */
-struct AST {
-    LocationRange location;
-    ASTType type;
-    Fodder openFodder;
-    Identifiers freeVariables;
-    AST(const LocationRange &location, ASTType type, const Fodder &open_fodder)
-      : location(location), type(type), openFodder(open_fodder)
-    {
-    }
-    virtual ~AST(void)
-    {
-    }
-};
-
-typedef std::vector<AST*> ASTs;
-
-/** Either an arg in a function apply, or a param in a closure / other function definition.
- *
- * They happen to have exactly the same structure.
- *
- * In the case of an arg, the id is optional and the expr is required.  Presence of the id indicates
- * that this is a named rather than positional argument.
- *
- * In the case of a param, the id is required and if expr is given, it is a default argument to be
- * used when no argument is bound to the param.
- */
-struct ArgParam {
-    Fodder idFodder;  // Empty if no id.
-    const Identifier *id;  // nullptr if there isn't one
-    Fodder eqFodder; // Empty if no id or no expr.
-    AST *expr;  // nullptr if there wasn't one.
-    Fodder commaFodder;  // Before the comma (if there is a comma).
-    // Only has id
-    ArgParam (const Fodder &id_fodder, const Identifier *id, const Fodder &comma_fodder)
-      : idFodder(id_fodder), id(id), expr(nullptr), commaFodder(comma_fodder)
-    { }
-    // Only has expr
-    ArgParam (AST *expr, const Fodder &comma_fodder)
-      : id(nullptr), expr(expr), commaFodder(comma_fodder)
-    { }
-    // Has both id and expr
-    ArgParam (const Fodder &id_fodder, const Identifier *id, const Fodder &eq_fodder,
-              AST *expr, const Fodder &comma_fodder)
-      : idFodder(id_fodder), id(id), eqFodder(eq_fodder), expr(expr), commaFodder(comma_fodder)
-    { }
-};
-
-typedef std::vector<ArgParam> ArgParams;
-
-/** Used in Object & Array Comprehensions. */
-struct ComprehensionSpec {
-    enum Kind {
-        FOR,
-        IF
-    };
-    Kind kind;
-    Fodder openFodder;
-    Fodder varFodder; // {} when kind != SPEC_FOR.
-    const Identifier *var;  // Null when kind != SPEC_FOR.
-    Fodder inFodder; // {} when kind != SPEC_FOR.
-    AST *expr;
-    ComprehensionSpec(Kind kind, const Fodder &open_fodder, const Fodder &var_fodder,
-                      const Identifier *var, const Fodder &in_fodder, AST *expr)
-      : kind(kind), openFodder(open_fodder), varFodder(var_fodder), var(var), inFodder(in_fodder),
-        expr(expr)
-    { }
-};
-
-
-/** Represents function calls. */
-struct Apply : public AST {
-    AST *target;
-    Fodder fodderL;
-    ArgParams args;
-    bool trailingComma;
-    Fodder fodderR;
-    Fodder tailstrictFodder;
-    bool tailstrict;
-    Apply(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &fodder_l,
-          const ArgParams &args, bool trailing_comma, const Fodder &fodder_r,
-          const Fodder &tailstrict_fodder, bool tailstrict)
-      : AST(lr, AST_APPLY, open_fodder), target(target), fodderL(fodder_l), args(args),
-        trailingComma(trailing_comma), fodderR(fodder_r), tailstrictFodder(tailstrict_fodder),
-        tailstrict(tailstrict)
-    { }
-};
-
-/** Represents e { }.  Desugared to e + { }. */
-struct ApplyBrace : public AST {
-    AST *left;
-    AST *right;  // This is always an object or object comprehension.
-    ApplyBrace(const LocationRange &lr, const Fodder &open_fodder, AST *left, AST *right)
-      : AST(lr, AST_BINARY, open_fodder), left(left), right(right)
-    { }
-};
-
-/** Represents array constructors [1, 2, 3]. */
-struct Array : public AST {
-    struct Element {
-        AST *expr;
-        Fodder commaFodder;
-        Element(AST *expr, const Fodder &comma_fodder)
-          : expr(expr), commaFodder(comma_fodder)
-        { }
-    };
-    typedef std::vector<Element> Elements;
-    Elements elements;
-    bool trailingComma;
-    Fodder closeFodder;
-    Array(const LocationRange &lr, const Fodder &open_fodder, const Elements &elements,
-          bool trailing_comma, const Fodder &close_fodder)
-      : AST(lr, AST_ARRAY, open_fodder), elements(elements), trailingComma(trailing_comma),
-        closeFodder(close_fodder)
-    { }
-};
-
-/** Represents array comprehensions (which are like Python list comprehensions). */
-struct ArrayComprehension : public AST {
-    AST* body;
-    Fodder commaFodder;
-    bool trailingComma;
-    std::vector<ComprehensionSpec> specs;
-    Fodder closeFodder;
-    ArrayComprehension(const LocationRange &lr, const Fodder &open_fodder, AST *body,
-                       const Fodder &comma_fodder, bool trailing_comma,
-                       const std::vector<ComprehensionSpec> &specs, const Fodder &close_fodder)
-      : AST(lr, AST_ARRAY_COMPREHENSION, open_fodder), body(body), commaFodder(comma_fodder),
-        trailingComma(trailing_comma), specs(specs), closeFodder(close_fodder)
-    {
-        assert(specs.size() > 0);
-    }
-};
-
-/** Represents an assert expression (not an object-level assert).
- * 
- * After parsing, message can be nullptr indicating that no message was specified. This AST is
- * elimiated by desugaring.
- */
-struct Assert : public AST {
-    AST *cond;
-    Fodder colonFodder;
-    AST *message;
-    Fodder semicolonFodder;
-    AST *rest;
-    Assert(const LocationRange &lr, const Fodder &open_fodder, AST *cond,
-           const Fodder &colon_fodder, AST *message, const Fodder &semicolon_fodder, AST *rest)
-      : AST(lr, AST_ASSERT, open_fodder), cond(cond), colonFodder(colon_fodder),
-        message(message), semicolonFodder(semicolon_fodder), rest(rest)
-    { }
-};
-
-enum BinaryOp {
-    BOP_MULT,
-    BOP_DIV,
-    BOP_PERCENT,
-
-    BOP_PLUS,
-    BOP_MINUS,
-
-    BOP_SHIFT_L,
-    BOP_SHIFT_R,
-
-    BOP_GREATER,
-    BOP_GREATER_EQ,
-    BOP_LESS,
-    BOP_LESS_EQ,
-    BOP_IN,
-
-    BOP_MANIFEST_EQUAL,
-    BOP_MANIFEST_UNEQUAL,
-
-    BOP_BITWISE_AND,
-    BOP_BITWISE_XOR,
-    BOP_BITWISE_OR,
-
-    BOP_AND,
-    BOP_OR
-};
-
-static inline std::string bop_string (BinaryOp bop)
-{
-    switch (bop) {
-        case BOP_MULT: return "*";
-        case BOP_DIV: return "/";
-        case BOP_PERCENT: return "%";
-
-        case BOP_PLUS: return "+";
-        case BOP_MINUS: return "-";
-
-        case BOP_SHIFT_L: return "<<";
-        case BOP_SHIFT_R: return ">>";
-
-        case BOP_GREATER: return ">";
-        case BOP_GREATER_EQ: return ">=";
-        case BOP_LESS: return "<";
-        case BOP_LESS_EQ: return "<=";
-        case BOP_IN: return "in";
-
-        case BOP_MANIFEST_EQUAL: return "==";
-        case BOP_MANIFEST_UNEQUAL: return "!=";
-
-        case BOP_BITWISE_AND: return "&";
-        case BOP_BITWISE_XOR: return "^";
-        case BOP_BITWISE_OR: return "|";
-
-        case BOP_AND: return "&&";
-        case BOP_OR: return "||";
-
-        default:
-        std::cerr << "INTERNAL ERROR: Unrecognised binary operator: " << bop << std::endl;
-        std::abort();
-    }
-}
-
-/** Represents binary operators. */
-struct Binary : public AST {
-    AST *left;
-    Fodder opFodder;
-    BinaryOp op;
-    AST *right;
-    Binary(const LocationRange &lr, const Fodder &open_fodder, AST *left, const Fodder &op_fodder,
-           BinaryOp op, AST *right)
-      : AST(lr, AST_BINARY, open_fodder), left(left), opFodder(op_fodder), op(op), right(right)
-    { }
-};
-
-/** Represents built-in functions.
- *
- * There is no parse rule to build this AST.  Instead, it is used to build the std object in the
- * interpreter.
- */
-struct BuiltinFunction : public AST {
-    std::string name;
-    Identifiers params;
-    BuiltinFunction(const LocationRange &lr, const std::string &name,
-                    const Identifiers &params)
-      : AST(lr, AST_BUILTIN_FUNCTION, Fodder{}), name(name), params(params)
-    { }
-};
-
-/** Represents if then else.
- * 
- * After parsing, branchFalse can be nullptr indicating that no else branch was specified.  The
- * desugarer fills this in with a LiteralNull.
- */
-struct Conditional : public AST {
-    AST *cond;
-    Fodder thenFodder;
-    AST *branchTrue;
-    Fodder elseFodder;
-    AST *branchFalse;
-    Conditional(const LocationRange &lr, const Fodder &open_fodder, AST *cond,
-                const Fodder &then_fodder, AST *branch_true, const Fodder &else_fodder,
-                AST *branch_false)
-      : AST(lr, AST_CONDITIONAL, open_fodder), cond(cond), thenFodder(then_fodder),
-        branchTrue(branch_true), elseFodder(else_fodder), branchFalse(branch_false)
-    { }
-};
-
-/** Represents the $ keyword. */
-struct Dollar : public AST {
-    Dollar(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_DOLLAR, open_fodder)
-    { }
-};
-
-/** Represents error e. */
-struct Error : public AST {
-    AST *expr;
-    Error(const LocationRange &lr, const Fodder &open_fodder, AST *expr)
-      : AST(lr, AST_ERROR, open_fodder), expr(expr)
-    { }
-};
-
-/** Represents closures. */
-struct Function : public AST {
-    Fodder parenLeftFodder;
-    ArgParams params;
-    bool trailingComma;
-    Fodder parenRightFodder;
-    AST *body;
-    Function(const LocationRange &lr, const Fodder &open_fodder, const Fodder &paren_left_fodder,
-             const ArgParams &params, bool trailing_comma, const Fodder &paren_right_fodder,
-             AST *body)
-      : AST(lr, AST_FUNCTION, open_fodder), parenLeftFodder(paren_left_fodder),
-        params(params), trailingComma(trailing_comma), parenRightFodder(paren_right_fodder),
-        body(body)
-    { }
-};
-
-struct LiteralString;
-
-/** Represents import "file". */
-struct Import : public AST {
-    LiteralString *file;
-    Import(const LocationRange &lr, const Fodder &open_fodder, LiteralString *file)
-      : AST(lr, AST_IMPORT, open_fodder), file(file)
-    { }
-};
-
-/** Represents importstr "file". */
-struct Importstr : public AST {
-    LiteralString *file;
-    Importstr(const LocationRange &lr, const Fodder &open_fodder, LiteralString *file)
-      : AST(lr, AST_IMPORTSTR, open_fodder), file(file)
-    { }
-};
-
-/** Represents both e[e] and the syntax sugar e.f.
- *
- * One of index and id will be nullptr before desugaring.  After desugaring id will be nullptr.
- */
-struct Index : public AST {
-    AST *target;
-    Fodder dotFodder;  // When index is being used, this is the fodder before the [.
-    bool isSlice;
-    AST *index;
-    Fodder endColonFodder;  // When end is being used, this is the fodder before the :.
-    AST *end;
-    Fodder stepColonFodder;  // When step is being used, this is the fodder before the :.
-    AST *step;
-    Fodder idFodder;  // When index is being used, this is the fodder before the ].
-    const Identifier *id;
-    // Use this constructor for e.f
-    Index(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &dot_fodder,
-          const Fodder &id_fodder, const Identifier *id)
-      : AST(lr, AST_INDEX, open_fodder), target(target), dotFodder(dot_fodder), isSlice(false),
-        index(nullptr), end(nullptr), step(nullptr), idFodder(id_fodder), id(id)
-    { }
-    // Use this constructor for e[x:y:z] with nullptr for index, end or step if not present. 
-    Index(const LocationRange &lr, const Fodder &open_fodder, AST *target, const Fodder &dot_fodder,
-          bool is_slice, AST *index, const Fodder &end_colon_fodder, AST *end,
-          const Fodder &step_colon_fodder, AST *step, const Fodder &id_fodder)
-      : AST(lr, AST_INDEX, open_fodder), target(target), dotFodder(dot_fodder), isSlice(is_slice),
-        index(index), endColonFodder(end_colon_fodder), end(end),
-        stepColonFodder(step_colon_fodder), step(step), idFodder(id_fodder), id(nullptr)
-    { }
-};
-
-/** Represents local x = e; e.  After desugaring, functionSugar is false. */
-struct Local : public AST {
-    struct Bind {
-        Fodder varFodder;
-        const Identifier *var;
-        Fodder opFodder;
-        AST *body;
-        bool functionSugar;
-        Fodder parenLeftFodder;
-        ArgParams params;  // If functionSugar == true
-        bool trailingComma;
-        Fodder parenRightFodder;
-        Fodder closeFodder;
-        Bind(const Fodder &var_fodder, const Identifier *var, const Fodder &op_fodder, AST *body,
-             bool function_sugar, const Fodder &paren_left_fodder, const ArgParams &params,
-             bool trailing_comma, const Fodder &paren_right_fodder, const Fodder &close_fodder)
-          : varFodder(var_fodder), var(var), opFodder(op_fodder), body(body),
-            functionSugar(function_sugar), parenLeftFodder(paren_left_fodder), params(params),
-            trailingComma(trailing_comma), parenRightFodder(paren_right_fodder),
-            closeFodder(close_fodder)
-        { }
-    };
-    typedef std::vector<Bind> Binds;
-    Binds binds;
-    AST *body;
-    Local(const LocationRange &lr, const Fodder &open_fodder, const Binds &binds, AST *body)
-      : AST(lr, AST_LOCAL, open_fodder), binds(binds), body(body)
-    { }
-};
-
-/** Represents true and false. */
-struct LiteralBoolean : public AST {
-    bool value;
-    LiteralBoolean(const LocationRange &lr, const Fodder &open_fodder, bool value)
-      : AST(lr, AST_LITERAL_BOOLEAN, open_fodder), value(value)
-    { }
-};
-
-/** Represents the null keyword. */
-struct LiteralNull : public AST {
-    LiteralNull(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_LITERAL_NULL, open_fodder)
-    { }
-};
-
-/** Represents JSON numbers. */
-struct LiteralNumber : public AST {
-    double value;
-    std::string originalString;
-    LiteralNumber(const LocationRange &lr, const Fodder &open_fodder, const std::string &str)
-      : AST(lr, AST_LITERAL_NUMBER, open_fodder), value(strtod(str.c_str(), nullptr)),
-        originalString(str)
-    { }
-};
-
-/** Represents JSON strings. */
-struct LiteralString : public AST {
-    UString value;
-    enum TokenKind { SINGLE, DOUBLE, BLOCK, VERBATIM_SINGLE, VERBATIM_DOUBLE };
-    TokenKind tokenKind;
-    std::string blockIndent;  // Only contains ' ' and '\t'.
-    std::string blockTermIndent;  // Only contains ' ' and '\t'.
-    LiteralString(const LocationRange &lr, const Fodder &open_fodder, const UString &value,
-                  TokenKind token_kind, const std::string &block_indent,
-                  const std::string &block_term_indent)
-      : AST(lr, AST_LITERAL_STRING, open_fodder), value(value), tokenKind(token_kind),
-        blockIndent(block_indent), blockTermIndent(block_term_indent)
-    { }
-};
-
-
-struct ObjectField {
-    // Depending on the kind of Jsonnet field, the fields of this C++ class are used for storing
-    // different parts of the AST.
-    enum Kind {
-
-        // <fodder1> 'assert' <expr2>
-        // [ <opFodder> : <expr3> ]
-        // <commaFodder>
-        ASSERT, 
-
-        // <fodder1> id
-        // [ <fodderL> '(' <params> <fodderR> ')' ]
-        // <opFodder> [+]:[:[:]] <expr2>
-        // <commaFodder>
-        FIELD_ID,
-
-        // <fodder1> '[' <expr1> <fodder2> ']'
-        // [ <fodderL> '(' <params> <fodderR> ')' ]
-        // <opFodder> [+]:[:[:]] <expr2>
-        // <commaFodder>
-        FIELD_EXPR,
-
-        // <expr1>
-        // <fodderL> '(' <params> <fodderR> ')'
-        // <opFodder> [+]:[:[:]] <expr2>
-        // <commaFodder>
-        FIELD_STR,
-
-        // <fodder1> 'local' <fodder2> id
-        // [ <fodderL> '(' <params> <fodderR> ')' ]
-        // [ <opFodder> = <expr2> ]
-        // <commaFodder>
-        LOCAL,
-    };
-
-    // NOTE TO SELF: sort out fodder1-4, then modify desugarer (maybe) parser and unparser.
-
-    enum Hide {
-        HIDDEN,  // f:: e
-        INHERIT,  // f: e
-        VISIBLE,  // f::: e
-    };
-    enum Kind kind;
-    Fodder fodder1, fodder2, fodderL, fodderR;
-    enum Hide hide;  // (ignore if kind != FIELD_something
-    bool superSugar;  // +:  (ignore if kind != FIELD_something)
-    bool methodSugar;  // f(x, y, z): ...  (ignore if kind  == ASSERT)
-    AST *expr1;  // Not in scope of the object
-    const Identifier *id;
-    ArgParams params;  // If methodSugar == true then holds the params.
-    bool trailingComma;  // If methodSugar == true then remembers the trailing comma.
-    Fodder opFodder;  // Before the : or =
-    AST *expr2, *expr3;  // In scope of the object (can see self).
-    Fodder commaFodder;  // If this field is followed by a comma, this is its fodder.
-
-    ObjectField(
-        enum Kind kind, const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, enum Hide hide, bool super_sugar, bool method_sugar, AST *expr1,
-        const Identifier *id, const ArgParams &params, bool trailing_comma, const Fodder &op_fodder,
-        AST *expr2, AST *expr3, const Fodder &comma_fodder)
-        : kind(kind), fodder1(fodder1), fodder2(fodder2), fodderL(fodder_l), fodderR(fodder_r),
-          hide(hide), superSugar(super_sugar), methodSugar(method_sugar), expr1(expr1), id(id),
-          params(params), trailingComma(trailing_comma), opFodder(op_fodder), expr2(expr2),
-          expr3(expr3), commaFodder(comma_fodder)
-    {
-        // Enforce what is written in comments above.
-        assert(kind != ASSERT || (hide == VISIBLE && !superSugar && !methodSugar));
-        assert(kind != LOCAL || (hide == VISIBLE && !superSugar));
-        assert(kind != FIELD_ID || (id != nullptr && expr1 == nullptr));
-        assert(kind == FIELD_ID || kind == LOCAL || id == nullptr);
-        assert(methodSugar || (params.size() == 0 && !trailingComma));
-        assert(kind == ASSERT || expr3 == nullptr);
-    }
-    // For when we don't know if it's a function or not.
-    static ObjectField Local(
-        const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, bool method_sugar, const Identifier *id, const ArgParams &params,
-        bool trailing_comma, const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
-    {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, fodder_l, fodder_r, VISIBLE, false, method_sugar, nullptr, id,
-            params, trailing_comma, op_fodder, body, nullptr, comma_fodder);
-    }
-    static ObjectField Local(
-        const Fodder &fodder1, const Fodder &fodder2, const Identifier *id,
-        const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
-    {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, Fodder{}, Fodder{}, VISIBLE, false, false, nullptr, id,
-            ArgParams{}, false, op_fodder, body, nullptr, comma_fodder);
-    }
-    static ObjectField LocalMethod(
-        const Fodder &fodder1, const Fodder &fodder2, const Fodder &fodder_l,
-        const Fodder &fodder_r, const Identifier *id, const ArgParams &params, bool trailing_comma,
-        const Fodder &op_fodder, AST *body, const Fodder &comma_fodder)
-    {
-        return ObjectField(
-            LOCAL, fodder1, fodder2, fodder_l, fodder_r, VISIBLE, false, true, nullptr, id, params,
-            trailing_comma, op_fodder, body, nullptr, comma_fodder);
-    }
-    static ObjectField Assert(const Fodder &fodder1, AST *body, const Fodder &op_fodder, AST *msg,
-                              const Fodder &comma_fodder)
-    {
-        return ObjectField(
-            ASSERT, fodder1, Fodder{}, Fodder{}, Fodder{}, VISIBLE, false, false, nullptr, nullptr,
-            ArgParams{}, false, op_fodder, body, msg, comma_fodder);
-    }
-};
-typedef std::vector<ObjectField> ObjectFields;
-
-/** Represents object constructors { f: e ... }.
- *
- * The trailing comma is only allowed if fields.size() > 0.  Converted to DesugaredObject during
- * desugaring.
- */
-struct Object : public AST {
-    ObjectFields fields;
-    bool trailingComma;
-    Fodder closeFodder;
-    Object(const LocationRange &lr, const Fodder &open_fodder, const ObjectFields &fields,
-           bool trailing_comma, const Fodder &close_fodder)
-      : AST(lr, AST_OBJECT, open_fodder), fields(fields), trailingComma(trailing_comma),
-        closeFodder(close_fodder)
-    {
-        assert(fields.size() > 0 || !trailing_comma);
-        if (fields.size() > 0)
-            assert(trailing_comma || fields[fields.size() - 1].commaFodder.size() == 0);
-    }
-};
-
-/** Represents object constructors { f: e ... } after desugaring.
- *
- * The assertions either return true or raise an error.
- */
-struct DesugaredObject : public AST {
-    struct Field {
-        enum ObjectField::Hide hide;
-        AST *name;
-        AST *body;
-        Field(enum ObjectField::Hide hide, AST *name, AST *body)
-          : hide(hide), name(name), body(body)
-        { }
-    };
-    typedef std::vector<Field> Fields;
-    ASTs asserts;
-    Fields fields;
-    DesugaredObject(const LocationRange &lr, const ASTs &asserts, const Fields &fields)
-      : AST(lr, AST_DESUGARED_OBJECT, Fodder{}), asserts(asserts), fields(fields)
-    { }
-};
-
-
-/** Represents object comprehension { [e]: e for x in e for.. if... }. */
-struct ObjectComprehension : public AST {
-    ObjectFields fields;
-    bool trailingComma;
-    std::vector<ComprehensionSpec> specs;
-    Fodder closeFodder;
-    ObjectComprehension(const LocationRange &lr, const Fodder &open_fodder,
-                        const ObjectFields &fields, bool trailing_comma,
-                        const std::vector<ComprehensionSpec> &specs, const Fodder &close_fodder)
-                        
-      : AST(lr, AST_OBJECT_COMPREHENSION, open_fodder), fields(fields),
-        trailingComma(trailing_comma), specs(specs), closeFodder(close_fodder)
-    { }
-};
-
-/** Represents post-desugaring object comprehension { [e]: e for x in e }. */
-struct ObjectComprehensionSimple : public AST {
-    AST *field;
-    AST *value;
-    const Identifier *id;
-    AST *array;
-    ObjectComprehensionSimple(const LocationRange &lr, AST *field, AST *value,
-                              const Identifier *id, AST *array)
-      : AST(lr, AST_OBJECT_COMPREHENSION_SIMPLE, Fodder{}), field(field), value(value), id(id),
-        array(array)
-    { }
-};
-
-/** Represents (e), which is desugared. */
-struct Parens : public AST {
-    AST *expr;
-    Fodder closeFodder;
-    Parens(const LocationRange &lr, const Fodder &open_fodder, AST *expr,
-           const Fodder &close_fodder)
-      : AST(lr, AST_PARENS, open_fodder), expr(expr), closeFodder(close_fodder)
-    { }
-};
-
-/** Represents the self keyword. */
-struct Self : public AST {
-    Self(const LocationRange &lr, const Fodder &open_fodder)
-      : AST(lr, AST_SELF, open_fodder)
-    { }
-};
-
-/** Represents the super[e] and super.f constructs.
- *
- * Either index or identifier will be set before desugaring.  After desugaring, id will be
- * nullptr.
- */
-struct SuperIndex : public AST {
-    Fodder dotFodder;
-    AST *index;
-    Fodder idFodder;
-    const Identifier *id;
-    SuperIndex(const LocationRange &lr, const Fodder &open_fodder, const Fodder &dot_fodder,
-               AST *index, const Fodder &id_fodder, const Identifier *id)
-      : AST(lr, AST_SUPER_INDEX, open_fodder), dotFodder(dot_fodder), index(index),
-        idFodder(id_fodder), id(id)
-    { }
-};
-
-/** Represents the e in super construct.
- */
-struct InSuper : public AST {
-    AST *element;
-    Fodder inFodder;
-    Fodder superFodder;
-    InSuper(const LocationRange &lr, const Fodder &open_fodder,
-            AST *element, const Fodder &in_fodder, const Fodder &super_fodder)
-      : AST(lr, AST_IN_SUPER, open_fodder), element(element),
-        inFodder(in_fodder), superFodder(super_fodder)
-    { }
-};
-
-enum UnaryOp {
-    UOP_NOT,
-    UOP_BITWISE_NOT,
-    UOP_PLUS,
-    UOP_MINUS
-};
-
-static inline std::string uop_string (UnaryOp uop)
-{
-    switch (uop) {
-        case UOP_PLUS: return "+";
-        case UOP_MINUS: return "-";
-        case UOP_BITWISE_NOT: return "~";
-        case UOP_NOT: return "!";
-
-        default:
-        std::cerr << "INTERNAL ERROR: Unrecognised unary operator: " << uop << std::endl;
-        std::abort();
-    }
-}
-
-/** Represents unary operators. */
-struct Unary : public AST {
-   UnaryOp op;
-    AST *expr;
-    Unary(const LocationRange &lr, const Fodder &open_fodder, UnaryOp op, AST *expr)
-      : AST(lr, AST_UNARY, open_fodder), op(op), expr(expr)
-    { }
-};
-
-/** Represents variables. */
-struct Var : public AST {
-    const Identifier *id;
-    Var(const LocationRange &lr, const Fodder &open_fodder, const Identifier *id)
-      : AST(lr, AST_VAR, open_fodder), id(id)
-    { }
-};
-
-
-/** Allocates ASTs on demand, frees them in its destructor.
- */
-class Allocator {
-    std::map<UString, const Identifier*> internedIdentifiers;
-    ASTs allocated;
-    public:
-    template <class T, class... Args> T* make(Args&&... args)
-    {
-        auto r = new T(std::forward<Args>(args)...);
-        allocated.push_back(r);
-        return r;
-    }
-
-    template <class T> T *clone(T * ast) {
-        auto r = new T(*ast);
-        allocated.push_back(r);
-        return r;
-    }
-    /** Returns interned identifiers.
-     *
-     * The location used in the Identifier AST is that of the first one parsed.
-     */
-    const Identifier *makeIdentifier(const UString &name)
-    {
-        auto it = internedIdentifiers.find(name);
-        if (it != internedIdentifiers.end()) {
-            return it->second;
-        }
-        auto r = new Identifier(name);
-        internedIdentifiers[name] = r;
-        return r;
-    }
-    ~Allocator()
-    {
-        for (auto x : allocated) {
-            delete x;
-        }
-        allocated.clear();
-        for (auto x : internedIdentifiers) {
-            delete x.second;
-        }
-        internedIdentifiers.clear();
-    }
-};
-
-namespace {
-
-// Precedences used by various compilation units are defined here.
-const int APPLY_PRECEDENCE = 2;  // Function calls and indexing.
-const int UNARY_PRECEDENCE = 4;  // Logical and bitwise negation, unary + -
-const int BEFORE_ELSE_PRECEDENCE = 15; // True branch of an if.
-const int MAX_PRECEDENCE = 16; // Local, If, Import, Function, Error
-
-/** These are the binary operator precedences, unary precedence is given by
- * UNARY_PRECEDENCE.
- */
-std::map<BinaryOp, int> build_precedence_map(void)
-{
-    std::map<BinaryOp, int> r;
-
-    r[BOP_MULT] = 5;
-    r[BOP_DIV] = 5;
-    r[BOP_PERCENT] = 5;
-
-    r[BOP_PLUS] = 6;
-    r[BOP_MINUS] = 6;
-
-    r[BOP_SHIFT_L] = 7;
-    r[BOP_SHIFT_R] = 7;
-
-    r[BOP_GREATER] = 8;
-    r[BOP_GREATER_EQ] = 8;
-    r[BOP_LESS] = 8;
-    r[BOP_LESS_EQ] = 8;
-    r[BOP_IN] = 8;
-
-    r[BOP_MANIFEST_EQUAL] = 9;
-    r[BOP_MANIFEST_UNEQUAL] = 9;
-
-    r[BOP_BITWISE_AND] = 10;
-
-    r[BOP_BITWISE_XOR] = 11;
-
-    r[BOP_BITWISE_OR] = 12;
-
-    r[BOP_AND] = 13;
-
-    r[BOP_OR] = 14;
-
-    return r;
-}
-
-std::map<std::string, UnaryOp> build_unary_map(void)
-{
-    std::map<std::string, UnaryOp> r;
-    r["!"] = UOP_NOT;
-    r["~"] = UOP_BITWISE_NOT;
-    r["+"] = UOP_PLUS;
-    r["-"] = UOP_MINUS;
-    return r;
-}
-
-std::map<std::string, BinaryOp> build_binary_map(void)
-{
-    std::map<std::string, BinaryOp> r;
-
-    r["*"] = BOP_MULT;
-    r["/"] = BOP_DIV;
-    r["%"] = BOP_PERCENT;
-
-    r["+"] = BOP_PLUS;
-    r["-"] = BOP_MINUS;
-
-    r["<<"] = BOP_SHIFT_L;
-    r[">>"] = BOP_SHIFT_R;
-
-    r[">"] = BOP_GREATER;
-    r[">="] = BOP_GREATER_EQ;
-    r["<"] = BOP_LESS;
-    r["<="] = BOP_LESS_EQ;
-    r["in"] = BOP_IN;
-
-    r["=="] = BOP_MANIFEST_EQUAL;
-    r["!="] = BOP_MANIFEST_UNEQUAL;
-
-    r["&"] = BOP_BITWISE_AND;
-    r["^"] = BOP_BITWISE_XOR;
-    r["|"] = BOP_BITWISE_OR;
-
-    r["&&"] = BOP_AND;
-    r["||"] = BOP_OR;
-    return r;
-}
-
-auto precedence_map = build_precedence_map();
-auto unary_map = build_unary_map();
-auto binary_map = build_binary_map();
-
-}  // namespace
-
-#endif  // JSONNET_AST_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/bridge.c b/vendor/github.com/strickyak/jsonnet_cgo/bridge.c
deleted file mode 100644
index b5d801bfbcda922facab2b8c0d0c83d1da2d07b4..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/bridge.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <memory.h>
-#include <stdio.h>
-#include <string.h>
-#include <libjsonnet.h>
-#include "_cgo_export.h"
-
-char* CallImport_cgo(void *ctx, const char *base, const char *rel, char **found_here, int *success) {
-  struct JsonnetVm* vm = ctx;
-  return go_call_import(vm, (char*)base, (char*)rel, found_here, success);
-}
-
-struct JsonnetJsonValue* CallNative_cgo(void* ctx, const struct JsonnetJsonValue* const* argv, int* success) {
-  GoUintptr key = (GoUintptr)ctx;
-  return go_call_native(key, (struct JsonnetJsonValue**)argv, success);
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/desugarer.cpp b/vendor/github.com/strickyak/jsonnet_cgo/desugarer.cpp
deleted file mode 100644
index 26b766c082991d46ee4c4b14b912babc41b8ce5f..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/desugarer.cpp
+++ /dev/null
@@ -1,934 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <cassert>
-
-#include "ast.h"
-#include "desugarer.h"
-#include "lexer.h"
-#include "parser.h"
-#include "pass.h"
-#include "string_utils.h"
-
-static const Fodder EF;  // Empty fodder.
-
-static const LocationRange E;  // Empty.
-
-struct BuiltinDecl {
-    UString name;
-    std::vector<UString> params;
-};
-
-static unsigned long max_builtin = 26;
-BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
-{
-    switch (builtin) {
-        case 0: return {U"makeArray", {U"sz", U"func"}};
-        case 1: return {U"pow", {U"x", U"n"}};
-        case 2: return {U"floor", {U"x"}};
-        case 3: return {U"ceil", {U"x"}};
-        case 4: return {U"sqrt", {U"x"}};
-        case 5: return {U"sin", {U"x"}};
-        case 6: return {U"cos", {U"x"}};
-        case 7: return {U"tan", {U"x"}};
-        case 8: return {U"asin", {U"x"}};
-        case 9: return {U"acos", {U"x"}};
-        case 10: return {U"atan", {U"x"}};
-        case 11: return {U"type", {U"x"}};
-        case 12: return {U"filter", {U"func", U"arr"}};
-        case 13: return {U"objectHasEx", {U"obj", U"f", U"inc_hidden"}};
-        case 14: return {U"length", {U"x"}};
-        case 15: return {U"objectFieldsEx", {U"obj", U"inc_hidden"}};
-        case 16: return {U"codepoint", {U"str"}};
-        case 17: return {U"char", {U"n"}};
-        case 18: return {U"log", {U"n"}};
-        case 19: return {U"exp", {U"n"}};
-        case 20: return {U"mantissa", {U"n"}};
-        case 21: return {U"exponent", {U"n"}};
-        case 22: return {U"modulo", {U"a", U"b"}};
-        case 23: return {U"extVar", {U"x"}};
-        case 24: return {U"primitiveEquals", {U"a", U"b"}};
-        case 25: return {U"native", {U"name"}};
-        case 26: return {U"md5", {U"str"}};
-        default:
-        std::cerr << "INTERNAL ERROR: Unrecognized builtin function: " << builtin << std::endl;
-        std::abort();
-    }
-    // Quiet, compiler.
-    return BuiltinDecl();
-}
-
-static constexpr char STD_CODE[] = {
-    #include "std.jsonnet.h"
-};
-
-/** Desugar Jsonnet expressions to reduce the number of constructs the rest of the implementation
- * needs to understand.
- *
- * Desugaring should happen immediately after parsing, i.e. before static analysis and execution.
- * Temporary variables introduced here should be prefixed with $ to ensure they do not clash with
- * variables used in user code.
- */
-class Desugarer {
-
-    Allocator *alloc;
-
-    template <class T, class... Args> T* make(Args&&... args)
-    {
-        return alloc->make<T>(std::forward<Args>(args)...);
-    }
-
-    AST *clone(AST *ast)
-    { return clone_ast(*alloc, ast); }
-
-    const Identifier *id(const UString &s)
-    { return alloc->makeIdentifier(s); }
-
-    LiteralString *str(const UString &s)
-    { return make<LiteralString>(E, EF, s, LiteralString::DOUBLE, "", ""); }
-
-    LiteralString *str(const LocationRange &loc, const UString &s)
-    { return make<LiteralString>(loc, EF, s, LiteralString::DOUBLE, "", ""); }
-
-    LiteralNull *null(void)
-    { return make<LiteralNull>(E, EF); }
-
-    Var *var(const Identifier *ident)
-    { return make<Var>(E, EF, ident); }
-
-    Var *std(void)
-    { return var(id(U"std")); }
-
-
-    Local::Bind bind(const Identifier *id, AST *body)
-    {
-        return Local::Bind(EF, id, EF, body, false, EF, ArgParams{}, false, EF, EF);
-    }
-
-    Local::Binds singleBind(const Identifier *id, AST *body)
-    {
-        return {bind(id, body)};
-    }
-
-    Array *singleton(AST *body)
-    {
-        return make<Array>(body->location, EF, Array::Elements{Array::Element(body, EF)},
-                           false, EF);
-    }
-
-    Apply *stdFunc(const UString &name, AST *v)
-    {
-        return make<Apply>(
-            v->location,
-            EF,
-            make<Index>(E, EF, std(), EF, false, str(name), EF, nullptr, EF, nullptr, EF),
-            EF,
-            ArgParams{{v, EF}},
-            false,  // trailingComma
-            EF,
-            EF,
-            true  // tailstrict
-        );
-    }
-
-    Apply *stdFunc(const LocationRange &loc, const UString &name, AST *a, AST *b)
-    {
-        return make<Apply>(
-            loc,
-            EF,
-            make<Index>(E, EF, std(), EF, false, str(name), EF, nullptr, EF, nullptr, EF),
-            EF,
-            ArgParams{{a, EF}, {b, EF}},
-            false,  // trailingComma
-            EF,
-            EF,
-            true  // tailstrict
-        );
-    }
-
-    Apply *length(AST *v)
-    {
-        return stdFunc(U"length", v);
-    }
-
-    Apply *type(AST *v)
-    {
-        return stdFunc(U"type", v);
-    }
-
-    Apply *primitiveEquals(const LocationRange &loc, AST *a, AST *b)
-    {
-        return stdFunc(loc, U"primitiveEquals", a, b);
-    }
-
-    Apply *equals(const LocationRange &loc, AST *a, AST *b)
-    {
-        return stdFunc(loc, U"equals", a, b);
-    }
-
-    Error *error(AST *msg)
-    {
-        return make<Error>(msg->location, EF, msg);
-    }
-
-    Error *error(const LocationRange &loc, const UString &msg)
-    {
-        return error(str(loc, msg));
-    }
-
-    public:
-    Desugarer(Allocator *alloc)
-      : alloc(alloc)
-    { }
-
-    void desugarParams(ArgParams &params, unsigned obj_level)
-    {
-        for (auto &param : params) {
-            if (param.expr) {
-                // Default arg.
-                desugar(param.expr, obj_level);
-            }
-        }
-    }
-
-    // For all occurrences, records the identifier that will replace super[e]
-    // If self occurs, also map the self identifier to nullptr.
-    typedef std::vector<std::pair<const Identifier *, AST *>> SuperVars;
-
-    SuperVars desugarFields(AST *ast, ObjectFields &fields, unsigned obj_level)
-    {
-        // Desugar children
-        for (auto &field : fields) {
-            if (field.expr1 != nullptr) desugar(field.expr1, obj_level);
-            desugar(field.expr2, obj_level + 1);
-            if (field.expr3 != nullptr) desugar(field.expr3, obj_level + 1);
-            desugarParams(field.params, obj_level + 1);
-        }
-
-        // Simplify asserts
-        for (auto &field : fields) {
-            if (field.kind != ObjectField::ASSERT) continue;
-            AST *msg = field.expr3;
-            field.expr3 = nullptr;
-            if (msg == nullptr) {
-                // The location is what appears in the stacktrace.
-                msg = str(field.expr2->location, U"Object assertion failed.");
-            }
-
-            // if expr2 then true else error msg
-            field.expr2 = make<Conditional>(
-                field.expr2->location,
-                EF,
-                field.expr2,
-                EF,
-                make<LiteralBoolean>(E, EF, true),
-                EF,
-                error(msg));
-        }
-
-        // Remove methods
-        for (auto &field : fields) {
-            if (!field.methodSugar) continue;
-            field.expr2 = make<Function>(
-                field.expr2->location, EF, field.fodderL, field.params, field.trailingComma,
-                field.fodderR, field.expr2);
-            field.methodSugar = false;
-            field.params.clear();
-        }
-
-
-        // Remove object-level locals
-        auto copy = fields;
-        fields.clear();
-        Local::Binds binds;
-        for (auto &local : copy) {
-            if (local.kind != ObjectField::LOCAL) continue;
-            binds.push_back(bind(local.id, local.expr2));
-        }
-        for (auto &field : copy) {
-            if (field.kind == ObjectField::LOCAL) continue;
-            if (!binds.empty())
-                field.expr2 = make<Local>(field.expr2->location, EF, binds, field.expr2);
-            fields.push_back(field);
-        }
-
-        // Change all to FIELD_EXPR
-        for (auto &field : fields) {
-            switch (field.kind) {
-                case ObjectField::ASSERT:
-                // Nothing to do.
-                break;
-
-                case ObjectField::FIELD_ID:
-                field.expr1 = str(field.id->name);
-                field.kind = ObjectField::FIELD_EXPR;
-                break;
-
-                case ObjectField::FIELD_EXPR:
-                // Nothing to do.
-                break;
-
-                case ObjectField::FIELD_STR:
-                // Just set the flag.
-                field.kind = ObjectField::FIELD_EXPR;
-                break;
-
-                case ObjectField::LOCAL:
-                std::cerr << "Locals should be removed by now." << std::endl;
-                abort();
-            }
-        }
-
-        /** Replaces all occurrences of self, super[f] and e in super with variables.
-         *
-         * Returns all variables and original expressions via super_vars.
-         */
-        class SubstituteSelfSuper : public CompilerPass {
-            Desugarer *desugarer;
-            SuperVars &superVars;
-            unsigned &counter;
-            const Identifier *newSelf;
-            public:
-            SubstituteSelfSuper(Desugarer *desugarer, SuperVars &super_vars, unsigned &counter)
-              : CompilerPass(*desugarer->alloc), desugarer(desugarer), superVars(super_vars),
-                counter(counter), newSelf(nullptr)
-            {
-            }
-            void visitExpr(AST *&expr)
-            {
-                if (dynamic_cast<Self*>(expr)) {
-                    if (newSelf == nullptr) {
-                        newSelf = desugarer->id(U"$outer_self");
-                        superVars.emplace_back(newSelf, nullptr);
-                    }
-                    expr = alloc.make<Var>(expr->location, expr->openFodder, newSelf);
-                } else if (auto *super_index = dynamic_cast<SuperIndex*>(expr)) {
-                    UStringStream ss;
-                    ss << U"$outer_super_index" << (counter++);
-                    const Identifier *super_var = desugarer->id(ss.str());
-                    AST *index = super_index->index;
-                    // Desugaring of expr should already have occurred.
-                    assert(index != nullptr);
-                    // Re-use super_index since we're replacing it here.
-                    superVars.emplace_back(super_var, super_index);
-                    expr = alloc.make<Var>(expr->location, expr->openFodder, super_var);
-                } else if (auto *in_super = dynamic_cast<InSuper*>(expr)) {
-                    UStringStream ss;
-                    ss << U"$outer_in_super" << (counter++);
-                    const Identifier *in_super_var = desugarer->id(ss.str());
-                    // Re-use in_super since we're replacing it here.
-                    superVars.emplace_back(in_super_var, in_super);
-                    expr = alloc.make<Var>(expr->location, expr->openFodder, in_super_var);
-                }
-                CompilerPass::visitExpr(expr);
-            }
-        };
-
-        SuperVars super_vars;
-        unsigned counter = 0;
-
-        // Remove +:
-        for (auto &field : fields) {
-            if (!field.superSugar) continue;
-            // We have to bind self/super from expr1 outside the class, as we copy the expression
-            // into the field body.
-            // Clone it so that we maintain the AST as a tree.
-            AST *index = clone(field.expr1);
-            // This will remove self/super.
-            SubstituteSelfSuper(this, super_vars, counter).expr(index);
-            field.expr2 = make<Conditional>(
-                ast->location,
-                EF,
-                make<InSuper>(ast->location, EF, index, EF, EF),
-                EF,
-                make<Binary>(
-                    ast->location,
-                    EF,
-                    make<SuperIndex>(ast->location, EF, EF, clone(index), EF, nullptr),
-                    EF,
-                    BOP_PLUS,
-                    field.expr2),
-                EF,
-                clone(field.expr2));
-            field.superSugar = false;
-        }
-
-        return super_vars;
-    }
-
-    void desugar(AST *&ast_, unsigned obj_level)
-    {
-        if (auto *ast = dynamic_cast<Apply*>(ast_)) {
-            desugar(ast->target, obj_level);
-            for (ArgParam &arg : ast->args)
-                desugar(arg.expr, obj_level);
-
-        } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
-            desugar(ast->left, obj_level);
-            desugar(ast->right, obj_level);
-            ast_ = make<Binary>(ast->location, ast->openFodder,
-                                ast->left, EF, BOP_PLUS, ast->right);
-
-        } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
-            for (auto &el : ast->elements)
-                desugar(el.expr, obj_level);
-
-        } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
-            for (ComprehensionSpec &spec : ast->specs)
-                desugar(spec.expr, obj_level);
-            desugar(ast->body, obj_level + 1);
-
-            int n = ast->specs.size();
-            AST *zero = make<LiteralNumber>(E, EF, "0.0");
-            AST *one = make<LiteralNumber>(E, EF, "1.0");
-            auto *_r = id(U"$r");
-            auto *_l = id(U"$l");
-            std::vector<const Identifier*> _i(n);
-            for (int i = 0; i < n ; ++i) {
-                UStringStream ss;
-                ss << U"$i_" << i;
-                _i[i] = id(ss.str());
-            }
-            std::vector<const Identifier*> _aux(n);
-            for (int i = 0; i < n ; ++i) {
-                UStringStream ss;
-                ss << U"$aux_" << i;
-                _aux[i] = id(ss.str());
-            }
-
-            // Build it from the inside out.  We keep wrapping 'in' with more ASTs.
-            assert(ast->specs[0].kind == ComprehensionSpec::FOR);
-
-            int last_for = n - 1;
-            while (ast->specs[last_for].kind != ComprehensionSpec::FOR)
-                last_for--;
-            // $aux_{last_for}($i_{last_for} + 1, $r + [body])
-            AST *in = make<Apply>(
-                ast->body->location,
-                EF,
-                var(_aux[last_for]),
-                EF,
-                ArgParams {
-                    { make<Binary>(E, EF, var(_i[last_for]), EF, BOP_PLUS, one), EF},
-                    { make<Binary>(E, EF, var(_r), EF, BOP_PLUS, singleton(ast->body)), EF}
-                },
-                false,  // trailingComma
-                EF,
-                EF,
-                true  // tailstrict
-            );
-            for (int i = n - 1; i >= 0 ; --i) {
-                const ComprehensionSpec &spec = ast->specs[i];
-                AST *out;
-                if (i > 0) {
-                    int prev_for = i - 1;
-                    while (ast->specs[prev_for].kind != ComprehensionSpec::FOR)
-                        prev_for--;
-
-                    // aux_{prev_for}($i_{prev_for} + 1, $r)
-                    out = make<Apply>(  // False branch.
-                        E,
-                        EF,
-                        var(_aux[prev_for]),
-                        EF,
-                        ArgParams {
-                            { make<Binary>(E, EF, var(_i[prev_for]), EF, BOP_PLUS, one), EF, },
-                            { var(_r), EF, }
-                        },
-                        false, // trailingComma
-                        EF,
-                        EF,
-                        true  // tailstrict
-                    );
-                } else {
-                    out = var(_r);
-                }
-                switch (spec.kind) {
-                    case ComprehensionSpec::IF: {
-                        /*
-                            if [[[...cond...]]] then
-                                [[[...in...]]]
-                            else
-                                [[[...out...]]]
-                        */
-                        in = make<Conditional>(
-                            ast->location,
-                            EF,
-                            spec.expr,
-                            EF,
-                            in,  // True branch.
-                            EF,
-                            out);  // False branch.
-                    } break;
-                    case ComprehensionSpec::FOR: {
-                        /*
-                            local $l = [[[...array...]]]
-                                  aux_{i}(i_{i}, r) =
-                                if i_{i} >= std.length($l) then
-                                    [[[...out...]]]
-                                else
-                                    local [[[...var...]]] = $l[i_{i}];
-                                    [[[...in...]]];
-                            if std.type($l) == "array" then
-                                aux_{i}(0, $r) tailstrict
-                            else
-                                error "In comprehension, can only iterate over array..";
-                        */
-                        in = make<Local>(
-                            ast->location,
-                            EF,
-                            Local::Binds {
-                                bind(_l, spec.expr),  // Need to check expr is an array
-                                bind(_aux[i], make<Function>(
-                                    ast->location,
-                                    EF,
-                                    EF,
-                                    ArgParams{{EF, _i[i], EF}, {EF, _r, EF}},
-                                    false,  // trailingComma
-                                    EF,
-                                    make<Conditional>(
-                                        ast->location,
-                                        EF,
-                                        make<Binary>(
-                                            E, EF, var(_i[i]), EF, BOP_GREATER_EQ, length(var(_l))),
-                                        EF,
-                                        out,
-                                        EF,
-                                        make<Local>(
-                                            ast->location,
-                                            EF,
-                                            singleBind(
-                                                spec.var,
-                                                make<Index>(E, EF, var(_l), EF, false, var(_i[i]),
-                                                            EF, nullptr, EF, nullptr, EF)
-                                            ),
-                                            in)
-                                    )
-                                ))},
-                            make<Conditional>(
-                                ast->location,
-                                EF,
-                                equals(ast->location, type(var(_l)), str(U"array")),
-                                EF,
-                                make<Apply>(
-                                    E,
-                                    EF,
-                                    var(_aux[i]),
-                                    EF,
-                                    ArgParams {
-                                        {zero, EF},
-                                        {
-                                            i == 0
-                                            ? make<Array>(E, EF, Array::Elements{}, false, EF)
-                                            : static_cast<AST*>(var(_r)),
-                                            EF,
-                                        }
-                                    },
-                                    false,  // trailingComma
-                                    EF,
-                                    EF,
-                                    true),  // tailstrict
-                                EF,
-                                error(ast->location,
-                                      U"In comprehension, can only iterate over array.")));
-                    } break;
-                }
-            }
-
-            ast_ = in;
-
-        } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
-            desugar(ast->cond, obj_level);
-            if (ast->message == nullptr) {
-                ast->message = str(U"Assertion failed.");
-            }
-            desugar(ast->message, obj_level);
-            desugar(ast->rest, obj_level);
-
-            // if cond then rest else error msg
-            AST *branch_false = make<Error>(ast->location, EF, ast->message);
-            ast_ = make<Conditional>(ast->location, ast->openFodder,
-                                            ast->cond, EF, ast->rest, EF, branch_false);
-
-        } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
-            desugar(ast->left, obj_level);
-            desugar(ast->right, obj_level);
-
-            bool invert = false;
-
-            switch (ast->op) {
-                case BOP_PERCENT: {
-                    AST *f_mod = make<Index>(E, EF, std(), EF, false, str(U"mod"), EF,
-                                                    nullptr, EF, nullptr, EF);
-                    ArgParams args = {{ast->left, EF}, {ast->right, EF}};
-                    ast_ = make<Apply>(ast->location, ast->openFodder, f_mod, EF, args,
-                                              false, EF, EF, false);
-                } break;
-
-                case BOP_MANIFEST_UNEQUAL:
-                invert = true;
-                case BOP_MANIFEST_EQUAL: {
-                    ast_ = equals(ast->location, ast->left, ast->right);
-                    if (invert)
-                        ast_ = make<Unary>(ast->location, ast->openFodder, UOP_NOT, ast_);
-                }
-                break;
-
-                default:;
-                // Otherwise don't change it.
-            }
-
-        } else if (dynamic_cast<const BuiltinFunction*>(ast_)) {
-            // Nothing to do.
-
-        } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
-            desugar(ast->cond, obj_level);
-            desugar(ast->branchTrue, obj_level);
-            if (ast->branchFalse == nullptr)
-                ast->branchFalse = null();
-            desugar(ast->branchFalse, obj_level);
-
-        } else if (auto *ast = dynamic_cast<Dollar*>(ast_)) {
-            if (obj_level == 0) {
-                throw StaticError(ast->location, "No top-level object found.");
-            }
-            ast_ = var(id(U"$"));
-
-        } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
-            desugar(ast->expr, obj_level);
-
-        } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
-            desugar(ast->body, obj_level);
-            desugarParams(ast->params, obj_level);
-
-        } else if (dynamic_cast<const Import*>(ast_)) {
-            // Nothing to do.
-
-        } else if (dynamic_cast<const Importstr*>(ast_)) {
-            // Nothing to do.
-
-        } else if (auto *ast = dynamic_cast<InSuper*>(ast_)) {
-            desugar(ast->element, obj_level);
-
-        } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
-            desugar(ast->target, obj_level);
-            if (ast->isSlice) {
-                if (ast->index == nullptr)
-                    ast->index = null();
-                desugar(ast->index, obj_level);
-
-                if (ast->end == nullptr)
-                    ast->end = null();
-                desugar(ast->end, obj_level);
-
-                if (ast->step == nullptr)
-                    ast->step = null();
-                desugar(ast->step, obj_level);
-
-                ast_ = make<Apply>(
-                    ast->location,
-                    EF,
-                    make<Index>(
-                        E, EF, std(), EF, false, str(U"slice"), EF, nullptr, EF, nullptr, EF),
-                    EF,
-                    ArgParams{
-                        {ast->target, EF},
-                        {ast->index, EF},
-                        {ast->end, EF},
-                        {ast->step, EF},
-                    },
-                    false,  // trailing comma
-                    EF,
-                    EF,
-                    false  // tailstrict
-                );
-            } else {
-                if (ast->id != nullptr) {
-                    assert(ast->index == nullptr);
-                    ast->index = str(ast->id->name);
-                    ast->id = nullptr;
-                }
-                desugar(ast->index, obj_level);
-            }
-
-        } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-            for (auto &bind: ast->binds)
-                desugar(bind.body, obj_level);
-            desugar(ast->body, obj_level);
-
-            for (auto &bind: ast->binds) {
-                if (bind.functionSugar) {
-                    desugarParams(bind.params, obj_level);
-                    bind.body = make<Function>(
-                        ast->location, ast->openFodder, bind.parenLeftFodder, bind.params, false,
-                        bind.parenRightFodder, bind.body);
-                    bind.functionSugar = false;
-                    bind.params.clear();
-                }
-            }
-
-        } else if (dynamic_cast<const LiteralBoolean*>(ast_)) {
-            // Nothing to do.
-
-        } else if (dynamic_cast<const LiteralNumber*>(ast_)) {
-            // Nothing to do.
-
-        } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-            if ((ast->tokenKind != LiteralString::BLOCK) &&
-                (ast->tokenKind != LiteralString::VERBATIM_DOUBLE) &&
-                (ast->tokenKind != LiteralString::VERBATIM_SINGLE)) {
-                ast->value = jsonnet_string_unescape(ast->location, ast->value);
-            }
-            ast->tokenKind = LiteralString::DOUBLE;
-            ast->blockIndent.clear();
-
-        } else if (dynamic_cast<const LiteralNull*>(ast_)) {
-            // Nothing to do.
-
-        } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-            for (auto &field : ast->fields) {
-                desugar(field.name, obj_level);
-                desugar(field.body, obj_level + 1);
-            }
-            for (AST *assert : ast->asserts) {
-                desugar(assert, obj_level + 1);
-            }
-
-        } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
-            // Hidden variable to allow outer/top binding.
-            if (obj_level == 0) {
-                const Identifier *hidden_var = id(U"$");
-                auto *body = make<Self>(E, EF);
-                ast->fields.push_back(ObjectField::Local(EF, EF, hidden_var, EF, body, EF));
-            }
-
-            SuperVars svs = desugarFields(ast, ast->fields, obj_level);
-
-            DesugaredObject::Fields new_fields;
-            ASTs new_asserts;
-            for (const ObjectField &field : ast->fields) {
-                if (field.kind == ObjectField::ASSERT) {
-                    new_asserts.push_back(field.expr2);
-                } else if (field.kind == ObjectField::FIELD_EXPR) {
-                    new_fields.emplace_back(field.hide, field.expr1, field.expr2);
-                } else {
-                    std::cerr << "INTERNAL ERROR: field should have been desugared: "
-                              << field.kind << std::endl;
-                }
-            }
-            ast_ = make<DesugaredObject>(ast->location, new_asserts, new_fields);
-            if (svs.size() > 0) {
-                Local::Binds binds;
-                for (const auto &pair : svs) {
-                    if (pair.second == nullptr) {
-                        // Self binding
-                        binds.push_back(bind(pair.first, make<Self>(E, EF)));
-                    } else {
-                        // Super binding
-                        binds.push_back(bind(pair.first, pair.second));
-                    }
-                }
-                ast_ = make<Local>(ast->location, EF, binds, ast_);
-            }
-
-        } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
-            // Hidden variable to allow outer/top binding.
-            if (obj_level == 0) {
-                const Identifier *hidden_var = id(U"$");
-                auto *body = make<Self>(E, EF);
-                ast->fields.push_back(ObjectField::Local(EF, EF, hidden_var, EF, body, EF));
-            }
-
-            SuperVars svs = desugarFields(ast, ast->fields, obj_level);
-
-            for (ComprehensionSpec &spec : ast->specs)
-                desugar(spec.expr, obj_level);
-
-            AST *field = ast->fields.front().expr1;
-            AST *value = ast->fields.front().expr2;
-
-            /*  {
-                    [arr[0]]: local x = arr[1], y = arr[2], z = arr[3]; val_expr
-                    for arr in [ [key_expr, x, y, z] for ...  ]
-                }
-            */
-            auto *_arr = id(U"$arr");
-            AST *zero = make<LiteralNumber>(E, EF, "0.0");
-            int counter = 1;
-            Local::Binds binds;
-            Array::Elements arr_e {Array::Element(field, EF)};
-            for (ComprehensionSpec &spec : ast->specs) {
-                if (spec.kind == ComprehensionSpec::FOR) {
-                    std::stringstream num;
-                    num << counter++;
-                    binds.push_back(bind(
-                        spec.var,
-                        make<Index>(E, EF, var(_arr), EF, false,
-                                    make<LiteralNumber>(E, EF, num.str()), EF, nullptr, EF, nullptr,
-                                    EF)));
-                    arr_e.emplace_back(var(spec.var), EF);
-                }
-            }
-            AST *arr = make<ArrayComprehension>(
-                ast->location,
-                EF,
-                make<Array>(ast->location, EF, arr_e, false, EF),
-                EF,
-                false,
-                ast->specs,
-                EF);
-            desugar(arr, obj_level);
-            ast_ = make<ObjectComprehensionSimple>(
-                ast->location,
-                make<Index>(E, EF, var(_arr), EF, false, zero, EF, nullptr, EF, nullptr, EF),
-                make<Local>(
-                    ast->location,
-                    EF,
-                    binds,
-                    value),
-                _arr,
-                arr);
-
-        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-            desugar(ast->field, obj_level);
-            desugar(ast->value, obj_level + 1);
-            desugar(ast->array, obj_level);
-
-        } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
-            // Strip parens.
-            desugar(ast->expr, obj_level);
-            ast_ = ast->expr;
-
-        } else if (dynamic_cast<const Self*>(ast_)) {
-            // Nothing to do.
-
-        } else if (auto * ast = dynamic_cast<SuperIndex*>(ast_)) {
-            if (ast->id != nullptr) {
-                assert(ast->index == nullptr);
-                ast->index = str(ast->id->name);
-                ast->id = nullptr;
-            }
-            desugar(ast->index, obj_level);
-
-        } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
-            desugar(ast->expr, obj_level);
-
-        } else if (dynamic_cast<const Var*>(ast_)) {
-            // Nothing to do.
-
-        } else {
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-            std::abort();
-
-        }
-    }
-
-    void desugarFile(AST *&ast, std::map<std::string, VmExt> *tlas)
-    {
-        desugar(ast, 0);
-
-        // Now, implement the std library by wrapping in a local construct.
-        Tokens tokens = jsonnet_lex("std.jsonnet", STD_CODE);
-        AST *std_ast = jsonnet_parse(alloc, tokens);
-        desugar(std_ast, 0);
-        auto *std_obj = dynamic_cast<DesugaredObject*>(std_ast);
-        if (std_obj == nullptr) {
-            std::cerr << "INTERNAL ERROR: std.jsonnet not an object." << std::endl;
-            std::abort();
-        }
-
-        // Bind 'std' builtins that are implemented natively.
-        DesugaredObject::Fields &fields = std_obj->fields;
-        for (unsigned long c=0 ; c <= max_builtin ; ++c) {
-            const auto &decl = jsonnet_builtin_decl(c);
-            Identifiers params;
-            for (const auto &p : decl.params)
-                params.push_back(id(p));
-            fields.emplace_back(
-                ObjectField::HIDDEN,
-                str(decl.name),
-                make<BuiltinFunction>(E, encode_utf8(decl.name), params));
-        }
-        fields.emplace_back(
-            ObjectField::HIDDEN,
-            str(U"thisFile"),
-            str(decode_utf8(ast->location.file)));
-
-        std::vector<std::string> empty;
-        auto line_end_blank = Fodder{{FodderElement::LINE_END, 1, 0, empty}};
-        auto line_end = Fodder{{FodderElement::LINE_END, 0, 0, empty}};
-
-        // local body = ast;
-        // if std.type(body) == "function") then
-        //     body(tlas...)
-        // else
-        //     body
-        if (tlas != nullptr) {
-            LocationRange tla_loc("Top-level function");
-            ArgParams args;
-            for (const auto &pair : *tlas)
-            {
-                AST *expr;
-                if (pair.second.isCode) {
-                    // Now, implement the std library by wrapping in a local construct.
-                    Tokens tokens = jsonnet_lex("tla:" + pair.first, pair.second.data.c_str());
-                    expr = jsonnet_parse(alloc, tokens);
-                    desugar(expr, 0);
-                } else {
-                    expr = str(decode_utf8(pair.second.data));
-                }
-                // Add them as named arguments, so order does not matter.
-                args.emplace_back(EF, id(decode_utf8(pair.first)), EF, expr, EF);
-            }
-            const Identifier *body = id(U"top_level");
-            ast = make<Local>(
-                ast->location,
-                line_end_blank,
-                singleBind(body, ast),
-                make<Conditional>(
-                    E,
-                    line_end,
-                    primitiveEquals(E, type(var(body)), str(U"function")),
-                    EF,
-                    make<Apply>(
-                        tla_loc,
-                        EF,
-                        make<Var>(E, line_end, body),
-                        EF,
-                        args,
-                        false,  // trailing comma
-                        EF,
-                        EF,
-                        false  // tailstrict
-                    ),
-                    line_end,
-                    make<Var>(E, line_end, body)));
-        }
-
-        // local std = (std.jsonnet stuff); ast
-        ast = make<Local>(
-            ast->location,
-            EF,
-            singleBind(id(U"std"), std_obj),
-            ast);
-    }
-};
-
-void jsonnet_desugar(Allocator *alloc, AST *&ast, std::map<std::string, VmExt> *tlas)
-{
-    Desugarer desugarer(alloc);
-    desugarer.desugarFile(ast, tlas);
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/desugarer.h b/vendor/github.com/strickyak/jsonnet_cgo/desugarer.h
deleted file mode 100644
index 6e33ee61eb1cb01db359ba3dfb7fda347389d70e..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/desugarer.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_DESUGARING_H
-#define JSONNET_DESUGARING_H
-
-#include <map>
-#include <string>
-
-#include "ast.h"
-#include "vm.h"
-
-/** Translate the AST to remove syntax sugar.
- * \param alloc Allocator for making new identifiers / ASTs.
- * \param ast The AST to change.
- * \param tla the top level arguments.  If null then do not try to process
- * top-level functions.
- */
-void jsonnet_desugar(Allocator *alloc, AST *&ast, std::map<std::string, VmExt> *tla);
-
-#endif
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/formatter.cpp b/vendor/github.com/strickyak/jsonnet_cgo/formatter.cpp
deleted file mode 100644
index 2d58a52486c075db7f442bf7e300ca6d4029c20d..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/formatter.cpp
+++ /dev/null
@@ -1,1764 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <typeinfo>
-
-#include "formatter.h"
-#include "lexer.h"
-#include "pass.h"
-#include "string_utils.h"
-#include "unicode.h"
-
-static std::string unparse_id(const Identifier *id)
-{
-    return encode_utf8(id->name);
-}
-
-/** If left recursive, return the left hand side, else return nullptr. */
-static AST *left_recursive(AST *ast_)
-{
-    if (auto *ast = dynamic_cast<Apply*>(ast_))
-        return ast->target;
-    if (auto *ast = dynamic_cast<ApplyBrace*>(ast_))
-        return ast->left;
-    if (auto *ast = dynamic_cast<Binary*>(ast_))
-        return ast->left;
-    if (auto *ast = dynamic_cast<Index*>(ast_))
-        return ast->target;
-    if (auto *ast = dynamic_cast<InSuper*>(ast_))
-        return ast->element;
-    return nullptr;
-}
-static const AST *left_recursive(const AST *ast_)
-{
-    return left_recursive(const_cast<AST*>(ast_));
-}
-
-/** Pretty-print fodder.
- *
- * \param fodder The fodder to print
- * \param space_before Whether a space should be printed before any other output.
- * \param separate_token If the last fodder was an interstitial, whether a space should follow it.
- */
-void fodder_fill(std::ostream &o, const Fodder &fodder, bool space_before, bool separate_token)
-{
-    unsigned last_indent = 0;
-    for (const auto &fod : fodder) {
-        switch (fod.kind) {
-            case FodderElement::LINE_END:
-            if (fod.comment.size() > 0)
-                o << "  " << fod.comment[0];
-            o << '\n';
-            o << std::string(fod.blanks, '\n');
-            o << std::string(fod.indent, ' ');
-            last_indent = fod.indent;
-            space_before = false;
-            break;
-
-            case FodderElement::INTERSTITIAL:
-            if (space_before)
-                o << ' ';
-            o << fod.comment[0];
-            space_before = true;
-            break;
-
-            case FodderElement::PARAGRAPH: {
-                bool first = true;
-                for (const std::string &l : fod.comment) {
-                    // Do not indent empty lines (note: first line is never empty).
-                    if (l.length() > 0) {
-                        // First line is already indented by previous fod.
-                        if (!first)
-                            o << std::string(last_indent, ' ');
-                        o << l;
-                    }
-                    o << '\n';
-                    first = false;
-                }
-                o << std::string(fod.blanks, '\n');
-                o << std::string(fod.indent, ' ');
-                last_indent = fod.indent;
-                space_before = false;
-            } break;
-        }
-    }
-    if (separate_token && space_before)
-        o << ' ';
-}
-
-/** A model of fodder_fill that just keeps track of the column counter. */
-static void fodder_count(unsigned &column, const Fodder &fodder, bool space_before,
-                         bool separate_token)
-{
-    for (const auto &fod : fodder) {
-        switch (fod.kind) {
-            case FodderElement::PARAGRAPH:
-            case FodderElement::LINE_END:
-            column = fod.indent;
-            space_before = false;
-            break;
-
-            case FodderElement::INTERSTITIAL:
-            if (space_before)
-                column++;
-            column += fod.comment[0].length();
-            space_before = true;
-            break;
-        }
-    }
-    if (separate_token && space_before)
-        column++;
-}
-
-class Unparser {
-    public:
-
-    private:
-    std::ostream &o;
-    FmtOpts opts;
-
-    public:
-    Unparser(std::ostream &o, const FmtOpts &opts)
-      : o(o), opts(opts)
-    { }
-
-    void unparseSpecs(const std::vector<ComprehensionSpec> &specs)
-    {
-        for (const auto &spec : specs) {
-            fill(spec.openFodder, true, true);
-            switch (spec.kind) {
-                case ComprehensionSpec::FOR:
-                o << "for";
-                fill(spec.varFodder, true, true);
-                o << unparse_id(spec.var);
-                fill(spec.inFodder, true, true);
-                o << "in";
-                unparse(spec.expr, true);
-                break;
-                case ComprehensionSpec::IF:
-                o << "if";
-                unparse(spec.expr, true);
-                break;
-            }
-        }
-    }
-
-    void fill(const Fodder &fodder, bool space_before, bool separate_token)
-    {
-        fodder_fill(o, fodder, space_before, separate_token);
-    }
-
-    void unparseParams(const Fodder &fodder_l, const ArgParams &params, bool trailing_comma,
-                       const Fodder &fodder_r)
-    {
-        fill(fodder_l, false, false);
-        o << "(";
-        bool first = true;
-        for (const auto &param : params) {
-            if (!first) o << ",";
-            fill(param.idFodder, !first, true);
-            o << unparse_id(param.id);
-            if (param.expr != nullptr) {
-                // default arg, no spacing: x=e
-                fill(param.eqFodder, false, false);
-                o << "=";
-                unparse(param.expr, false);
-            }
-            fill(param.commaFodder, false, false);
-            first = false;
-        }
-        if (trailing_comma)
-            o << ",";
-        fill(fodder_r, false, false);
-        o << ")";
-    }
-
-    void unparseFieldParams(const ObjectField &field)
-    {
-        if (field.methodSugar) {
-            unparseParams(field.fodderL, field.params, field.trailingComma, field.fodderR);
-        }
-    }
-
-    void unparseFields(const ObjectFields &fields, bool space_before)
-    {
-        bool first = true;
-        for (const auto &field : fields) {
-
-            if (!first) o << ',';
-
-            switch (field.kind) {
-                case ObjectField::LOCAL: {
-                    fill(field.fodder1, !first || space_before, true);
-                    o << "local";
-                    fill(field.fodder2, true, true);
-                    o << unparse_id(field.id);
-                    unparseFieldParams(field);
-                    fill(field.opFodder, true, true);
-                    o << "=";
-                    unparse(field.expr2, true);
-                } break;
-
-                case ObjectField::FIELD_ID:
-                case ObjectField::FIELD_STR:
-                case ObjectField::FIELD_EXPR: {
-
-
-                    if (field.kind == ObjectField::FIELD_ID) {
-                        fill(field.fodder1, !first || space_before, true);
-                        o << unparse_id(field.id);
-
-                    } else if (field.kind == ObjectField::FIELD_STR) {
-                        unparse(field.expr1, !first || space_before);
-
-                    } else if (field.kind == ObjectField::FIELD_EXPR) {
-                        fill(field.fodder1, !first || space_before, true);
-                        o << "[";
-                        unparse(field.expr1, false);
-                        fill(field.fodder2, false, false);
-                        o << "]";
-                    }
-                    unparseFieldParams(field);
-
-                    fill(field.opFodder, false, false);
-
-                    if (field.superSugar) o << "+";
-                    switch (field.hide) {
-                        case ObjectField::INHERIT: o << ":"; break;
-                        case ObjectField::HIDDEN: o << "::"; break;
-                        case ObjectField::VISIBLE: o << ":::"; break;
-                    }
-                    unparse(field.expr2, true);
-
-                } break;
-
-                case ObjectField::ASSERT: {
-                    fill(field.fodder1, !first || space_before, true);
-                    o << "assert";
-                    unparse(field.expr2, true);
-                    if (field.expr3 != nullptr) {
-                        fill(field.opFodder, true, true);
-                        o << ":";
-                        unparse(field.expr3, true);
-                    }
-                } break;
-            }
-
-            first = false;
-            fill(field.commaFodder, false, false);
-        }
-    }
-
-    /** Unparse the given AST.
-     *
-     * \param ast_ The AST to be unparsed.
-     *
-     * \param precedence The precedence of the enclosing AST.  If this is greater than the current
-     * precedence, parens are not needed.
-     */
-    void unparse(const AST *ast_, bool space_before)
-    {
-        bool separate_token = !left_recursive(ast_);
-
-        fill(ast_->openFodder, space_before, separate_token);
-
-        if (auto *ast = dynamic_cast<const Apply*>(ast_)) {
-            unparse(ast->target, space_before);
-            fill(ast->fodderL, false, false);
-            o << "(";
-            bool first = true;
-            for (const auto &arg : ast->args) {
-                if (!first) o << ',';
-                bool space = !first;
-                if (arg.id != nullptr) {
-                    fill(arg.idFodder, space, true);
-                    o << unparse_id(arg.id);
-                    space = false;
-                    o << "=";
-                }
-                unparse(arg.expr, space);
-                fill(arg.commaFodder, false, false);
-                first = false;
-            }
-            if (ast->trailingComma) o << ",";
-            fill(ast->fodderR, false, false);
-            o << ")";
-            if (ast->tailstrict) {
-                fill(ast->tailstrictFodder, true, true);
-                o << "tailstrict";
-            }
-
-        } else if (auto *ast = dynamic_cast<const ApplyBrace*>(ast_)) {
-            unparse(ast->left, space_before);
-            unparse(ast->right, true);
-
-        } else if (auto *ast = dynamic_cast<const Array*>(ast_)) {
-            o << "[";
-            bool first = true;
-            for (const auto &element : ast->elements) {
-                if (!first) o << ',';
-                unparse(element.expr, !first || opts.padArrays);
-                fill(element.commaFodder, false, false);
-                first = false;
-            }
-            if (ast->trailingComma) o << ",";
-            fill(ast->closeFodder, ast->elements.size() > 0, opts.padArrays);
-            o << "]";
-
-        } else if (auto *ast = dynamic_cast<const ArrayComprehension*>(ast_)) {
-            o << "[";
-            unparse(ast->body, opts.padArrays);
-            fill(ast->commaFodder, false, false);
-            if (ast->trailingComma) o << ",";
-            unparseSpecs(ast->specs);
-            fill(ast->closeFodder, true, opts.padArrays);
-            o << "]";
-
-        } else if (auto *ast = dynamic_cast<const Assert*>(ast_)) {
-            o << "assert";
-            unparse(ast->cond, true);
-            if (ast->message != nullptr) {
-                fill(ast->colonFodder, true, true);
-                o << ":";
-                unparse(ast->message, true);
-            }
-            fill(ast->semicolonFodder, false, false);
-            o << ";";
-            unparse(ast->rest, true);
-
-        } else if (auto *ast = dynamic_cast<const Binary*>(ast_)) {
-            unparse(ast->left, space_before);
-            fill(ast->opFodder, true, true);
-            o << bop_string(ast->op);
-            // The - 1 is for left associativity.
-            unparse(ast->right, true);
-
-        } else if (auto *ast = dynamic_cast<const BuiltinFunction*>(ast_)) {
-            o << "/* builtin " << ast->name << " */ null";
-
-        } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) {
-            o << "if";
-            unparse(ast->cond, true);
-            fill(ast->thenFodder, true, true);
-            o << "then";
-            if (ast->branchFalse != nullptr) {
-                unparse(ast->branchTrue, true);
-                fill(ast->elseFodder, true, true);
-                o << "else";
-                unparse(ast->branchFalse, true);
-            } else {
-                unparse(ast->branchTrue, true);
-            }
-
-        } else if (dynamic_cast<const Dollar*>(ast_)) {
-            o << "$";
-
-        } else if (auto *ast = dynamic_cast<const Error*>(ast_)) {
-            o << "error";
-            unparse(ast->expr, true);
-
-        } else if (auto *ast = dynamic_cast<const Function*>(ast_)) {
-            o << "function";
-            unparseParams(ast->parenLeftFodder, ast->params, ast->trailingComma,
-                          ast->parenRightFodder);
-            unparse(ast->body, true);
-
-        } else if (auto *ast = dynamic_cast<const Import*>(ast_)) {
-            o << "import";
-            unparse(ast->file, true);
-
-        } else if (auto *ast = dynamic_cast<const Importstr*>(ast_)) {
-            o << "importstr";
-            unparse(ast->file, true);
-
-        } else if (auto *ast = dynamic_cast<const InSuper*>(ast_)) {
-            unparse(ast->element, true);
-            fill(ast->inFodder, true, true);
-            o << "in";
-            fill(ast->superFodder, true, true);
-            o << "super";
-
-        } else if (auto *ast = dynamic_cast<const Index*>(ast_)) {
-            unparse(ast->target, space_before);
-            fill(ast->dotFodder, false, false);
-            if (ast->id != nullptr) {
-                o << ".";
-                fill(ast->idFodder, false, false);
-                o << unparse_id(ast->id);
-            } else {
-                o << "[";
-                if (ast->isSlice) {
-                    if (ast->index != nullptr) {
-                        unparse(ast->index, false);
-                    }
-                    fill(ast->endColonFodder, false, false);
-                    o << ":";
-                    if (ast->end != nullptr) {
-                        unparse(ast->end, false);
-                    }
-                    if (ast->step != nullptr || ast->stepColonFodder.size() > 0) {
-                        fill(ast->stepColonFodder, false, false);
-                        o << ":";
-                        if (ast->step != nullptr) {
-                            unparse(ast->step, false);
-                        }
-                    }
-                } else {
-                    unparse(ast->index, false);
-                }
-                fill(ast->idFodder, false, false);
-                o << "]";
-            }
-
-        } else if (auto *ast = dynamic_cast<const Local*>(ast_)) {
-            o << "local";
-            assert(ast->binds.size() > 0);
-            bool first = true;
-            for (const auto &bind : ast->binds) {
-                if (!first)
-                    o << ",";
-                first = false;
-                fill(bind.varFodder, true, true);
-                o << unparse_id(bind.var);
-                if (bind.functionSugar) {
-                    unparseParams(bind.parenLeftFodder, bind.params, bind.trailingComma,
-                                  bind.parenRightFodder);
-                }
-                fill(bind.opFodder, true, true);
-                o << "=";
-                unparse(bind.body, true);
-                fill(bind.closeFodder, false, false);
-            }
-            o << ";";
-            unparse(ast->body, true);
-
-        } else if (auto *ast = dynamic_cast<const LiteralBoolean*>(ast_)) {
-            o << (ast->value ? "true" : "false");
-
-        } else if (auto *ast = dynamic_cast<const LiteralNumber*>(ast_)) {
-            o << ast->originalString;
-
-        } else if (auto *ast = dynamic_cast<const LiteralString*>(ast_)) {
-            if (ast->tokenKind == LiteralString::DOUBLE) {
-                o << "\"";
-                o << encode_utf8(ast->value);
-                o << "\"";
-            } else if (ast->tokenKind == LiteralString::SINGLE) {
-                o << "'";
-                o << encode_utf8(ast->value);
-                o << "'";
-            } else if (ast->tokenKind == LiteralString::BLOCK) {
-                o << "|||\n";
-                if (ast->value.c_str()[0] != U'\n')
-                    o << ast->blockIndent;
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
-                    std::string utf8;
-                    encode_utf8(*cp, utf8);
-                    o << utf8;
-                    if (*cp == U'\n' && *(cp + 1) != U'\n' && *(cp + 1) != U'\0') {
-                        o << ast->blockIndent;
-                    }
-                }
-                o << ast->blockTermIndent << "|||";
-            } else if (ast->tokenKind == LiteralString::VERBATIM_DOUBLE) {
-                o << "@\"";
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
-                    if (*cp == U'"') {
-                        o << "\"\"";
-                    } else {
-                        std::string utf8;
-                        encode_utf8(*cp, utf8);
-                        o << utf8;
-                    }
-                }
-                o << "\"";
-            } else if (ast->tokenKind == LiteralString::VERBATIM_SINGLE) {
-                o << "@'";
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
-                    if (*cp == U'\'') {
-                        o << "''";
-                    } else {
-                        std::string utf8;
-                        encode_utf8(*cp, utf8);
-                        o << utf8;
-                    }
-                }
-                o << "'";
-            }
-
-        } else if (dynamic_cast<const LiteralNull*>(ast_)) {
-            o << "null";
-
-        } else if (auto *ast = dynamic_cast<const Object*>(ast_)) {
-            o << "{";
-            unparseFields(ast->fields, opts.padObjects);
-            if (ast->trailingComma) o << ",";
-            fill(ast->closeFodder, ast->fields.size() > 0, opts.padObjects);
-            o << "}";
-
-        } else if (auto *ast = dynamic_cast<const DesugaredObject*>(ast_)) {
-            o << "{";
-            for (AST *assert : ast->asserts) {
-                o << "assert";
-                unparse(assert, true);
-                o << ",";
-            }
-            for (auto &field : ast->fields) {
-                o << "[";
-                unparse(field.name, false);
-                o << "]";
-                switch (field.hide) {
-                    case ObjectField::INHERIT: o << ":"; break;
-                    case ObjectField::HIDDEN: o << "::"; break;
-                    case ObjectField::VISIBLE: o << ":::"; break;
-                }
-                unparse(field.body, true);
-                o << ",";
-            }
-            o << "}";
-
-        } else if (auto *ast = dynamic_cast<const ObjectComprehension*>(ast_)) {
-            o << "{";
-            unparseFields(ast->fields, opts.padObjects);
-            if (ast->trailingComma) o << ",";
-            unparseSpecs(ast->specs);
-            fill(ast->closeFodder, true, opts.padObjects);
-            o << "}";
-
-        } else if (auto *ast = dynamic_cast<const ObjectComprehensionSimple*>(ast_)) {
-            o << "{[";
-            unparse(ast->field, false);
-            o << "]:";
-            unparse(ast->value, true);
-            o << " for " << unparse_id(ast->id) << " in";
-            unparse(ast->array, true);
-            o << "}";
-
-        } else if (auto *ast = dynamic_cast<const Parens*>(ast_)) {
-            o << "(";
-            unparse(ast->expr, false);
-            fill(ast->closeFodder, false, false);
-            o << ")";
-
-        } else if (dynamic_cast<const Self*>(ast_)) {
-            o << "self";
-
-        } else if (auto *ast = dynamic_cast<const SuperIndex*>(ast_)) {
-            o << "super";
-            fill(ast->dotFodder, false, false);
-            if (ast->id != nullptr) {
-                o << ".";
-                fill(ast->idFodder, false, false);
-                o << unparse_id(ast->id);
-            } else {
-                o << "[";
-                unparse(ast->index, false);
-                fill(ast->idFodder, false, false);
-                o << "]";
-            }
-
-        } else if (auto *ast = dynamic_cast<const Unary*>(ast_)) {
-            o << uop_string(ast->op);
-            if (dynamic_cast<const Dollar*>(left_recursive(ast->expr))) {
-                unparse(ast->expr, true);
-            } else {
-                unparse(ast->expr, false);
-            }
-
-        } else if (auto *ast = dynamic_cast<const Var*>(ast_)) {
-            o << encode_utf8(ast->id->name);
-
-        } else {
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-            std::abort();
-
-        }
-    }
-};
-
-
-/********************************************************************************
- * The rest of this file contains transformations on the ASTs before unparsing. *
- ********************************************************************************/
-
-/** As a + b but preserves constraints.
- *
- * Namely, a LINE_END is not allowed to follow a PARAGRAPH or a LINE_END.
- */
-static Fodder concat_fodder(const Fodder &a, const Fodder &b)
-{
-    if (a.size() == 0) return b;
-    if (b.size() == 0) return a;
-    Fodder r = a;
-    // Add the first element of b somehow.
-    if (r[a.size() - 1].kind != FodderElement::INTERSTITIAL &&
-        b[0].kind == FodderElement::LINE_END) {
-        if (b[0].comment.size() > 0) {
-            // The line end had a comment, so create a single line paragraph for it.
-            r.emplace_back(FodderElement::PARAGRAPH, b[0].blanks, b[0].indent, b[0].comment);
-        } else {
-            // Merge it into the previous line end.
-            r[r.size() - 1].indent = b[0].indent;
-            r[r.size() - 1].blanks += b[0].blanks;
-        }
-    } else {
-        r.push_back(b[0]);
-    }
-    // Add the rest of b.
-    for (unsigned i = 1; i < b.size() ; ++i) {
-        r.push_back(b[i]);
-    }
-    return r;
-}
-
-/** Move b to the front of a. */
-static void fodder_move_front(Fodder &a, Fodder &b)
-{
-    a = concat_fodder(b, a);
-    b.clear();
-}
-
-/** A generic Pass that does nothing but can be extended to easily define real passes.
- */
-class FmtPass : public CompilerPass {
-    protected:
-    FmtOpts opts;
-
-    public:
-    FmtPass(Allocator &alloc, const FmtOpts &opts)
-     : CompilerPass(alloc), opts(opts) { }
-};
-
-
-class EnforceStringStyle : public FmtPass {
-    using FmtPass::visit;
-    public:
-    EnforceStringStyle(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void visit(LiteralString *lit)
-    {
-        if (lit->tokenKind == LiteralString::BLOCK) return;
-        if (lit->tokenKind == LiteralString::VERBATIM_DOUBLE) return;
-        if (lit->tokenKind == LiteralString::VERBATIM_SINGLE) return;
-        UString canonical = jsonnet_string_unescape(lit->location, lit->value);
-        unsigned num_single = 0, num_double = 0;
-        for (char32_t c : canonical) {
-            if (c == '\'') num_single++;
-            if (c == '"') num_double++;
-        }
-        if (num_single > 0 && num_double > 0) return;  // Don't change it.
-        bool use_single = opts.stringStyle == 's';
-        if (num_single > 0)
-            use_single = false;
-        if (num_double > 0)
-            use_single = true;
-
-        // Change it.
-        lit->value = jsonnet_string_escape(canonical, use_single);
-        lit->tokenKind = use_single ? LiteralString::SINGLE : LiteralString::DOUBLE;
-    }
-};
-
-class EnforceCommentStyle : public FmtPass {
-    public:
-    bool firstFodder;
-    EnforceCommentStyle(Allocator &alloc, const FmtOpts &opts)
-      : FmtPass(alloc, opts), firstFodder(true)
-    { }
-    /** Change the comment to match the given style, but don't break she-bang.
-     *
-     * If preserve_hash is true, do not touch a comment that starts with #!.
-     */
-    void fixComment(std::string &s, bool preserve_hash)
-    {
-        if (opts.commentStyle == 'h' && s[0] == '/') {
-            s = "#" + s.substr(2);
-        }
-        if (opts.commentStyle == 's' && s[0] == '#') {
-            if (preserve_hash && s[1] == '!') return;
-            s = "//" + s.substr(1);
-        }
-    }
-    void fodder(Fodder &fodder)
-    {
-        for (auto &f : fodder) {
-            switch (f.kind) {
-                case FodderElement::LINE_END:
-                case FodderElement::PARAGRAPH:
-                if (f.comment.size() == 1) {
-                    fixComment(f.comment[0], firstFodder);
-                }
-                break;
-
-                case FodderElement::INTERSTITIAL:
-                break;
-            }
-            firstFodder = false;
-        }
-    }
-};
-
-class EnforceMaximumBlankLines : public FmtPass {
-    public:
-    EnforceMaximumBlankLines(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void fodderElement(FodderElement &f)
-    {
-        if (f.kind != FodderElement::INTERSTITIAL)
-            if (f.blanks > 2) f.blanks = 2;
-    }
-};
-
-class StripComments : public FmtPass {
-    public:
-    StripComments(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void fodder(Fodder &fodder)
-    {
-        Fodder copy = fodder;
-        fodder.clear();
-        for (auto &f : copy) {
-            if (f.kind == FodderElement::LINE_END)
-                fodder.push_back(f);
-        }
-    }
-};
-
-class StripEverything : public FmtPass {
-    public:
-    StripEverything(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void fodder(Fodder &fodder) { fodder.clear(); }
-};
-
-class StripAllButComments : public FmtPass {
-    public:
-    StripAllButComments(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    Fodder comments;
-    void fodder(Fodder &fodder)
-    {
-        for (auto &f : fodder) {
-            if (f.kind == FodderElement::PARAGRAPH) {
-                comments.emplace_back(FodderElement::PARAGRAPH, 0, 0, f.comment);
-            } else if (f.kind == FodderElement::INTERSTITIAL) {
-                comments.push_back(f);
-                comments.emplace_back(FodderElement::LINE_END, 0, 0, std::vector<std::string>{});
-            }
-        }
-        fodder.clear();
-    }
-    virtual void file(AST *&body, Fodder &final_fodder)
-    {
-        expr(body);
-        fodder(final_fodder);
-        body = alloc.make<LiteralNull>(body->location, comments);
-        final_fodder.clear();
-    }
-};
-
-/** These cases are infix so we descend on the left to find the fodder. */
-static Fodder &open_fodder(AST *ast_)
-{
-    AST *left = left_recursive(ast_);
-    return left != nullptr ? open_fodder(left) : ast_->openFodder;
-}
-
-/** Strip blank lines from the top of the file. */
-void remove_initial_newlines(AST *ast)
-{
-    Fodder &f = open_fodder(ast);
-    while (f.size() > 0 && f[0].kind == FodderElement::LINE_END)
-        f.erase(f.begin());
-}
-
-bool contains_newline(const Fodder &fodder)
-{
-    for (const auto &f : fodder) {
-        if (f.kind != FodderElement::INTERSTITIAL)
-            return true;
-    }
-    return false;
-}
-
-/* Commas should appear at the end of an object/array only if the closing token is on a new line. */
-class FixTrailingCommas : public FmtPass {
-    using FmtPass::visit;
-    public:
-    FixTrailingCommas(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    Fodder comments;
-
-    // Generalized fix that works across a range of ASTs.
-    void fix_comma(Fodder &last_comma_fodder, bool &trailing_comma, Fodder &close_fodder)
-    {
-        bool need_comma = contains_newline(close_fodder) || contains_newline(last_comma_fodder);
-        if (trailing_comma) {
-            if (!need_comma) {
-                // Remove it but keep fodder.
-                trailing_comma = false;
-                fodder_move_front(close_fodder, last_comma_fodder);
-            } else if (contains_newline(last_comma_fodder)) {
-                // The comma is needed but currently is separated by a newline.
-                fodder_move_front(close_fodder, last_comma_fodder);
-            }
-        } else {
-            if (need_comma) {
-                // There was no comma, but there was a newline before the ] so add a comma.
-                trailing_comma = true;
-            }
-        }
-    }
-
-    void remove_comma(Fodder &last_comma_fodder, bool &trailing_comma, Fodder &close_fodder)
-    {
-        if (trailing_comma) {
-            // Remove it but keep fodder.
-            trailing_comma = false;
-            close_fodder = concat_fodder(last_comma_fodder, close_fodder);
-            last_comma_fodder.clear();
-        }
-    }
-
-    void visit(Array *expr)
-    {
-        if (expr->elements.size() == 0) {
-            // No comma present and none can be added.
-            return;
-        }
-
-        fix_comma(expr->elements.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        FmtPass::visit(expr);
-    }
-
-    void visit(ArrayComprehension *expr)
-    {
-        remove_comma(expr->commaFodder, expr->trailingComma, expr->specs[0].openFodder);
-        FmtPass::visit(expr);
-    }
-
-    void visit(Object *expr)
-    {
-        if (expr->fields.size() == 0) {
-            // No comma present and none can be added.
-            return;
-        }
-
-        fix_comma(expr->fields.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        FmtPass::visit(expr);
-    }
-
-    void visit(ObjectComprehension *expr)
-    {
-        remove_comma(expr->fields.back().commaFodder, expr->trailingComma, expr->closeFodder);
-        FmtPass::visit(expr);
-    }
-
-};
-
-
-/* Remove nested parens. */
-class FixParens : public FmtPass {
-    using FmtPass::visit;
-    public:
-    FixParens(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void visit(Parens *expr)
-    {
-        if (auto *body = dynamic_cast<Parens*>(expr->expr)) {
-            // Deal with fodder.
-            expr->expr = body->expr;
-            fodder_move_front(open_fodder(body->expr), body->openFodder);
-            fodder_move_front(expr->closeFodder, body->closeFodder);
-        }
-        FmtPass::visit(expr);
-    }
-};
-
-
-
-/* Ensure ApplyBrace syntax sugar is used in the case of A + { }. */
-class FixPlusObject : public FmtPass {
-    using FmtPass::visit;
-    public:
-    FixPlusObject(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-    void visitExpr(AST *&expr)
-    {
-        if (auto *bin_op = dynamic_cast<Binary*>(expr)) {
-            // Could relax this to allow more ASTs on the LHS but this seems OK for now.
-            if (dynamic_cast<Var*>(bin_op->left)
-                || dynamic_cast<Index*>(bin_op->left)) {
-                if (AST *rhs = dynamic_cast<Object*>(bin_op->right)) {
-                    if (bin_op->op == BOP_PLUS) {
-                        fodder_move_front(rhs->openFodder, bin_op->opFodder);
-                        expr = alloc.make<ApplyBrace>(bin_op->location, bin_op->openFodder,
-                                                      bin_op->left, rhs);
-                    }
-                }
-            }
-        }
-        FmtPass::visitExpr(expr);
-    }
-};
-
-
-
-/* Remove final colon in slices. */
-class NoRedundantSliceColon : public FmtPass {
-    using FmtPass::visit;
-    public:
-    NoRedundantSliceColon(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-
-    void visit(Index *expr)
-    {
-        if (expr->isSlice) {
-            if (expr->step == nullptr) {
-                if (expr->stepColonFodder.size() > 0) {
-                    fodder_move_front(expr->idFodder, expr->stepColonFodder);
-                }
-            }
-        }
-        FmtPass::visit(expr);
-    }
-};
-
-/* Ensure syntax sugar is used where possible. */
-class PrettyFieldNames : public FmtPass {
-    using FmtPass::visit;
-    public:
-    PrettyFieldNames(Allocator &alloc, const FmtOpts &opts) : FmtPass(alloc, opts) { }
-
-    bool isIdentifier(const UString &str) {
-        bool first = true;
-        for (char32_t c : str) {
-            if (!first && c >= '0' && c <= '9')
-                continue;
-            first = false;
-            if ((c >= 'A' && c <= 'Z')
-                || (c >= 'a' && c <= 'z')
-                || (c == '_'))
-                continue;
-            return false;
-        }
-        // Filter out keywords.
-        if (lex_get_keyword_kind(encode_utf8(str)) != Token::IDENTIFIER)
-            return false;
-        return true;
-    }
-
-    void visit(Index *expr)
-    {
-        if (!expr->isSlice && expr->index != nullptr) {
-            // Maybe we can use an id instead.
-            if (auto *lit = dynamic_cast<LiteralString*>(expr->index)) {
-                if (isIdentifier(lit->value)) {
-                    expr->id = alloc.makeIdentifier(lit->value);
-                    expr->idFodder = lit->openFodder;
-                    expr->index = nullptr;
-                }
-            }
-        }
-        FmtPass::visit(expr);
-    }
-
-    void visit(Object *expr)
-    {
-        for (auto &field : expr->fields) {
-            // First try ["foo"] -> "foo".
-            if (field.kind == ObjectField::FIELD_EXPR) {
-                if (auto *field_expr = dynamic_cast<LiteralString*>(field.expr1)) {
-                    field.kind = ObjectField::FIELD_STR;
-                    fodder_move_front(field_expr->openFodder, field.fodder1);
-                    if (field.methodSugar) {
-                        fodder_move_front(field.fodderL, field.fodder2);
-                    } else {
-                        fodder_move_front(field.opFodder, field.fodder2);
-                    }
-                }
-            }
-            // Then try "foo" -> foo.
-            if (field.kind == ObjectField::FIELD_STR) {
-                if (auto *lit = dynamic_cast<LiteralString*>(field.expr1)) {
-                    if (isIdentifier(lit->value)) {
-                        field.kind = ObjectField::FIELD_ID;
-                        field.id = alloc.makeIdentifier(lit->value);
-                        field.fodder1 = lit->openFodder;
-                        field.expr1 = nullptr;
-                    }
-                }
-            }
-        }
-        FmtPass::visit(expr);
-    }
-};
-
-class FixIndentation {
-
-    FmtOpts opts;
-    unsigned column;
-
-    public:
-    FixIndentation(const FmtOpts &opts) : opts(opts), column(0) { }
-
-    /* Set the indentation on the fodder elements, adjust column counter as if it was printed.
-     * \param fodder The fodder to pretend to print.
-     * \param space_before Whether a space should be printed before any other output.
-     * \param separate_token If the last fodder was an interstitial, whether a space should follow
-     * it.
-     * \param all_but_last_indent New indentation value for all but final fodder element.
-     * \param last_indent New indentation value for but final fodder element.
-     */
-    void fill(Fodder &fodder, bool space_before, bool separate_token,
-              unsigned all_but_last_indent, unsigned last_indent)
-    {
-        setIndents(fodder, all_but_last_indent, last_indent);
-        fodder_count(column, fodder, space_before, separate_token);
-    }
-
-    void fill(Fodder &fodder, bool space_before, bool separate_token, unsigned indent)
-    {
-        fill(fodder, space_before, separate_token, indent, indent);
-    }
-
-    /* This struct is the representation of the indentation level.  The field lineUp is what is
-     * generally used to indent after a new line.  The field base is used to help derive a new
-     * Indent struct when the indentation level increases.  lineUp is generally > base.
-     *
-     * In the following case (where spaces are replaced with underscores):
-     * ____foobar(1,
-     * ___________2)
-     *
-     * At the AST representing the 2, the indent has base == 4 and lineUp == 11.
-     */
-    struct Indent {
-        unsigned base;
-        unsigned lineUp;
-        Indent(unsigned base, unsigned line_up) : base(base), lineUp(line_up) { }
-    };
-
-    /** Calculate the indentation of sub-expressions.
-     *
-     * If the first sub-expression is on the same line as the current node, then subsequent
-     * ones will be lined up, otherwise subsequent ones will be on the next line indented
-     * by 'indent'.
-     */
-    Indent newIndent(const Fodder &first_fodder, const Indent &old, unsigned line_up)
-    {
-        if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
-            return Indent(old.base, line_up);
-        } else {
-            // Reset
-            return Indent(old.base + opts.indent, old.base + opts.indent);
-        }
-    }
-
-    /** Calculate the indentation of sub-expressions.
-     *
-     * If the first sub-expression is on the same line as the current node, then subsequent
-     * ones will be lined up and further indentations in their subexpressions will be based from
-     * this column.
-     */
-    Indent newIndentStrong(const Fodder &first_fodder, const Indent &old, unsigned line_up)
-    {
-        if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
-            return Indent(line_up, line_up);
-        } else {
-            // Reset
-            return Indent(old.base + opts.indent, old.base + opts.indent);
-        }
-    }
-
-    /** Calculate the indentation of sub-expressions.
-     *
-     * If the first sub-expression is on the same line as the current node, then subsequent
-     * ones will be lined up, otherwise subseqeuent ones will be on the next line with no
-     * additional indent.
-     */
-    Indent align(const Fodder &first_fodder, const Indent &old, unsigned line_up)
-    {
-        if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
-            return Indent(old.base, line_up);
-        } else {
-            // Reset
-            return old;
-        }
-    }
-
-    /** Calculate the indentation of sub-expressions.
-     *
-     * If the first sub-expression is on the same line as the current node, then subsequent
-     * ones will be lined up and further indentations in their subexpresssions will be based from
-     * this column.  Otherwise, subseqeuent ones will be on the next line with no
-     * additional indent.
-     */
-    Indent alignStrong(const Fodder &first_fodder, const Indent &old, unsigned line_up)
-    {
-        if (first_fodder.size() == 0 || first_fodder[0].kind == FodderElement::INTERSTITIAL) {
-            return Indent(line_up, line_up);
-        } else {
-            // Reset
-            return old;
-        }
-    }
-
-    /* Set indentation values within the fodder elements.
-     *
-     * The last one gets a special indentation value, all the others are set to the same thing.
-     */
-    void setIndents(Fodder &fodder, unsigned all_but_last_indent, unsigned last_indent)
-    {
-        // First count how many there are.
-        unsigned count = 0;
-        for (const auto &f : fodder) {
-            if (f.kind != FodderElement::INTERSTITIAL)
-                count++;
-        }
-        // Now set the indents.
-        unsigned i = 0;
-        for (auto &f : fodder) {
-            if (f.kind != FodderElement::INTERSTITIAL) {
-                if (i + 1 < count) {
-                    f.indent = all_but_last_indent;
-                } else {
-                    assert(i == count - 1);
-                    f.indent = last_indent;
-                }
-                i++;
-            }
-        }
-    }
-
-    /** Indent comprehension specs.
-     * \param indent The indentation level.
-     */
-    void specs(std::vector<ComprehensionSpec> &specs, const Indent &indent)
-    {
-        for (auto &spec : specs) {
-            fill(spec.openFodder, true, true, indent.lineUp);
-            switch (spec.kind) {
-                case ComprehensionSpec::FOR: {
-                    column += 3;  // for
-                    fill(spec.varFodder, true, true, indent.lineUp);
-                    column += spec.var->name.length();
-                    fill(spec.inFodder, true, true, indent.lineUp);
-                    column += 2;  // in
-                    Indent new_indent = newIndent(open_fodder(spec.expr), indent, column);
-                    expr(spec.expr, new_indent, true);
-                }
-                break;
-
-                case ComprehensionSpec::IF: {
-                    column += 2;  // if
-                    Indent new_indent = newIndent(open_fodder(spec.expr), indent, column);
-                    expr(spec.expr, new_indent, true);
-                }
-                break;
-            }
-        }
-    }
-
-    void params(Fodder &fodder_l, ArgParams &params, bool trailing_comma, Fodder &fodder_r,
-                const Indent &indent)
-    {
-        fill(fodder_l, false, false, indent.lineUp, indent.lineUp);
-        column++;  // (
-        const Fodder &first_inside = params.size() == 0 ? fodder_r : params[0].idFodder;
-
-        Indent new_indent = newIndent(first_inside, indent, column);
-        bool first = true;
-        for (auto &param : params) {
-            if (!first) column++;  // ','
-            fill(param.idFodder, !first, true, new_indent.lineUp);
-            column += param.id->name.length();
-            if (param.expr != nullptr) {
-                // default arg, no spacing: x=e
-                fill(param.eqFodder, false, false, new_indent.lineUp);
-                column++;
-                expr(param.expr, new_indent, false);
-            }
-            fill(param.commaFodder, false, false, new_indent.lineUp);
-            first = false;
-        }
-        if (trailing_comma)
-            column++;
-        fill(fodder_r, false, false, new_indent.lineUp, indent.lineUp);
-        column++;  // )
-    }
-
-    void fieldParams(ObjectField &field, const Indent &indent)
-    {
-        if (field.methodSugar) {
-            params(field.fodderL, field.params, field.trailingComma, field.fodderR, indent);
-        }
-    }
-
-    /** Indent fields within an object.
-     *
-     * \params fields
-     * \param indent Indent of the first field.
-     * \param space_before
-     */
-    void fields(ObjectFields &fields, const Indent &indent, bool space_before)
-    {
-        unsigned new_indent = indent.lineUp;
-        bool first = true;
-        for (auto &field : fields) {
-            if (!first) column++;  // ','
-
-            switch (field.kind) {
-                case ObjectField::LOCAL: {
-
-                    fill(field.fodder1, !first || space_before, true, indent.lineUp);
-                    column += 5;  // local
-                    fill(field.fodder2, true, true, indent.lineUp);
-                    column += field.id->name.length();
-                    fieldParams(field, indent);
-                    fill(field.opFodder, true, true, indent.lineUp);
-                    column++;  // =
-                    Indent new_indent2 = newIndent(open_fodder(field.expr2), indent, column);
-                    expr(field.expr2, new_indent2, true);
-                } break;
-
-                case ObjectField::FIELD_ID:
-                case ObjectField::FIELD_STR:
-                case ObjectField::FIELD_EXPR: {
-
-                    if (field.kind == ObjectField::FIELD_ID) {
-                        fill(field.fodder1, !first || space_before, true, new_indent);
-                        column += field.id->name.length();
-
-                    } else if (field.kind == ObjectField::FIELD_STR) {
-                        expr(field.expr1, indent, !first || space_before);
-
-                    } else if (field.kind == ObjectField::FIELD_EXPR) {
-                        fill(field.fodder1, !first || space_before, true, new_indent);
-                        column++;  // [
-                        expr(field.expr1, indent, false);
-                        fill(field.fodder2, false, false, new_indent);
-                        column++;  // ]
-                    }
-
-                    fieldParams(field, indent);
-
-                    fill(field.opFodder, false, false, new_indent);
-
-                    if (field.superSugar) column++;
-                    switch (field.hide) {
-                        case ObjectField::INHERIT: column+=1; break;
-                        case ObjectField::HIDDEN: column+=2; break;
-                        case ObjectField::VISIBLE: column+=3; break;
-                    }
-                    Indent new_indent2 = newIndent(open_fodder(field.expr2), indent, column);
-                    expr(field.expr2, new_indent2, true);
-
-                } break;
-
-                case ObjectField::ASSERT: {
-
-                    fill(field.fodder1, !first || space_before, true, new_indent);
-                    column += 6;  // assert
-                    // + 1 for the space after the assert
-                    Indent new_indent2 = newIndent(open_fodder(field.expr2), indent, column + 1);
-                    expr(field.expr2, indent, true);
-                    if (field.expr3 != nullptr) {
-                        fill(field.opFodder, true, true, new_indent2.lineUp);
-                        column++;  // ":"
-                        expr(field.expr3, new_indent2, true);
-                    }
-                } break;
-            }
-
-            first = false;
-            fill(field.commaFodder, false, false, new_indent);
-        }
-    }
-
-    /** Does the given fodder contain at least one new line? */
-    bool hasNewLines(const Fodder &fodder)
-    {
-        for (const auto &f : fodder) {
-            if (f.kind != FodderElement::INTERSTITIAL)
-                return true;
-        }
-        return false;
-    }
-
-    /** Get the first fodder from an ArgParam. */
-    const Fodder &argParamFirstFodder(const ArgParam &ap)
-    {
-        if (ap.id != nullptr) return ap.idFodder;
-        return open_fodder(ap.expr);
-    }
-
-    /** Reindent an expression.
-     *
-     * \param ast_ The ast to reindent.
-     * \param indent Beginning of the line.
-     * \param space_before As defined in the pretty-printer.
-     */
-    void expr(AST *ast_, const Indent &indent, bool space_before)
-    {
-        fill(ast_->openFodder, space_before, !left_recursive(ast_), indent.lineUp);
-
-        if (auto *ast = dynamic_cast<Apply*>(ast_)) {
-            const Fodder &init_fodder = open_fodder(ast->target);
-            Indent new_indent = align(init_fodder, indent,
-                                      column + (space_before ? 1 : 0));
-            expr(ast->target, new_indent, space_before);
-            fill(ast->fodderL, false, false, new_indent.lineUp);
-            column++;  // (
-            const Fodder &first_fodder = ast->args.size() == 0
-                                         ? ast->fodderR : argParamFirstFodder(ast->args[0]);
-            bool strong_indent = false;
-            // Need to use strong indent if any of the
-            // arguments (except the first) are preceded by newlines.
-            bool first = true;
-            for (auto &arg : ast->args) {
-                if (first) {
-                    // Skip first element.
-                    first = false;
-                    continue;
-                }
-                if (hasNewLines(argParamFirstFodder(arg)))
-                    strong_indent = true;
-            }
-
-            Indent arg_indent = strong_indent
-                                ? newIndentStrong(first_fodder, indent, column)
-                                : newIndent(first_fodder, indent, column);
-            first = true;
-            for (auto &arg : ast->args) {
-                if (!first) column++;  // ","
-
-                bool space = !first;
-                if (arg.id != nullptr) {
-                    fill(arg.idFodder, space, false, arg_indent.lineUp);
-                    column += arg.id->name.length();
-                    space = false;
-                    column++;  // "="
-                }
-                expr(arg.expr, arg_indent, space);
-                fill(arg.commaFodder, false, false, arg_indent.lineUp);
-                first = false;
-            }
-            if (ast->trailingComma) column++;  // ","
-            fill(ast->fodderR, false, false, arg_indent.lineUp, indent.base);
-            column++;  // )
-            if (ast->tailstrict) {
-                fill(ast->tailstrictFodder, true, true, indent.base);
-                column += 10;  // tailstrict
-            }
-
-        } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
-            const Fodder &init_fodder = open_fodder(ast->left);
-            Indent new_indent = align(init_fodder, indent,
-                                      column + (space_before ? 1 : 0));
-            expr(ast->left, new_indent, space_before);
-            expr(ast->right, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
-            column++;  // '['
-            // First fodder element exists and is a newline
-            const Fodder &first_fodder = ast->elements.size() > 0
-                                         ? open_fodder(ast->elements[0].expr)
-                                         : ast->closeFodder;
-            unsigned new_column = column + (opts.padArrays ? 1 : 0);
-            bool strong_indent = false;
-            // Need to use strong indent if there are not newlines before any of the sub-expressions
-            bool first = true;
-            for (auto &el : ast->elements) {
-                if (first) {
-                    first = false;
-                    continue;
-                }
-                if (hasNewLines(open_fodder(el.expr)))
-                    strong_indent = true;
-            }
-
-            Indent new_indent = strong_indent
-                                ? newIndentStrong(first_fodder, indent, new_column)
-                                : newIndent(first_fodder, indent, new_column);
-
-            first = true;
-            for (auto &element : ast->elements) {
-                if (!first) column++;
-                expr(element.expr, new_indent, !first || opts.padArrays);
-                fill(element.commaFodder, false, false, new_indent.lineUp, new_indent.lineUp);
-                first = false;
-            }
-            if (ast->trailingComma) column++;
-
-            // Handle penultimate newlines from expr.close_fodder if there are any.
-            fill(ast->closeFodder, ast->elements.size() > 0, opts.padArrays, new_indent.lineUp,
-                 indent.base);
-            column++;  // ']'
-
-        } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
-            column++;  // [
-            Indent new_indent = newIndent(open_fodder(ast->body), indent,
-                                          column + (opts.padArrays ? 1 : 0));
-            expr(ast->body, new_indent, opts.padArrays);
-            fill(ast->commaFodder, false, false, new_indent.lineUp);
-            if (ast->trailingComma) column++;  // ','
-            specs(ast->specs, new_indent);
-            fill(ast->closeFodder, true, opts.padArrays, new_indent.lineUp, indent.base);
-            column++;  // ]
-
-        } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
-            column += 6;  // assert
-            // + 1 for the space after the assert
-            Indent new_indent = newIndent(open_fodder(ast->cond), indent, column + 1);
-            expr(ast->cond, new_indent, true);
-            if (ast->message != nullptr) {
-                fill(ast->colonFodder, true, true, new_indent.lineUp);
-                column++;  // ":"
-                expr(ast->message, new_indent, true);
-            }
-            fill(ast->semicolonFodder, false, false, new_indent.lineUp);
-            column++;  // ";"
-            expr(ast->rest, indent, true);
-
-        } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
-            const Fodder &first_fodder = open_fodder(ast->left);
-
-            // Need to use strong indent in the case of
-            /*
-            A
-            + B
-            or
-            A +
-            B
-            */
-            bool strong_indent = hasNewLines(ast->opFodder) || hasNewLines(open_fodder(ast->right));
-
-            unsigned inner_column = column + (space_before ? 1 : 0);
-            Indent new_indent = strong_indent
-                                ? alignStrong(first_fodder, indent, inner_column)
-                                : align(first_fodder, indent, inner_column);
-            expr(ast->left, new_indent, space_before);
-            fill(ast->opFodder, true, true, new_indent.lineUp);
-            column += bop_string(ast->op).length();
-            // Don't calculate a new indent for here, because we like being able to do:
-            // true &&
-            // true &&
-            // true
-            expr(ast->right, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
-            column += 11;  // "/* builtin "
-            column += ast->name.length();
-            column += 8;  // " */ null"
-
-        } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
-            column += 2;  // if
-            Indent cond_indent = newIndent(open_fodder(ast->cond), indent, column + 1);
-            expr(ast->cond, cond_indent, true);
-            fill(ast->thenFodder, true, true, indent.base);
-            column += 4;  // then
-            Indent true_indent = newIndent(open_fodder(ast->branchTrue), indent, column + 1);
-            expr(ast->branchTrue, true_indent, true);
-            if (ast->branchFalse != nullptr) {
-                fill(ast->elseFodder, true, true, indent.base);
-                column += 4;  // else
-                Indent false_indent = newIndent(open_fodder(ast->branchFalse), indent, column + 1);
-                expr(ast->branchFalse, false_indent, true);
-            }
-
-        } else if (dynamic_cast<Dollar*>(ast_)) {
-            column++;  // $
-
-        } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
-            column += 5;  // error
-            Indent new_indent = newIndent(open_fodder(ast->expr), indent, column + 1);
-            expr(ast->expr, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
-            column += 8;  // function
-            params(ast->parenLeftFodder, ast->params, ast->trailingComma,
-                   ast->parenRightFodder, indent);
-            Indent new_indent = newIndent(open_fodder(ast->body), indent, column + 1);
-            expr(ast->body, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<Import*>(ast_)) {
-            column += 6;  // import
-            Indent new_indent = newIndent(open_fodder(ast->file), indent, column + 1);
-            expr(ast->file, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<Importstr*>(ast_)) {
-            column += 9;  // importstr
-            Indent new_indent = newIndent(open_fodder(ast->file), indent, column + 1);
-            expr(ast->file, new_indent, true);
-
-        } else if (auto *ast = dynamic_cast<InSuper*>(ast_)) {
-            expr(ast->element, indent, space_before);
-            fill(ast->inFodder, true, true, indent.lineUp);
-            column += 2;  // in
-            fill(ast->superFodder, true, true, indent.lineUp);
-            column += 5;  // super
-
-        } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
-            expr(ast->target, indent, space_before);
-            fill(ast->dotFodder, false, false, indent.lineUp);
-            if (ast->id != nullptr) {
-                Indent new_indent = newIndent(ast->idFodder, indent, column);
-                column++;  // "."
-                fill(ast->idFodder, false, false, new_indent.lineUp);
-                column += ast->id->name.length();
-            } else {
-                column++;  // "["
-                if (ast->isSlice) {
-                    Indent new_indent(0, 0);
-                    if (ast->index != nullptr) {
-                        new_indent = newIndent(open_fodder(ast->index), indent, column);
-                        expr(ast->index, new_indent, false);
-                    }
-                    if (ast->end != nullptr) {
-                        new_indent = newIndent(ast->endColonFodder, indent, column);
-                        fill(ast->endColonFodder, false, false, new_indent.lineUp);
-                        column++;  // ":"
-                        expr(ast->end, new_indent, false);
-                    }
-                    if (ast->step != nullptr) {
-                        if (ast->end == nullptr) {
-                            new_indent = newIndent(ast->endColonFodder, indent, column);
-                            fill(ast->endColonFodder, false, false, new_indent.lineUp);
-                            column++;  // ":"
-                        }
-                        fill(ast->stepColonFodder, false, false, new_indent.lineUp);
-                        column++;  // ":"
-                        expr(ast->step, new_indent, false);
-                    }
-                    if (ast->index == nullptr && ast->end == nullptr && ast->step == nullptr) {
-                        new_indent = newIndent(ast->endColonFodder, indent, column);
-                        fill(ast->endColonFodder, false, false, new_indent.lineUp);
-                        column++;  // ":"
-                    }
-                } else {
-                    Indent new_indent = newIndent(open_fodder(ast->index), indent, column);
-                    expr(ast->index, new_indent, false);
-                    fill(ast->idFodder, false, false, new_indent.lineUp, indent.base);
-                }
-                column++;  // "]"
-            }
-
-        } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-            column += 5;  // local
-            assert(ast->binds.size() > 0);
-            bool first = true;
-            Indent new_indent = newIndent(ast->binds[0].varFodder, indent, column + 1);
-            for (auto &bind : ast->binds) {
-                if (!first)
-                    column++;  // ','
-                first = false;
-                fill(bind.varFodder, true, true, new_indent.lineUp);
-                column += bind.var->name.length();
-                if (bind.functionSugar) {
-                    params(bind.parenLeftFodder, bind.params, bind.trailingComma,
-                           bind.parenRightFodder, new_indent);
-                }
-                fill(bind.opFodder, true, true, new_indent.lineUp);
-                column++;  // '='
-                Indent new_indent2 = newIndent(open_fodder(bind.body), new_indent, column + 1);
-                expr(bind.body, new_indent2, true);
-                fill(bind.closeFodder, false, false, new_indent2.lineUp, indent.base);
-            }
-            column++;  // ';'
-            expr(ast->body, indent, true);
-
-        } else if (auto *ast = dynamic_cast<LiteralBoolean*>(ast_)) {
-            column += (ast->value ? 4 : 5);
-
-        } else if (auto *ast = dynamic_cast<LiteralNumber*>(ast_)) {
-            column += ast->originalString.length();
-
-        } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-            if (ast->tokenKind == LiteralString::DOUBLE) {
-                column += 2 + ast->value.length();  // Include quotes
-            } else if (ast->tokenKind == LiteralString::SINGLE) {
-                column += 2 + ast->value.length();  // Include quotes
-            } else if (ast->tokenKind == LiteralString::BLOCK) {
-                ast->blockIndent = std::string(indent.base + opts.indent, ' ');
-                ast->blockTermIndent = std::string(indent.base, ' ');
-                column = indent.base;  // blockTermIndent
-                column += 3;  // "|||"
-            } else if (ast->tokenKind == LiteralString::VERBATIM_SINGLE) {
-                column += 3;  // Include @, start and end quotes
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
-                    if (*cp == U'\'') {
-                        column += 2;
-                    } else {
-                        column += 1;
-                    }
-                }
-            } else if (ast->tokenKind == LiteralString::VERBATIM_DOUBLE) {
-                column += 3;  // Include @, start and end quotes
-                for (const char32_t *cp = ast->value.c_str() ; *cp != U'\0' ; ++cp) {
-                    if (*cp == U'"') {
-                        column += 2;
-                    } else {
-                        column += 1;
-                    }
-                }
-            }
-
-        } else if (dynamic_cast<LiteralNull*>(ast_)) {
-            column += 4;  // null
-
-        } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
-            column++;  // '{'
-            const Fodder &first_fodder = ast->fields.size() == 0
-                                         ? ast->closeFodder
-                                         : ast->fields[0].kind == ObjectField::FIELD_STR
-                                           ? open_fodder(ast->fields[0].expr1)
-                                           : ast->fields[0].fodder1;
-            Indent new_indent = newIndent(first_fodder, indent,
-                                          column + (opts.padObjects ? 1 : 0));
-
-            fields(ast->fields, new_indent, opts.padObjects);
-            if (ast->trailingComma) column++;
-            fill(ast->closeFodder, ast->fields.size() > 0, opts.padObjects,
-                 new_indent.lineUp, indent.base);
-            column++;  // '}'
-
-        } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-            // No fodder but need to recurse and maintain column counter.
-            column++;  // '{'
-            for (AST *assert : ast->asserts) {
-                column += 6;  // assert
-                expr(assert, indent, true);
-                column++;  // ','
-            }
-            for (auto &field : ast->fields) {
-                column++;  // '['
-                expr(field.name, indent, false);
-                column++;  // ']'
-                switch (field.hide) {
-                    case ObjectField::INHERIT: column += 1; break;
-                    case ObjectField::HIDDEN: column += 2; break;
-                    case ObjectField::VISIBLE: column += 3; break;
-                }
-                expr(field.body, indent, true);
-            }
-            column++;  // '}'
-
-        } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
-            column++;  // '{'
-            unsigned start_column = column;
-            const Fodder &first_fodder = ast->fields.size() == 0
-                                         ? ast->closeFodder
-                                         : ast->fields[0].kind == ObjectField::FIELD_STR
-                                           ? open_fodder(ast->fields[0].expr1)
-                                           : ast->fields[0].fodder1;
-            Indent new_indent = newIndent(first_fodder, indent,
-                                          start_column + (opts.padObjects ? 1 : 0));
-
-            fields(ast->fields, new_indent, opts.padObjects);
-            if (ast->trailingComma) column++;  // ','
-            specs(ast->specs, new_indent);
-            fill(ast->closeFodder, true, opts.padObjects, new_indent.lineUp, indent.base);
-            column++;  // '}'
-
-        } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-            column++;  // '{'
-            column++;  // '['
-            expr(ast->field, indent, false);
-            column++;  // ']'
-            column++;  // ':'
-            expr(ast->value, indent, true);
-            column += 5;  // " for "
-            column += ast->id->name.length();
-            column += 3;  // " in"
-            expr(ast->array, indent, true);
-            column++;  // '}'
-
-        } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
-            column++;  // (
-            Indent new_indent = newIndentStrong(open_fodder(ast->expr), indent, column);
-            expr(ast->expr, new_indent, false);
-            fill(ast->closeFodder, false, false, new_indent.lineUp, indent.base);
-            column++;  // )
-
-        } else if (dynamic_cast<const Self*>(ast_)) {
-            column += 4;  // self
-
-        } else if (auto *ast = dynamic_cast<SuperIndex*>(ast_)) {
-            column += 5;  // super
-            fill(ast->dotFodder, false, false, indent.lineUp);
-            if (ast->id != nullptr) {
-                column++;  // ".";
-                Indent new_indent = newIndent(ast->idFodder, indent, column);
-                fill(ast->idFodder, false, false, new_indent.lineUp);
-                column += ast->id->name.length();
-            } else {
-                column++;  // "[";
-                Indent new_indent = newIndent(open_fodder(ast->index), indent, column);
-                expr(ast->index, new_indent, false);
-                fill(ast->idFodder, false, false, new_indent.lineUp, indent.base);
-                column++;  // "]";
-            }
-
-        } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
-            column += uop_string(ast->op).length();
-            Indent new_indent = newIndent(open_fodder(ast->expr), indent, column);
-            expr(ast->expr, new_indent, false);
-
-        } else if (auto *ast = dynamic_cast<Var*>(ast_)) {
-            column += ast->id->name.length();
-
-        } else {
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-            std::abort();
-
-        }
-    }
-    virtual void file(AST *body, Fodder &final_fodder)
-    {
-        expr(body, Indent(0, 0), false);
-        setIndents(final_fodder, 0, 0);
-    }
-};
-
-
-
-// TODO(dcunnin): Add pass to alphabeticize top level imports.
-
-
-std::string jsonnet_fmt(AST *ast, Fodder &final_fodder, const FmtOpts &opts)
-{
-    Allocator alloc;
-
-    // Passes to enforce style on the AST.
-    remove_initial_newlines(ast);
-    if (opts.maxBlankLines > 0)
-        EnforceMaximumBlankLines(alloc, opts).file(ast, final_fodder);
-    FixTrailingCommas(alloc, opts).file(ast, final_fodder);
-    FixParens(alloc, opts).file(ast, final_fodder);
-    FixPlusObject(alloc, opts).file(ast, final_fodder);
-    NoRedundantSliceColon(alloc, opts).file(ast, final_fodder);
-    if (opts.stripComments)
-        StripComments(alloc, opts).file(ast, final_fodder);
-    else if (opts.stripAllButComments)
-        StripAllButComments(alloc, opts).file(ast, final_fodder);
-    else if (opts.stripEverything)
-        StripEverything(alloc, opts).file(ast, final_fodder);
-    if (opts.prettyFieldNames)
-        PrettyFieldNames(alloc, opts).file(ast, final_fodder);
-    if (opts.stringStyle != 'l')
-        EnforceStringStyle(alloc, opts).file(ast, final_fodder);
-    if (opts.commentStyle != 'l')
-        EnforceCommentStyle(alloc, opts).file(ast, final_fodder);
-    if (opts.indent > 0)
-        FixIndentation(opts).file(ast, final_fodder);
-
-    std::stringstream ss;
-    Unparser unparser(ss, opts);
-    unparser.unparse(ast, false);
-    unparser.fill(final_fodder, true, false);
-    return ss.str();
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/formatter.h b/vendor/github.com/strickyak/jsonnet_cgo/formatter.h
deleted file mode 100644
index a3a610b923751a5cdd43bbf6e5bd1cdc52023602..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/formatter.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_FORMATTER_H
-#define JSONNET_FORMATTER_H
-
-#include "ast.h"
-
-struct FmtOpts {
-    char stringStyle;
-    char commentStyle;
-    unsigned indent;
-    unsigned maxBlankLines;
-    bool padArrays;
-    bool padObjects;
-    bool stripComments;
-    bool stripAllButComments;
-    bool stripEverything;
-    bool prettyFieldNames;
-    FmtOpts(void)
-      : stringStyle('l'),
-        commentStyle('l'),
-        indent(0),
-        maxBlankLines(2),
-        padArrays(false),
-        padObjects(true),
-        stripComments(false),
-        stripAllButComments(false),
-        stripEverything(false),
-        prettyFieldNames(true)
-    { }
-};
-
-/** The inverse of jsonnet_parse.
- */
-std::string jsonnet_fmt(AST *ast, Fodder &final_fodder, const FmtOpts &opts);
-
-#endif  // JSONNET_PARSER_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/json.h b/vendor/github.com/strickyak/jsonnet_cgo/json.h
deleted file mode 100644
index d1c546308eab6987cac9a3922f33bd83b2dc6ce1..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/json.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_JSON_H
-#define JSONNET_JSON_H
-
-#include <vector>
-#include <memory>
-#include <string>
-
-#include <libjsonnet.h>
-
-struct JsonnetJsonValue {
-    enum Kind {
-        ARRAY,
-        BOOL,
-        NULL_KIND,
-        NUMBER,
-        OBJECT,
-        STRING,
-    };
-    Kind kind;
-    std::string string;
-    double number;  // Also used for bool (0.0 and 1.0)
-    std::vector<std::unique_ptr<JsonnetJsonValue>> elements;
-    std::map<std::string, std::unique_ptr<JsonnetJsonValue>> fields;
-};
-
-#endif
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/jsonnet.go b/vendor/github.com/strickyak/jsonnet_cgo/jsonnet.go
deleted file mode 100644
index 63c6280098bfb03ebdc2014499b5984594418e61..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/jsonnet.go
+++ /dev/null
@@ -1,493 +0,0 @@
-/*
-jsonnet is a simple Go wrapper for the JSonnet VM.
-
-See http://jsonnet.org/
-*/
-package jsonnet
-
-// By Henry Strickland <@yak.net:strick>
-// Made self-contained by Marko Mikulicic <mkm@bitnami.com>
-
-/*
-#include <memory.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <libjsonnet.h>
-
-char *CallImport_cgo(void *ctx, const char *base, const char *rel, char **found_here, int *success);
-struct JsonnetJsonValue *CallNative_cgo(void *ctx, const struct JsonnetJsonValue *const *argv, int *success);
-
-#cgo CXXFLAGS: -std=c++0x -O3
-*/
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"runtime"
-	"sync"
-	"unsafe"
-)
-
-type ImportCallback func(base, rel string) (result string, path string, err error)
-
-type NativeCallback func(args ...*JsonValue) (result *JsonValue, err error)
-
-type nativeFunc struct {
-	vm       *VM
-	argc     int
-	callback NativeCallback
-}
-
-// Global registry of native functions.  Cgo pointer rules don't allow
-// us to pass go pointers directly (may not be stable), so pass uintptr
-// keys into this indirect map instead.
-var nativeFuncsMu sync.Mutex
-var nativeFuncsIdx uintptr
-var nativeFuncs = make(map[uintptr]*nativeFunc)
-
-func registerFunc(vm *VM, arity int, callback NativeCallback) uintptr {
-	f := nativeFunc{vm: vm, argc: arity, callback: callback}
-
-	nativeFuncsMu.Lock()
-	defer nativeFuncsMu.Unlock()
-
-	nativeFuncsIdx++
-	for nativeFuncs[nativeFuncsIdx] != nil {
-		nativeFuncsIdx++
-	}
-
-	nativeFuncs[nativeFuncsIdx] = &f
-	return nativeFuncsIdx
-}
-
-func getFunc(key uintptr) *nativeFunc {
-	nativeFuncsMu.Lock()
-	defer nativeFuncsMu.Unlock()
-
-	return nativeFuncs[key]
-}
-
-func unregisterFuncs(vm *VM) {
-	nativeFuncsMu.Lock()
-	defer nativeFuncsMu.Unlock()
-
-	// This is inefficient if there are many
-	// simultaneously-existing VMs...
-	for idx, f := range nativeFuncs {
-		if f.vm == vm {
-			delete(nativeFuncs, idx)
-		}
-	}
-}
-
-type VM struct {
-	guts           *C.struct_JsonnetVm
-	importCallback ImportCallback
-}
-
-//export go_call_native
-func go_call_native(key uintptr, argv **C.struct_JsonnetJsonValue, okPtr *C.int) *C.struct_JsonnetJsonValue {
-	f := getFunc(key)
-	vm := f.vm
-
-	goArgv := make([]*JsonValue, f.argc)
-	for i := 0; i < f.argc; i++ {
-		p := unsafe.Pointer(uintptr(unsafe.Pointer(argv)) + unsafe.Sizeof(*argv)*uintptr(i))
-		argptr := (**C.struct_JsonnetJsonValue)(p)
-		// NB: argv will be freed by jsonnet after this
-		// function exits, so don't want (*JsonValue).destroy
-		// finalizer.
-		goArgv[i] = &JsonValue{
-			vm:   vm,
-			guts: *argptr,
-		}
-	}
-
-	ret, err := f.callback(goArgv...)
-	if err != nil {
-		*okPtr = C.int(0)
-		ret = vm.NewString(err.Error())
-	} else {
-		*okPtr = C.int(1)
-	}
-
-	return ret.take()
-}
-
-//export go_call_import
-func go_call_import(vmPtr unsafe.Pointer, base, rel *C.char, pathPtr **C.char, okPtr *C.int) *C.char {
-	vm := (*VM)(vmPtr)
-	result, path, err := vm.importCallback(C.GoString(base), C.GoString(rel))
-	if err != nil {
-		*okPtr = C.int(0)
-		return jsonnetString(vm, err.Error())
-	}
-	*pathPtr = jsonnetString(vm, path)
-	*okPtr = C.int(1)
-	return jsonnetString(vm, result)
-}
-
-// Evaluate a file containing Jsonnet code, return a JSON string.
-func Version() string {
-	return C.GoString(C.jsonnet_version())
-}
-
-// Create a new Jsonnet virtual machine.
-func Make() *VM {
-	vm := &VM{guts: C.jsonnet_make()}
-	return vm
-}
-
-// Complement of Make().
-func (vm *VM) Destroy() {
-	unregisterFuncs(vm)
-	C.jsonnet_destroy(vm.guts)
-	vm.guts = nil
-}
-
-// jsonnet often wants char* strings that were allocated via
-// jsonnet_realloc.  This function does that.
-func jsonnetString(vm *VM, s string) *C.char {
-	clen := C.size_t(len(s)) + 1 // num bytes including trailing \0
-
-	// TODO: remove additional copy
-	cstr := C.CString(s)
-	defer C.free(unsafe.Pointer(cstr))
-
-	ret := C.jsonnet_realloc(vm.guts, nil, clen)
-	C.memcpy(unsafe.Pointer(ret), unsafe.Pointer(cstr), clen)
-
-	return ret
-}
-
-// Evaluate a file containing Jsonnet code, return a JSON string.
-func (vm *VM) EvaluateFile(filename string) (string, error) {
-	var e C.int
-	z := C.GoString(C.jsonnet_evaluate_file(vm.guts, C.CString(filename), &e))
-	if e != 0 {
-		return "", errors.New(z)
-	}
-	return z, nil
-}
-
-// Evaluate a string containing Jsonnet code, return a JSON string.
-func (vm *VM) EvaluateSnippet(filename, snippet string) (string, error) {
-	var e C.int
-	z := C.GoString(C.jsonnet_evaluate_snippet(vm.guts, C.CString(filename), C.CString(snippet), &e))
-	if e != 0 {
-		return "", errors.New(z)
-	}
-	return z, nil
-}
-
-// Format a file containing Jsonnet code, return a JSON string.
-func (vm *VM) FormatFile(filename string) (string, error) {
-	var e C.int
-	z := C.GoString(C.jsonnet_fmt_file(vm.guts, C.CString(filename), &e))
-	if e != 0 {
-		return "", errors.New(z)
-	}
-	return z, nil
-}
-
-// Indentation level when reformatting (number of spaces)
-func (vm *VM) FormatIndent(n int) {
-	C.jsonnet_fmt_indent(vm.guts, C.int(n))
-}
-
-// Format a string containing Jsonnet code, return a JSON string.
-func (vm *VM) FormatSnippet(filename, snippet string) (string, error) {
-	var e C.int
-	z := C.GoString(C.jsonnet_fmt_snippet(vm.guts, C.CString(filename), C.CString(snippet), &e))
-	if e != 0 {
-		return "", errors.New(z)
-	}
-	return z, nil
-}
-
-// Override the callback used to locate imports.
-func (vm *VM) ImportCallback(f ImportCallback) {
-	vm.importCallback = f
-	C.jsonnet_import_callback(vm.guts, (*C.JsonnetImportCallback)(unsafe.Pointer(C.CallImport_cgo)), unsafe.Pointer(vm))
-}
-
-// NativeCallback is a helper around NativeCallbackRaw that uses
-// `reflect` to convert argument and result types to/from JsonValue.
-// `f` is expected to be a function that takes argument types
-// supported by `(*JsonValue).Extract` and returns `(x, error)` where
-// `x` is a type supported by `NewJson`.
-func (vm *VM) NativeCallback(name string, params []string, f interface{}) {
-	ty := reflect.TypeOf(f)
-	if ty.NumIn() != len(params) {
-		panic("Wrong number of parameters")
-	}
-	if ty.NumOut() != 2 {
-		panic("Wrong number of output parameters")
-	}
-
-	wrapper := func(args ...*JsonValue) (*JsonValue, error) {
-		in := make([]reflect.Value, len(args))
-		for i, arg := range args {
-			value := reflect.ValueOf(arg.Extract())
-			if vty := value.Type(); !vty.ConvertibleTo(ty.In(i)) {
-				return nil, fmt.Errorf("parameter %d (type %s) cannot be converted to type %s", i, vty, ty.In(i))
-			}
-			in[i] = value.Convert(ty.In(i))
-		}
-
-		out := reflect.ValueOf(f).Call(in)
-
-		result := vm.NewJson(out[0].Interface())
-		var err error
-		if out[1].IsValid() && !out[1].IsNil() {
-			err = out[1].Interface().(error)
-		}
-		return result, err
-	}
-
-	vm.NativeCallbackRaw(name, params, wrapper)
-}
-
-func (vm *VM) NativeCallbackRaw(name string, params []string, f NativeCallback) {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	// jsonnet expects this to be NULL-terminated, so the last
-	// element is left as nil
-	cparams := make([]*C.char, len(params)+1)
-	for i, param := range params {
-		cparams[i] = C.CString(param)
-		defer C.free(unsafe.Pointer(cparams[i]))
-	}
-
-	key := registerFunc(vm, len(params), f)
-	C.jsonnet_native_callback(vm.guts, cname, (*C.JsonnetNativeCallback)(C.CallNative_cgo), unsafe.Pointer(key), (**C.char)(unsafe.Pointer(&cparams[0])))
-}
-
-// Bind a Jsonnet external var to the given value.
-func (vm *VM) ExtVar(key, val string) {
-	C.jsonnet_ext_var(vm.guts, C.CString(key), C.CString(val))
-}
-
-// Bind a Jsonnet external var to the given Jsonnet code.
-func (vm *VM) ExtCode(key, val string) {
-	C.jsonnet_ext_code(vm.guts, C.CString(key), C.CString(val))
-}
-
-// Bind a Jsonnet top-level argument to the given value.
-func (vm *VM) TlaVar(key, val string) {
-	C.jsonnet_tla_var(vm.guts, C.CString(key), C.CString(val))
-}
-
-// Bind a Jsonnet top-level argument to the given Jsonnet code.
-func (vm *VM) TlaCode(key, val string) {
-	C.jsonnet_tla_code(vm.guts, C.CString(key), C.CString(val))
-}
-
-// Set the maximum stack depth.
-func (vm *VM) MaxStack(v uint) {
-	C.jsonnet_max_stack(vm.guts, C.uint(v))
-}
-
-// Set the number of lines of stack trace to display (0 for all of them).
-func (vm *VM) MaxTrace(v uint) {
-	C.jsonnet_max_trace(vm.guts, C.uint(v))
-}
-
-// Set the number of objects required before a garbage collection cycle is allowed.
-func (vm *VM) GcMinObjects(v uint) {
-	C.jsonnet_gc_min_objects(vm.guts, C.uint(v))
-}
-
-// Run the garbage collector after this amount of growth in the number of objects.
-func (vm *VM) GcGrowthTrigger(v float64) {
-	C.jsonnet_gc_growth_trigger(vm.guts, C.double(v))
-}
-
-// Expect a string as output and don't JSON encode it.
-func (vm *VM) StringOutput(v bool) {
-	if v {
-		C.jsonnet_string_output(vm.guts, C.int(1))
-	} else {
-		C.jsonnet_string_output(vm.guts, C.int(0))
-	}
-}
-
-// Add to the default import callback's library search path.
-func (vm *VM) JpathAdd(path string) {
-	C.jsonnet_jpath_add(vm.guts, C.CString(path))
-}
-
-/* The following are not implemented because they are trivial to implement in Go on top of the
- * existing API by parsing and post-processing the JSON output by regular evaluation.
- *
- * jsonnet_evaluate_file_multi
- * jsonnet_evaluate_snippet_multi
- * jsonnet_evaluate_file_stream
- * jsonnet_evaluate_snippet_stream
- */
-
-// JsonValue represents a jsonnet JSON object.
-type JsonValue struct {
-	vm   *VM
-	guts *C.struct_JsonnetJsonValue
-}
-
-func (v *JsonValue) Extract() interface{} {
-	if x, ok := v.ExtractString(); ok {
-		return x
-	}
-	if x, ok := v.ExtractNumber(); ok {
-		return x
-	}
-	if x, ok := v.ExtractBool(); ok {
-		return x
-	}
-	if ok := v.ExtractNull(); ok {
-		return nil
-	}
-	panic("Unable to extract value")
-}
-
-// ExtractString returns the string value and true if the value was a string
-func (v *JsonValue) ExtractString() (string, bool) {
-	cstr := C.jsonnet_json_extract_string(v.vm.guts, v.guts)
-	if cstr == nil {
-		return "", false
-	}
-	return C.GoString(cstr), true
-}
-
-func (v *JsonValue) ExtractNumber() (float64, bool) {
-	var ret C.double
-	ok := C.jsonnet_json_extract_number(v.vm.guts, v.guts, &ret)
-	return float64(ret), ok != 0
-}
-
-func (v *JsonValue) ExtractBool() (bool, bool) {
-	ret := C.jsonnet_json_extract_bool(v.vm.guts, v.guts)
-	switch ret {
-	case 0:
-		return false, true
-	case 1:
-		return true, true
-	case 2:
-		// Not a bool
-		return false, false
-	default:
-		panic("jsonnet_json_extract_number returned unexpected value")
-	}
-}
-
-// ExtractNull returns true iff the value is null
-func (v *JsonValue) ExtractNull() bool {
-	ret := C.jsonnet_json_extract_null(v.vm.guts, v.guts)
-	return ret != 0
-}
-
-func (vm *VM) newjson(ptr *C.struct_JsonnetJsonValue) *JsonValue {
-	v := &JsonValue{vm: vm, guts: ptr}
-	runtime.SetFinalizer(v, (*JsonValue).destroy)
-	return v
-}
-
-func (v *JsonValue) destroy() {
-	if v.guts == nil {
-		return
-	}
-	C.jsonnet_json_destroy(v.vm.guts, v.guts)
-	v.guts = nil
-	runtime.SetFinalizer(v, nil)
-}
-
-// Take ownership of the embedded ptr, effectively consuming the JsonValue
-func (v *JsonValue) take() *C.struct_JsonnetJsonValue {
-	ptr := v.guts
-	if ptr == nil {
-		panic("taking nil pointer from JsonValue")
-	}
-	v.guts = nil
-	runtime.SetFinalizer(v, nil)
-	return ptr
-}
-
-func (vm *VM) NewJson(value interface{}) *JsonValue {
-	switch val := value.(type) {
-	case string:
-		return vm.NewString(val)
-	case int:
-		return vm.NewNumber(float64(val))
-	case float64:
-		return vm.NewNumber(val)
-	case bool:
-		return vm.NewBool(val)
-	case nil:
-		return vm.NewNull()
-	case []interface{}:
-		a := vm.NewArray()
-		for _, v := range val {
-			a.ArrayAppend(vm.NewJson(v))
-		}
-		return a
-	case map[string]interface{}:
-		o := vm.NewObject()
-		for k, v := range val {
-			o.ObjectAppend(k, vm.NewJson(v))
-		}
-		return o
-	default:
-		panic(fmt.Sprintf("NewJson can't handle type: %T", value))
-	}
-}
-
-func (vm *VM) NewString(v string) *JsonValue {
-	cstr := C.CString(v)
-	defer C.free(unsafe.Pointer(cstr))
-	ptr := C.jsonnet_json_make_string(vm.guts, cstr)
-	return vm.newjson(ptr)
-}
-
-func (vm *VM) NewNumber(v float64) *JsonValue {
-	ptr := C.jsonnet_json_make_number(vm.guts, C.double(v))
-	return vm.newjson(ptr)
-}
-
-func (vm *VM) NewBool(v bool) *JsonValue {
-	var i C.int
-	if v {
-		i = 1
-	} else {
-		i = 0
-	}
-	ptr := C.jsonnet_json_make_bool(vm.guts, i)
-	return vm.newjson(ptr)
-}
-
-func (vm *VM) NewNull() *JsonValue {
-	ptr := C.jsonnet_json_make_null(vm.guts)
-	return vm.newjson(ptr)
-}
-
-func (vm *VM) NewArray() *JsonValue {
-	ptr := C.jsonnet_json_make_array(vm.guts)
-	return vm.newjson(ptr)
-}
-
-func (v *JsonValue) ArrayAppend(item *JsonValue) {
-	C.jsonnet_json_array_append(v.vm.guts, v.guts, item.take())
-}
-
-func (vm *VM) NewObject() *JsonValue {
-	ptr := C.jsonnet_json_make_object(vm.guts)
-	return vm.newjson(ptr)
-}
-
-func (v *JsonValue) ObjectAppend(key string, value *JsonValue) {
-	ckey := C.CString(key)
-	defer C.free(unsafe.Pointer(ckey))
-
-	C.jsonnet_json_object_append(v.vm.guts, v.guts, ckey, value.take())
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/lexer.cpp b/vendor/github.com/strickyak/jsonnet_cgo/lexer.cpp
deleted file mode 100644
index 89b48a3ced4fce856e0c7074a6fee1215cd3b561..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/lexer.cpp
+++ /dev/null
@@ -1,810 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <cassert>
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "lexer.h"
-#include "static_error.h"
-#include "unicode.h"
-
-static const std::vector<std::string> EMPTY;
-
-/** Strip whitespace from both ends of a string, but only up to margin on the left hand side. */
-static std::string strip_ws(const std::string &s, unsigned margin)
-{
-    if (s.size() == 0) return s;  // Avoid underflow below.
-    size_t i = 0;
-    while (i < s.length() && (s[i] == ' ' || s[i] == '\t' || s[i] == '\r') && i < margin)
-        i++;
-    size_t j = s.size();
-    while (j > i && (s[j - 1] == ' ' || s[j - 1] == '\t' || s[j - 1] == '\r')) {
-        j--;
-    }
-    return std::string(&s[i], &s[j]);
-}
-
-/** Split a string by \n and also strip left (up to margin) & right whitespace from each line. */
-static std::vector<std::string> line_split(const std::string &s, unsigned margin)
-{
-    std::vector<std::string> ret;
-    std::stringstream ss;
-    for (size_t i=0 ; i<s.length() ; ++i) {
-        if (s[i] == '\n') {
-            ret.emplace_back(strip_ws(ss.str(), margin));
-            ss.str("");
-        } else {
-            ss << s[i];
-        }
-    }
-    ret.emplace_back(strip_ws(ss.str(), margin));
-    return ret;
-}
-
-
-
-/** Consume whitespace.
- *
- * Return number of \n and number of spaces after last \n.  Convert \t to spaces.
- */
-static void lex_ws(const char *&c, unsigned &new_lines, unsigned &indent, const char *&line_start,
-                   unsigned long &line_number)
-{
-    indent = 0;
-    new_lines = 0;
-    for (; *c != '\0' && (*c == ' ' || *c == '\n' || *c == '\t' || *c == '\r'); c++) {
-        switch (*c) {
-            case '\r':
-            // Ignore.
-            break;
-
-            case '\n':
-            indent = 0;
-            new_lines++;
-            line_number++;
-            line_start = c + 1;
-            break;
-
-            case ' ':
-            indent += 1;
-            break;
-
-            // This only works for \t at the beginning of lines, but we strip it everywhere else
-            // anyway.  The only case where this will cause a problem is spaces followed by \t
-            // at the beginning of a line.  However that is rare, ill-advised, and if re-indentation
-            // is enabled it will be fixed later.
-            case '\t':
-            indent += 8;
-            break;
-        }
-    }
-}
-
-
-/**
-# Consume all text until the end of the line, return number of newlines after that and indent
-*/
-static void lex_until_newline(const char *&c, std::string &text, unsigned &blanks, unsigned &indent,
-                              const char *&line_start, unsigned long &line_number)
-{
-    const char *original_c = c;
-    const char *last_non_space = c;
-    for (; *c != '\0' && *c != '\n'; c++) {
-        if (*c != ' ' && *c != '\t' && *c != '\r')
-            last_non_space = c;
-    }
-    text = std::string(original_c, last_non_space - original_c + 1);
-    // Consume subsequent whitespace including the '\n'.
-    unsigned new_lines;
-    lex_ws(c, new_lines, indent, line_start, line_number);
-    blanks = new_lines == 0 ? 0 : new_lines - 1;
-}
-
-static bool is_upper(char c)
-{
-    return c >= 'A' && c <= 'Z';
-}
-
-static bool is_lower(char c)
-{
-    return c >= 'a' && c <= 'z';
-}
-
-static bool is_number(char c)
-{
-    return c >= '0' && c <= '9';
-}
-
-static bool is_identifier_first(char c)
-{
-    return is_upper(c) || is_lower(c) || c == '_';
-}
-
-static bool is_identifier(char c)
-{
-    return is_identifier_first(c) || is_number(c);
-}
-
-static bool is_symbol(char c)
-{
-    switch (c) {
-        case '!': case '$': case ':':
-        case '~': case '+': case '-':
-        case '&': case '|': case '^':
-        case '=': case '<': case '>':
-        case '*': case '/': case '%':
-        return true;
-    }
-    return false;
-}
-
-static const std::map<std::string, Token::Kind> keywords = {
-    {"assert", Token::ASSERT},
-    {"else", Token::ELSE},
-    {"error", Token::ERROR},
-    {"false", Token::FALSE},
-    {"for", Token::FOR},
-    {"function", Token::FUNCTION},
-    {"if", Token::IF},
-    {"import", Token::IMPORT},
-    {"importstr", Token::IMPORTSTR},
-    {"in", Token::IN},
-    {"local", Token::LOCAL},
-    {"null", Token::NULL_LIT},
-    {"self", Token::SELF},
-    {"super", Token::SUPER},
-    {"tailstrict", Token::TAILSTRICT},
-    {"then", Token::THEN},
-    {"true", Token::TRUE},
-};
-
-Token::Kind lex_get_keyword_kind(const std::string &identifier)
-{
-    auto it = keywords.find(identifier);
-    if (it == keywords.end()) return Token::IDENTIFIER;
-    return it->second;
-}
-
-std::string lex_number(const char *&c, const std::string &filename, const Location &begin)
-{
-    // This function should be understood with reference to the linked image:
-    // http://www.json.org/number.gif
-
-    // Note, we deviate from the json.org documentation as follows:
-    // There is no reason to lex negative numbers as atomic tokens, it is better to parse them
-    // as a unary operator combined with a numeric literal.  This avoids x-1 being tokenized as
-    // <identifier> <number> instead of the intended <identifier> <binop> <number>.
-
-    enum State {
-        BEGIN,
-        AFTER_ZERO,
-        AFTER_ONE_TO_NINE,
-        AFTER_DOT,
-        AFTER_DIGIT,
-        AFTER_E,
-        AFTER_EXP_SIGN,
-        AFTER_EXP_DIGIT
-    } state;
-
-    std::string r;
-
-    state = BEGIN;
-    while (true) {
-        switch (state) {
-            case BEGIN:
-            switch (*c) {
-                case '0':
-                state = AFTER_ZERO;
-                break;
-
-                case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_ONE_TO_NINE;
-                break;
-
-                default:
-                throw StaticError(filename, begin, "Couldn't lex number");
-            }
-            break;
-
-            case AFTER_ZERO:
-            switch (*c) {
-                case '.':
-                state = AFTER_DOT;
-                break;
-
-                case 'e': case 'E':
-                state = AFTER_E;
-                break;
-
-                default:
-                goto end;
-            }
-            break;
-
-            case AFTER_ONE_TO_NINE:
-            switch (*c) {
-                case '.':
-                state = AFTER_DOT;
-                break;
-
-                case 'e': case 'E':
-                state = AFTER_E;
-                break;
-
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_ONE_TO_NINE;
-                break;
-
-                default:
-                goto end;
-            }
-            break;
-
-            case AFTER_DOT:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_DIGIT;
-                break;
-
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after decimal point: " << *c;
-                    throw StaticError(filename, begin, ss.str());
-                }
-            }
-            break;
-
-            case AFTER_DIGIT:
-            switch (*c) {
-                case 'e': case 'E':
-                state = AFTER_E;
-                break;
-
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_DIGIT;
-                break;
-
-                default:
-                goto end;
-            }
-            break;
-
-            case AFTER_E:
-            switch (*c) {
-                case '+': case '-':
-                state = AFTER_EXP_SIGN;
-                break;
-
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
-                break;
-
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after 'E': " << *c;
-                    throw StaticError(filename, begin, ss.str());
-                }
-            }
-            break;
-
-            case AFTER_EXP_SIGN:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
-                break;
-
-                default: {
-                    std::stringstream ss;
-                    ss << "Couldn't lex number, junk after exponent sign: " << *c;
-                    throw StaticError(filename, begin, ss.str());
-                }
-            }
-            break;
-
-            case AFTER_EXP_DIGIT:
-            switch (*c) {
-                case '0': case '1': case '2': case '3': case '4':
-                case '5': case '6': case '7': case '8': case '9':
-                state = AFTER_EXP_DIGIT;
-                break;
-
-                default:
-                goto end;
-            }
-            break;
-        }
-        r += *c;
-        c++;
-    }
-    end:
-    return r;
-}
-
-// Check that b has at least the same whitespace prefix as a and returns the amount of this
-// whitespace, otherwise returns 0.  If a has no whitespace prefix than return 0.
-static int whitespace_check(const char *a, const char *b)
-{
-    int i = 0;
-    while (a[i] == ' ' || a[i] == '\t') {
-        if (b[i] != a[i]) return 0;
-        i++;
-    }
-    return i;
-}
-
-/*
-static void add_whitespace(Fodder &fodder, const char *s, size_t n)
-{
-    std::string ws(s, n);
-    if (fodder.size() == 0 || fodder.back().kind != FodderElement::WHITESPACE) {
-        fodder.emplace_back(FodderElement::WHITESPACE, ws);
-    } else {
-        fodder.back().data += ws;
-    }
-}
-*/
-
-Tokens jsonnet_lex(const std::string &filename, const char *input)
-{
-    unsigned long line_number = 1;
-    const char *line_start = input;
-
-    Tokens r;
-
-    const char *c = input;
-
-    Fodder fodder;
-    bool fresh_line = true;  // Are we tokenizing from the beginning of a new line?
-
-    while (*c!='\0') {
-
-        // Used to ensure we have actually advanced the pointer by the end of the iteration.
-        const char *original_c = c;
-
-        Token::Kind kind;
-        std::string data;
-        std::string string_block_indent;
-        std::string string_block_term_indent;
-
-        unsigned new_lines, indent;
-        lex_ws(c, new_lines, indent, line_start, line_number);
-
-        // If it's the end of the file, discard final whitespace.
-        if (*c == '\0')
-            break;
-
-        if (new_lines > 0) {
-            // Otherwise store whitespace in fodder.
-            unsigned blanks = new_lines - 1;
-            fodder.emplace_back(FodderElement::LINE_END, blanks, indent, EMPTY);
-            fresh_line = true;
-        }
-
-        Location begin(line_number, c - line_start + 1);
-
-        switch (*c) {
-
-            // The following operators should never be combined with subsequent symbols.
-            case '{':
-            kind = Token::BRACE_L;
-            c++;
-            break;
-
-            case '}':
-            kind = Token::BRACE_R;
-            c++;
-            break;
-
-            case '[':
-            kind = Token::BRACKET_L;
-            c++;
-            break;
-
-            case ']':
-            kind = Token::BRACKET_R;
-            c++;
-            break;
-
-            case ',':
-            kind = Token::COMMA;
-            c++;
-            break;
-
-            case '.':
-            kind = Token::DOT;
-            c++;
-            break;
-
-            case '(':
-            kind = Token::PAREN_L;
-            c++;
-            break;
-
-            case ')':
-            kind = Token::PAREN_R;
-            c++;
-            break;
-
-            case ';':
-            kind = Token::SEMICOLON;
-            c++;
-            break;
-
-            // Numeric literals.
-            case '0': case '1': case '2': case '3': case '4':
-            case '5': case '6': case '7': case '8': case '9':
-            kind = Token::NUMBER;
-            data = lex_number(c, filename, begin);
-            break;
-
-            // UString literals.
-            case '"': {
-                c++;
-                for (; ; ++c) {
-                    if (*c == '\0') {
-                        throw StaticError(filename, begin, "Unterminated string");
-                    }
-                    if (*c == '"') {
-                        break;
-                    }
-                    if (*c == '\\' && *(c+1) != '\0') {
-                        data += *c;
-                        ++c;
-                    }
-                    if (*c == '\n') {
-                        // Maintain line/column counters.
-                        line_number++;
-                        line_start = c+1;
-                    }
-                    data += *c;
-                }
-                c++;  // Advance beyond the ".
-                kind = Token::STRING_DOUBLE;
-            }
-            break;
-
-            // UString literals.
-            case '\'': {
-                c++;
-                for (; ; ++c) {
-                    if (*c == '\0') {
-                        throw StaticError(filename, begin, "Unterminated string");
-                    }
-                    if (*c == '\'') {
-                        break;
-                    }
-                    if (*c == '\\' && *(c+1) != '\0') {
-                        data += *c;
-                        ++c;
-                    }
-                    if (*c == '\n') {
-                        // Maintain line/column counters.
-                        line_number++;
-                        line_start = c+1;
-                    }
-                    data += *c;
-                }
-                c++;  // Advance beyond the '.
-                kind = Token::STRING_SINGLE;
-            }
-            break;
-
-            // Verbatim string literals.
-            // ' and " quoting is interpreted here, unlike non-verbatim strings
-            // where it is done later by jsonnet_string_unescape.  This is OK
-            // in this case because no information is lost by resoving the
-            // repeated quote into a single quote, so we can go back to the
-            // original form in the formatter.
-            case '@': {
-                c++;
-                if (*c != '"' && *c != '\'') {
-                    std::stringstream ss;
-                    ss << "Couldn't lex verbatim string, junk after '@': " << *c;
-                    throw StaticError(filename, begin, ss.str());
-                }
-                const char quot = *c;
-                c++;  // Advance beyond the opening quote.
-                for (; ; ++c) {
-                    if (*c == '\0')  {
-                        throw StaticError(filename, begin, "Unterminated verbatim string");
-                    }
-                    if (*c == quot) {
-                        if (*(c+1) == quot) {
-                           c++;
-                       } else {
-                           break;
-                       }
-                    }
-                    data += *c;
-                }
-                c++;  // Advance beyond the closing quote.
-                if (quot == '"') {
-                    kind = Token::VERBATIM_STRING_DOUBLE;
-                } else {
-                    kind = Token::VERBATIM_STRING_SINGLE;
-                }
-            }
-            break;
-
-            // Keywords
-            default:
-            if (is_identifier_first(*c)) {
-                std::string id;
-                for (; is_identifier(*c); ++c)
-                    id += *c;
-                kind = lex_get_keyword_kind(id);
-                data = id;
-
-            } else if (is_symbol(*c) || *c == '#') {
-
-                // Single line C++ and Python style comments.
-                if (*c == '#' || (*c == '/' && *(c+1) == '/')) {
-                    std::vector<std::string> comment(1);
-                    unsigned blanks;
-                    unsigned indent;
-                    lex_until_newline(c, comment[0], blanks, indent, line_start, line_number);
-                    auto kind = fresh_line ? FodderElement::PARAGRAPH : FodderElement::LINE_END;
-                    fodder.emplace_back(kind, blanks, indent, comment);
-                    fresh_line = true;
-                    continue;  // We've not got a token, just fodder, so keep scanning.
-                }
-
-                // Multi-line C style comment.
-                if (*c == '/' && *(c+1) == '*') {
-
-                    unsigned margin = c - line_start;
-
-                    const char *initial_c = c;
-                    c += 2;  // Avoid matching /*/: skip the /* before starting the search for */.
-
-                    while (!(*c == '*' && *(c+1) == '/')) {
-                        if (*c == '\0') {
-                            auto msg = "Multi-line comment has no terminating */.";
-                            throw StaticError(filename, begin, msg);
-                        }
-                        if (*c == '\n') {
-                            // Just keep track of the line / column counters.
-                            line_number++;
-                            line_start = c+1;
-                        }
-                        ++c;
-                    }
-                    c += 2;  // Move the pointer to the char after the closing '/'.
-
-                    std::string comment(initial_c, c - initial_c);  // Includes the "/*" and "*/".
-
-                    // Lex whitespace after comment
-                    unsigned new_lines_after, indent_after;
-                    lex_ws(c, new_lines_after, indent_after, line_start, line_number);
-                    std::vector<std::string> lines;
-                    if (comment.find('\n') >= comment.length()) {
-                        // Comment looks like /* foo */
-                        lines.push_back(comment);
-                        fodder.emplace_back(FodderElement::INTERSTITIAL, 0, 0, lines);
-                        if (new_lines_after > 0) {
-                            fodder.emplace_back(FodderElement::LINE_END, new_lines_after - 1,
-                                                indent_after, EMPTY);
-                            fresh_line = true;
-                        }
-                    } else {
-                        lines = line_split(comment, margin);
-                        assert(lines[0][0] == '/');
-                        // Little hack to support PARAGRAPHs with * down the LHS:
-                        // Add a space to lines that start with a '*'
-                        bool all_star = true;
-                        for (auto &l : lines) {
-                            if (l[0] != '*')
-                                all_star = false;
-                        }
-                        if (all_star) {
-                            for (auto &l : lines) {
-                                if (l[0] == '*') l = " " + l;
-                            }
-                        }
-                        if (new_lines_after == 0) {
-                            // Ensure a line end after the paragraph.
-                            new_lines_after = 1;
-                            indent_after = 0;
-                        }
-                        if (!fresh_line)
-                            // Ensure a line end before the comment.
-                            fodder.emplace_back(FodderElement::LINE_END, 0, 0, EMPTY);
-                        fodder.emplace_back(FodderElement::PARAGRAPH, new_lines_after - 1,
-                                            indent_after, lines);
-                        fresh_line = true;
-                    }
-                    continue;  // We've not got a token, just fodder, so keep scanning.
-                }
-
-                // Text block
-                if (*c == '|' && *(c+1) == '|' && *(c+2) == '|') {
-                    if (*(c+3) != '\n') {
-                        auto msg = "Text block syntax requires new line after |||.";
-                        throw StaticError(filename, begin, msg);
-                    }
-                    std::stringstream block;
-                    c += 4; // Skip the "|||\n"
-                    line_number++;
-                    // Skip any blank lines at the beginning of the block.
-                    while (*c == '\n') {
-                        line_number++;
-                        ++c;
-                        block << '\n';
-                    }
-                    line_start = c;
-                    const char *first_line = c;
-                    int ws_chars = whitespace_check(first_line, c);
-                    string_block_indent = std::string(first_line, ws_chars);
-                    if (ws_chars == 0) {
-                        auto msg = "Text block's first line must start with whitespace.";
-                        throw StaticError(filename, begin, msg);
-                    }
-                    while (true) {
-                        assert(ws_chars > 0);
-                        // Read up to the \n
-                        for (c = &c[ws_chars]; *c != '\n' ; ++c) {
-                            if (*c == '\0')
-                                throw StaticError(filename, begin, "Unexpected EOF");
-                            block << *c;
-                        }
-                        // Add the \n
-                        block << '\n';
-                        ++c;
-                        line_number++;
-                        line_start = c;
-                        // Skip any blank lines
-                        while (*c == '\n') {
-                            line_number++;
-                            ++c;
-                            block << '\n';
-                        }
-                        // Examine next line
-                        ws_chars = whitespace_check(first_line, c);
-                        if (ws_chars == 0) {
-                            // End of text block
-                            // Skip over any whitespace
-                            while (*c == ' ' || *c == '\t') {
-                                string_block_term_indent += *c;
-                                ++c;
-                            }
-                            // Expect |||
-                            if (!(*c == '|' && *(c+1) == '|' && *(c+2) == '|')) {
-                                auto msg = "Text block not terminated with |||";
-                                throw StaticError(filename, begin, msg);
-                            }
-                            c += 3;  // Leave after the last |
-                            data = block.str();
-                            kind = Token::STRING_BLOCK;
-                            break;  // Out of the while loop.
-                        }
-                    }
-
-                    break;  // Out of the switch.
-                }
-
-                const char *operator_begin = c;
-                for (; is_symbol(*c) ; ++c) {
-                    // Not allowed // in operators
-                    if (*c == '/' && *(c+1) == '/') break;
-                    // Not allowed /* in operators
-                    if (*c == '/' && *(c+1) == '*') break;
-                    // Not allowed ||| in operators
-                    if (*c == '|' && *(c+1) == '|' && *(c+2) == '|') break;
-                }
-                // Not allowed to end with a + - ~ ! unless a single char.
-                // So, wind it back if we need to (but not too far).
-                while (c > operator_begin + 1
-                       && (*(c-1) == '+' || *(c-1) == '-' || *(c-1) == '~' || *(c-1) == '!')) {
-                    c--;
-                }
-                data += std::string(operator_begin, c);
-                if (data == "$") {
-                    kind = Token::DOLLAR;
-                    data = "";
-                } else {
-                    kind = Token::OPERATOR;
-                }
-            } else {
-                std::stringstream ss;
-                ss << "Could not lex the character ";
-                auto uc = (unsigned char)(*c);
-                if (*c < 32)
-                    ss << "code " << unsigned(uc);
-                else
-                    ss << "'" << *c << "'";
-                throw StaticError(filename, begin, ss.str());
-            }
-        }
-
-        // Ensure that a bug in the above code does not cause an infinite memory consuming loop due
-        // to pushing empty tokens.
-        if (c == original_c) {
-            throw StaticError(filename, begin, "Internal lexing error:  Pointer did not advance");
-        }
-
-        Location end(line_number, c - line_start);
-        r.emplace_back(kind, fodder, data, string_block_indent, string_block_term_indent,
-                       LocationRange(filename, begin, end));
-        fodder.clear();
-        fresh_line = false;
-    }
-
-    Location end(line_number, c - line_start + 1);
-    r.emplace_back(Token::END_OF_FILE, fodder, "", "", "", LocationRange(filename, end, end));
-    return r;
-}
-
-std::string jsonnet_unlex(const Tokens &tokens)
-{
-    std::stringstream ss;
-    for (const auto &t : tokens) {
-        for (const auto &f : t.fodder) {
-            switch (f.kind) {
-                case FodderElement::LINE_END: {
-                    if (f.comment.size() > 0) {
-                        ss << "LineEnd(" << f.blanks << ", " << f.indent << ", "
-                           << f.comment[0] << ")\n";
-                    } else {
-                        ss << "LineEnd(" << f.blanks << ", " << f.indent << ")\n";
-                    }
-                } break;
-
-                case FodderElement::INTERSTITIAL: {
-                    ss << "Interstitial(" << f.comment[0] << ")\n";
-                } break;
-
-                case FodderElement::PARAGRAPH: {
-                    ss << "Paragraph(\n";
-                    for (const auto &line : f.comment) {
-                        ss << "    " << line << '\n';
-                    }
-                    ss << ")\n";
-                } break;
-            }
-        }
-        if (t.kind == Token::END_OF_FILE) {
-            ss << "EOF\n";
-            break;
-        }
-        if (t.kind == Token::STRING_DOUBLE) {
-            ss << "\"" << t.data << "\"\n";
-        } else if (t.kind == Token::STRING_SINGLE) {
-            ss << "'" << t.data << "'\n";
-        } else if (t.kind == Token::STRING_BLOCK) {
-            ss << "|||\n";
-            ss << t.stringBlockIndent;
-            for (const char *cp = t.data.c_str() ; *cp != '\0' ; ++cp) {
-                ss << *cp;
-                if (*cp == '\n' && *(cp + 1) != '\n' && *(cp + 1) != '\0') {
-                    ss << t.stringBlockIndent;
-                }
-            }
-            ss << t.stringBlockTermIndent << "|||\n";
-        } else {
-            ss << t.data << "\n";
-        }
-    }
-    return ss.str();
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/lexer.h b/vendor/github.com/strickyak/jsonnet_cgo/lexer.h
deleted file mode 100644
index 05176143f319392c64ec5d3e3e80a9c140d8c899..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/lexer.h
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_LEXER_H
-#define JSONNET_LEXER_H
-
-#include <cstdlib>
-#include <cassert>
-
-#include <iostream>
-#include <string>
-#include <list>
-#include <sstream>
-#include <vector>
-
-#include "unicode.h"
-#include "static_error.h"
-
-/** Whitespace and comments.
- *
- * "Fodder" (as in cannon fodder) implies this data is expendable.
- */
-struct FodderElement {
-    enum Kind {
-        LINE_END,
-        INTERSTITIAL,
-        PARAGRAPH,
-    };
-    Kind kind;
-    unsigned blanks;
-    unsigned indent;
-    std::vector<std::string> comment;
-    FodderElement(Kind kind, unsigned blanks, unsigned indent,
-                  const std::vector<std::string> &comment)
-      : kind(kind), blanks(blanks), indent(indent), comment(comment)
-    {
-        assert(kind != LINE_END || comment.size() <= 1);
-        assert(kind != INTERSTITIAL || (blanks == 0 && indent == 0 && comment.size() == 1));
-        assert(kind != PARAGRAPH || comment.size() >= 1);
-    }
-};
-static inline std::ostream &operator<<(std::ostream &o, const FodderElement &f)
-{
-    switch (f.kind) {
-        case FodderElement::LINE_END:
-        o << "END(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << ")";
-        break;
-        case FodderElement::INTERSTITIAL:
-        o << "INT(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << ")";
-        break;
-        case FodderElement::PARAGRAPH:
-        o << "PAR(" << f.blanks << ", " << f.indent << ", " << f.comment[0] << "...)";
-        break;
-    }
-    return o;
-}
-typedef std::vector<FodderElement> Fodder;
-
-static inline std::ostream &operator<<(std::ostream &o, const Fodder &fodder)
-{
-    bool first = true;
-    for (const auto &f : fodder) {
-        o << (first ? "[" : ", ");
-        first = false;
-        o << f;
-    }
-    o << (first ? "[]" : "]");
-    return o;
-}
-
-struct Token {
-    enum Kind {
-        // Symbols
-        BRACE_L,
-        BRACE_R,
-        BRACKET_L,
-        BRACKET_R,
-        COMMA,
-        DOLLAR,
-        DOT,
-        PAREN_L,
-        PAREN_R,
-        SEMICOLON,
-
-        // Arbitrary length lexemes
-        IDENTIFIER,
-        NUMBER,
-        OPERATOR,
-        STRING_DOUBLE,
-        STRING_SINGLE,
-        STRING_BLOCK,
-        VERBATIM_STRING_SINGLE,
-        VERBATIM_STRING_DOUBLE,
-
-        // Keywords
-        ASSERT,
-        ELSE,
-        ERROR,
-        FALSE,
-        FOR,
-        FUNCTION,
-        IF,
-        IMPORT,
-        IMPORTSTR,
-        IN,
-        LOCAL,
-        NULL_LIT,
-        TAILSTRICT,
-        THEN,
-        SELF,
-        SUPER,
-        TRUE,
-
-        // A special token that holds line/column information about the end of the file.
-        END_OF_FILE
-    } kind;
-
-    /** Fodder before this token. */
-    Fodder fodder;
-
-    /** Content of the token if it wasn't a keyword. */
-    std::string data;
-
-    /** If kind == STRING_BLOCK then stores the sequence of whitespace that indented the block. */
-    std::string stringBlockIndent;
-
-    /** If kind == STRING_BLOCK then stores the sequence of whitespace that indented the end of
-     * the block.
-     *
-     * This is always fewer whitespace characters than in stringBlockIndent.
-     */
-    std::string stringBlockTermIndent;
-
-    UString data32(void) { return decode_utf8(data); }
-
-    LocationRange location;
-
-    Token(Kind kind, const Fodder &fodder, const std::string &data,
-          const std::string &string_block_indent, const std::string &string_block_term_indent,
-          const LocationRange &location)
-      : kind(kind), fodder(fodder), data(data), stringBlockIndent(string_block_indent),
-        stringBlockTermIndent(string_block_term_indent), location(location)
-    { }
-
-    Token(Kind kind, const std::string &data="")
-        : kind(kind), data(data) { }
-
-    static const char *toString(Kind v)
-    {
-        switch (v) {
-            case BRACE_L: return "\"{\"";
-            case BRACE_R: return "\"}\"";
-            case BRACKET_L: return "\"[\"";
-            case BRACKET_R: return "\"]\"";
-            case COMMA: return "\",\"";
-            case DOLLAR: return "\"$\"";
-            case DOT: return "\".\"";
-
-            case PAREN_L: return "\"(\"";
-            case PAREN_R: return "\")\"";
-            case SEMICOLON: return "\";\"";
-
-            case IDENTIFIER: return "IDENTIFIER";
-            case NUMBER: return "NUMBER";
-            case OPERATOR: return "OPERATOR";
-            case STRING_SINGLE: return "STRING_SINGLE";
-            case STRING_DOUBLE: return "STRING_DOUBLE";
-            case VERBATIM_STRING_SINGLE: return "VERBATIM_STRING_SINGLE";
-            case VERBATIM_STRING_DOUBLE: return "VERBATIM_STRING_DOUBLE";
-            case STRING_BLOCK: return "STRING_BLOCK";
-
-            case ASSERT: return "assert";
-            case ELSE: return "else";
-            case ERROR: return "error";
-            case FALSE: return "false";
-            case FOR: return "for";
-            case FUNCTION: return "function";
-            case IF: return "if";
-            case IMPORT: return "import";
-            case IMPORTSTR: return "importstr";
-            case IN: return "in";
-            case LOCAL: return "local";
-            case NULL_LIT: return "null";
-            case SELF: return "self";
-            case SUPER: return "super";
-            case TAILSTRICT: return "tailstrict";
-            case THEN: return "then";
-            case TRUE: return "true";
-
-            case END_OF_FILE: return "end of file";
-            default:
-            std::cerr << "INTERNAL ERROR: Unknown token kind: " << v << std::endl;
-            std::abort();
-        }
-    }
-};
-
-/** The result of lexing.
- *
- * Because of the EOF token, this will always contain at least one token.  So element 0 can be used
- * to get the filename.
- */
-typedef std::list<Token> Tokens;
-
-static inline bool operator==(const Token &a, const Token &b)
-{
-    if (a.kind != b.kind) return false;
-    if (a.data != b.data) return false;
-    return true;
-}
-
-static inline std::ostream &operator<<(std::ostream &o, Token::Kind v)
-{
-    o << Token::toString(v);
-    return o;
-}
-
-static inline std::ostream &operator<<(std::ostream &o, const Token &v)
-{
-    if (v.data == "") {
-        o << Token::toString(v.kind);
-    } else if (v.kind == Token::OPERATOR) {
-            o << "\"" << v.data << "\"";
-    } else {
-        o << "(" << Token::toString(v.kind) << ", \"" << v.data << "\")";
-    }
-    return o;
-}
-
-/** IF the given identifier is a keyword, return its kind, otherwise return IDENTIFIER. */
-Token::Kind lex_get_keyword_kind(const std::string &identifier);
-
-Tokens jsonnet_lex(const std::string &filename, const char *input);
-
-std::string jsonnet_unlex(const Tokens &tokens);
-
-#endif  // JSONNET_LEXER_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.cpp b/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.cpp
deleted file mode 100644
index abe97c33c64b70c7612fb0aa999de662c54837b3..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.cpp
+++ /dev/null
@@ -1,673 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <cstdlib>
-#include <cstring>
-#include <cerrno>
-
-#include <exception>
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <string>
-
-extern "C" {
-#include "libjsonnet.h"
-}
-
-#include "desugarer.h"
-#include "formatter.h"
-#include "json.h"
-#include "parser.h"
-#include "static_analysis.h"
-#include "vm.h"
-
-static void memory_panic(void)
-{
-    fputs("FATAL ERROR: A memory allocation error occurred.\n", stderr);
-    abort();
-}
-
-static char *from_string(JsonnetVm* vm, const std::string &v)
-{
-    char *r = jsonnet_realloc(vm, nullptr, v.length() + 1);
-    std::strcpy(r, v.c_str());
-    return r;
-}
-
-static char *default_import_callback(void *ctx, const char *dir, const char *file,
-                                     char **found_here_cptr, int *success);
-
-const char *jsonnet_json_extract_string(JsonnetVm *vm, const struct JsonnetJsonValue *v)
-{
-    (void) vm;
-    if (v->kind != JsonnetJsonValue::STRING)
-        return nullptr;
-    return v->string.c_str();
-}
-
-int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonValue *v, double *out)
-{
-    (void) vm;
-    if (v->kind != JsonnetJsonValue::NUMBER)
-        return 0;
-    *out = v->number;
-    return 1;
-}
-
-int jsonnet_json_extract_bool(struct JsonnetVm *vm, const struct JsonnetJsonValue *v)
-{
-    (void) vm;
-    if (v->kind != JsonnetJsonValue::BOOL) return 2;
-    return v->number != 0;
-}
-
-int jsonnet_json_extract_null(struct JsonnetVm *vm, const struct JsonnetJsonValue *v)
-{
-    (void) vm;
-    return v->kind == JsonnetJsonValue::NULL_KIND;
-}
-
-JsonnetJsonValue *jsonnet_json_make_string(JsonnetVm *vm, const char *v)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::STRING;
-    r->string = v;
-    return r;
-}
-
-JsonnetJsonValue *jsonnet_json_make_number(struct JsonnetVm *vm, double v)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::NUMBER;
-    r->number = v;
-    return r;
-}
-
-JsonnetJsonValue *jsonnet_json_make_bool(struct JsonnetVm *vm, int v)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::BOOL;
-    r->number = v != 0;
-    return r;
-}
-
-JsonnetJsonValue *jsonnet_json_make_null(struct JsonnetVm *vm)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::NULL_KIND;
-    return r;
-}
-
-JsonnetJsonValue *jsonnet_json_make_array(JsonnetVm *vm)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::ARRAY;
-    return r;
-}
-
-void jsonnet_json_array_append(JsonnetVm *vm, JsonnetJsonValue *arr, JsonnetJsonValue *v)
-{
-    (void) vm;
-    assert(arr->kind == JsonnetJsonValue::ARRAY);
-    arr->elements.emplace_back(v);
-}
-
-JsonnetJsonValue *jsonnet_json_make_object(JsonnetVm *vm)
-{
-    (void) vm;
-    JsonnetJsonValue *r = new JsonnetJsonValue();
-    r->kind = JsonnetJsonValue::OBJECT;
-    return r;
-}
-
-void jsonnet_json_object_append(JsonnetVm *vm, JsonnetJsonValue *obj,
-                                const char *f, JsonnetJsonValue *v)
-{
-    (void) vm;
-    assert(obj->kind == JsonnetJsonValue::OBJECT);
-    obj->fields[std::string(f)] = std::unique_ptr<JsonnetJsonValue>(v);
-}
-
-void jsonnet_json_destroy(JsonnetVm *vm, JsonnetJsonValue *v)
-{
-    (void) vm;
-    delete v;
-}
-
-struct JsonnetVm {
-    double gcGrowthTrigger;
-    unsigned maxStack;
-    unsigned gcMinObjects;
-    unsigned maxTrace;
-    std::map<std::string, VmExt> ext;
-    std::map<std::string, VmExt> tla;
-    JsonnetImportCallback *importCallback;
-    VmNativeCallbackMap nativeCallbacks;
-    void *importCallbackContext;
-    bool stringOutput;
-    std::vector<std::string> jpaths;
-
-    FmtOpts fmtOpts;
-    bool fmtDebugDesugaring;
-
-    JsonnetVm(void)
-      : gcGrowthTrigger(2.0), maxStack(500), gcMinObjects(1000), maxTrace(20),
-        importCallback(default_import_callback), importCallbackContext(this), stringOutput(false),
-        fmtDebugDesugaring(false)
-    {
-        jpaths.emplace_back("/usr/share/" + std::string(jsonnet_version()) + "/");
-        jpaths.emplace_back("/usr/local/share/" + std::string(jsonnet_version()) + "/");
-    }
-};
-
-enum ImportStatus {
-    IMPORT_STATUS_OK,
-    IMPORT_STATUS_FILE_NOT_FOUND,
-    IMPORT_STATUS_IO_ERROR
-};
-
-static enum ImportStatus try_path(const std::string &dir, const std::string &rel,
-                                  std::string &content, std::string &found_here,
-                                  std::string &err_msg)
-{
-    std::string abs_path;
-    if (rel.length() == 0) {
-        err_msg = "The empty string is not a valid filename";
-        return IMPORT_STATUS_IO_ERROR;
-    }
-    // It is possible that rel is actually absolute.
-    if (rel[0] == '/') {
-        abs_path = rel;
-    } else {
-        abs_path = dir + rel;
-    }
-
-    if (abs_path[abs_path.length() - 1] == '/') {
-        err_msg = "Attempted to import a directory";
-        return IMPORT_STATUS_IO_ERROR;
-    }
-
-    std::ifstream f;
-    f.open(abs_path.c_str());
-    if (!f.good()) return IMPORT_STATUS_FILE_NOT_FOUND;
-    try {
-        content.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
-    } catch (const std::ios_base::failure &io_err) {
-        err_msg = io_err.what();
-        return IMPORT_STATUS_IO_ERROR;
-    }
-    if (!f.good()) {
-        err_msg = strerror(errno);
-        return IMPORT_STATUS_IO_ERROR;
-    }
-
-    found_here = abs_path;
-
-    return IMPORT_STATUS_OK;
-}
-
-static char *default_import_callback(void *ctx, const char *dir, const char *file,
-                                     char **found_here_cptr, int *success)
-{
-    auto *vm = static_cast<JsonnetVm*>(ctx);
-
-    std::string input, found_here, err_msg;
-
-    ImportStatus status = try_path(dir, file, input, found_here, err_msg);
-
-    std::vector<std::string> jpaths(vm->jpaths);
-
-    // If not found, try library search path.
-    while (status == IMPORT_STATUS_FILE_NOT_FOUND) {
-        if (jpaths.size() == 0) {
-            *success = 0;
-            const char *err = "No match locally or in the Jsonnet library paths.";
-            char *r = jsonnet_realloc(vm, nullptr, std::strlen(err) + 1);
-            std::strcpy(r, err);
-            return r;
-        }
-        status = try_path(jpaths.back(), file, input, found_here, err_msg);
-        jpaths.pop_back();
-    }
-
-    if (status == IMPORT_STATUS_IO_ERROR) {
-        *success = 0;
-        return from_string(vm, err_msg);
-    } else {
-        assert(status == IMPORT_STATUS_OK);
-        *success = 1;
-        *found_here_cptr = from_string(vm, found_here);
-        return from_string(vm, input);
-    }
-}
-
-#define TRY try {
-#define CATCH(func) \
-    } catch (const std::bad_alloc &) {\
-        memory_panic(); \
-    } catch (const std::exception &e) {\
-        std::cerr << "Something went wrong during " func ", please report this: " \
-                  << e.what() << std::endl; \
-        abort(); \
-    }
-
-const char *jsonnet_version(void)
-{
-    return LIB_JSONNET_VERSION;
-}
-
-JsonnetVm *jsonnet_make(void)
-{
-    TRY
-    return new JsonnetVm();
-    CATCH("jsonnet_make")
-    return nullptr;
-}
-
-void jsonnet_destroy(JsonnetVm *vm)
-{
-    TRY
-    delete vm;
-    CATCH("jsonnet_destroy")
-}
-
-void jsonnet_max_stack(JsonnetVm *vm, unsigned v)
-{
-    vm->maxStack = v;
-}
-
-void jsonnet_gc_min_objects(JsonnetVm *vm, unsigned v)
-{
-    vm->gcMinObjects = v;
-}
-
-void jsonnet_gc_growth_trigger(JsonnetVm *vm, double v)
-{
-    vm->gcGrowthTrigger = v;
-}
-
-void jsonnet_string_output(struct JsonnetVm *vm, int v)
-{
-    vm->stringOutput = bool(v);
-}
-
-void jsonnet_import_callback(struct JsonnetVm *vm, JsonnetImportCallback *cb, void *ctx)
-{
-    vm->importCallback = cb;
-    vm->importCallbackContext = ctx;
-}
-
-void jsonnet_native_callback(struct JsonnetVm *vm, const char *name, JsonnetNativeCallback *cb,
-                             void *ctx, const char * const *params)
-{
-    std::vector<std::string> params2;
-    for (; *params != nullptr; params++)
-        params2.push_back(*params);
-    vm->nativeCallbacks[name] = VmNativeCallback {cb, ctx, params2};
-}
-
-
-void jsonnet_ext_var(JsonnetVm *vm, const char *key, const char *val)
-{
-    vm->ext[key] = VmExt(val, false);
-}
-
-void jsonnet_ext_code(JsonnetVm *vm, const char *key, const char *val)
-{
-    vm->ext[key] = VmExt(val, true);
-}
-
-void jsonnet_tla_var(JsonnetVm *vm, const char *key, const char *val)
-{
-    vm->tla[key] = VmExt(val, false);
-}
-
-void jsonnet_tla_code(JsonnetVm *vm, const char *key, const char *val)
-{
-    vm->tla[key] = VmExt(val, true);
-}
-
-void jsonnet_fmt_debug_desugaring(JsonnetVm *vm, int v)
-{
-    vm->fmtDebugDesugaring = v;
-}
-
-void jsonnet_fmt_indent(JsonnetVm *vm, int v)
-{
-    vm->fmtOpts.indent = v;
-}
-
-void jsonnet_fmt_max_blank_lines(JsonnetVm *vm, int v)
-{
-    vm->fmtOpts.maxBlankLines = v;
-}
-
-void jsonnet_fmt_string(JsonnetVm *vm, int v)
-{
-    if (v != 'd' && v != 's' && v != 'l')
-        v = 'l';
-    vm->fmtOpts.stringStyle = v;
-}
-
-void jsonnet_fmt_comment(JsonnetVm *vm, int v)
-{
-    if (v != 'h' && v != 's' && v != 'l')
-        v = 'l';
-    vm->fmtOpts.commentStyle = v;
-}
-
-void jsonnet_fmt_pad_arrays(JsonnetVm *vm, int v)
-{
-    vm->fmtOpts.padArrays = v;
-}
-
-void jsonnet_fmt_pad_objects(JsonnetVm *vm, int v)
-{
-    vm->fmtOpts.padObjects = v;
-}
-
-void jsonnet_fmt_pretty_field_names(JsonnetVm *vm, int v)
-{
-    vm->fmtOpts.prettyFieldNames = v;
-}
-
-void jsonnet_max_trace(JsonnetVm *vm, unsigned v)
-{
-    vm->maxTrace = v;
-}
-
-void jsonnet_jpath_add(JsonnetVm *vm, const char *path_)
-{
-    if (std::strlen(path_) == 0) return;
-    std::string path = path_;
-    if (path[path.length() - 1] != '/') path += '/';
-    vm->jpaths.emplace_back(path);
-}
-
-static char *jsonnet_fmt_snippet_aux(JsonnetVm *vm, const char *filename, const char *snippet,
-                                     int *error)
-{
-    try {
-        Allocator alloc;
-        std::string json_str;
-        AST *expr;
-        std::map<std::string, std::string> files;
-        Tokens tokens = jsonnet_lex(filename, snippet);
-
-        // std::cout << jsonnet_unlex(tokens);
-
-        expr = jsonnet_parse(&alloc, tokens);
-        Fodder final_fodder = tokens.front().fodder;
-
-        if (vm->fmtDebugDesugaring)
-            jsonnet_desugar(&alloc, expr, &vm->tla);
-
-        json_str = jsonnet_fmt(expr, final_fodder, vm->fmtOpts);
-
-        json_str += "\n";
-
-        *error = false;
-        return from_string(vm, json_str);
-
-    } catch (StaticError &e) {
-        std::stringstream ss;
-        ss << "STATIC ERROR: " << e << std::endl;
-        *error = true;
-        return from_string(vm, ss.str());
-    }
-
-}
-
-char *jsonnet_fmt_file(JsonnetVm *vm, const char *filename, int *error)
-{
-    TRY
-        std::ifstream f;
-        f.open(filename);
-        if (!f.good()) {
-            std::stringstream ss;
-            ss << "Opening input file: " << filename << ": " << strerror(errno);
-            *error = true;
-            return from_string(vm, ss.str());
-        }
-        std::string input;
-        input.assign(std::istreambuf_iterator<char>(f),
-                     std::istreambuf_iterator<char>());
-
-        return jsonnet_fmt_snippet_aux(vm, filename, input.c_str(), error);
-    CATCH("jsonnet_fmt_file")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_fmt_snippet(JsonnetVm *vm, const char *filename, const char *snippet, int *error)
-{
-    TRY
-        return jsonnet_fmt_snippet_aux(vm, filename, snippet, error);
-    CATCH("jsonnet_fmt_snippet")
-    return nullptr;  // Never happens.
-}
-
-
-namespace {
-enum EvalKind { REGULAR, MULTI, STREAM };
-}  // namespace
-
-static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
-                                          const char *snippet, int *error, EvalKind kind)
-{
-    try {
-        Allocator alloc;
-        AST *expr;
-        Tokens tokens = jsonnet_lex(filename, snippet);
-
-        expr = jsonnet_parse(&alloc, tokens);
-
-        jsonnet_desugar(&alloc, expr, &vm->tla);
-
-        jsonnet_static_analysis(expr);
-        switch (kind) {
-            case REGULAR: {
-                std::string json_str = jsonnet_vm_execute(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext, vm->stringOutput);
-                json_str += "\n";
-                *error = false;
-                return from_string(vm, json_str);
-            }
-            break;
-
-            case MULTI: {
-                std::map<std::string, std::string> files = jsonnet_vm_execute_multi(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext, vm->stringOutput);
-                size_t sz = 1; // final sentinel
-                for (const auto &pair : files) {
-                    sz += pair.first.length() + 1; // include sentinel
-                    sz += pair.second.length() + 2; // Add a '\n' as well as sentinel
-                }
-                char *buf = (char*)::malloc(sz);
-                if (buf == nullptr) memory_panic();
-                std::ptrdiff_t i = 0;
-                for (const auto &pair : files) {
-                    memcpy(&buf[i], pair.first.c_str(), pair.first.length() + 1);
-                    i += pair.first.length() + 1;
-                    memcpy(&buf[i], pair.second.c_str(), pair.second.length());
-                    i += pair.second.length();
-                    buf[i] = '\n';
-                    i++;
-                    buf[i] = '\0';
-                    i++;
-                }
-                buf[i] = '\0'; // final sentinel
-                *error = false;
-                return buf;
-            }
-            break;
-
-            case STREAM: {
-                std::vector<std::string> documents = jsonnet_vm_execute_stream(
-                    &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
-                    vm->importCallbackContext);
-                size_t sz = 1; // final sentinel
-                for (const auto &doc : documents) {
-                    sz += doc.length() + 2; // Add a '\n' as well as sentinel
-                }
-                char *buf = (char*)::malloc(sz);
-                if (buf == nullptr) memory_panic();
-                std::ptrdiff_t i = 0;
-                for (const auto &doc : documents) {
-                    memcpy(&buf[i], doc.c_str(), doc.length());
-                    i += doc.length();
-                    buf[i] = '\n';
-                    i++;
-                    buf[i] = '\0';
-                    i++;
-                }
-                buf[i] = '\0'; // final sentinel
-                *error = false;
-                return buf;
-            }
-            break;
-
-            default:
-            fputs("INTERNAL ERROR: bad value of 'kind', probably memory corruption.\n", stderr);
-            abort();
-        }
-
-    } catch (StaticError &e) {
-        std::stringstream ss;
-        ss << "STATIC ERROR: " << e << std::endl;
-        *error = true;
-        return from_string(vm, ss.str());
-
-    } catch (RuntimeError &e) {
-        std::stringstream ss;
-        ss << "RUNTIME ERROR: " << e.msg << std::endl;
-        const long max_above = vm->maxTrace / 2;
-        const long max_below = vm->maxTrace - max_above;
-        const long sz = e.stackTrace.size();
-        for (long i = 0 ; i < sz ; ++i) {
-            const auto &f = e.stackTrace[i];
-            if (vm->maxTrace > 0 && i >= max_above && i < sz - max_below) {
-                if (i == max_above)
-                    ss << "\t..." << std::endl;
-            } else {
-                ss << "\t" << f.location << "\t" << f.name << std::endl;
-            }
-        }
-        *error = true;
-        return from_string(vm, ss.str());
-    }
-
-    return nullptr;  // Quiet, compiler.
-}
-
-static char *jsonnet_evaluate_file_aux(JsonnetVm *vm, const char *filename, int *error,
-                                       EvalKind kind)
-{
-    std::ifstream f;
-    f.open(filename);
-    if (!f.good()) {
-        std::stringstream ss;
-        ss << "Opening input file: " << filename << ": " << strerror(errno);
-        *error = true;
-        return from_string(vm, ss.str());
-    }
-    std::string input;
-    input.assign(std::istreambuf_iterator<char>(f),
-                 std::istreambuf_iterator<char>());
-
-    return jsonnet_evaluate_snippet_aux(vm, filename, input.c_str(), error, kind);
-}
-
-char *jsonnet_evaluate_file(JsonnetVm *vm, const char *filename, int *error)
-{
-    TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, REGULAR);
-    CATCH("jsonnet_evaluate_file")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_evaluate_file_multi(JsonnetVm *vm, const char *filename, int *error)
-{
-    TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, MULTI);
-    CATCH("jsonnet_evaluate_file_multi")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_evaluate_file_stream(JsonnetVm *vm, const char *filename, int *error)
-{
-    TRY
-    return jsonnet_evaluate_file_aux(vm, filename, error, STREAM);
-    CATCH("jsonnet_evaluate_file_stream")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_evaluate_snippet(JsonnetVm *vm, const char *filename, const char *snippet, int *error)
-{
-    TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, REGULAR);
-    CATCH("jsonnet_evaluate_snippet")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_evaluate_snippet_multi(JsonnetVm *vm, const char *filename,
-                                     const char *snippet, int *error)
-{
-    TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, MULTI);
-    CATCH("jsonnet_evaluate_snippet_multi")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_evaluate_snippet_stream(JsonnetVm *vm, const char *filename,
-                                     const char *snippet, int *error)
-{
-    TRY
-    return jsonnet_evaluate_snippet_aux(vm, filename, snippet, error, STREAM);
-    CATCH("jsonnet_evaluate_snippet_stream")
-    return nullptr;  // Never happens.
-}
-
-char *jsonnet_realloc(JsonnetVm *vm, char *str, size_t sz)
-{
-    (void) vm;
-    if (str == nullptr) {
-        if (sz == 0) return nullptr;
-        auto *r = static_cast<char*>(::malloc(sz));
-        if (r == nullptr) memory_panic();
-        return r;
-    } else {
-        if (sz == 0) {
-            ::free(str);
-            return nullptr;
-        } else {
-            auto *r = static_cast<char*>(::realloc(str, sz));
-            if (r == nullptr) memory_panic();
-            return r;
-        }
-    }
-}
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.h b/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.h
deleted file mode 100644
index ebaf8ff1999c1b3e568d0e934d34d6acea8736c0..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/libjsonnet.h
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef LIB_JSONNET_H
-#define LIB_JSONNET_H
-
-#include <stddef.h>
-
-/** \file This file is a library interface for evaluating Jsonnet.  It is written in C++ but exposes
- * a C interface for easier wrapping by other languages.  See \see jsonnet_lib_test.c for an example
- * of using the library.
- */
-
-
-#define LIB_JSONNET_VERSION "v0.9.4"
-
-
-/** Return the version string of the Jsonnet interpreter.  Conforms to semantic versioning
- * http://semver.org/ If this does not match LIB_JSONNET_VERSION then there is a mismatch between
- * header and compiled library.
- */
-const char *jsonnet_version(void);
-
-/** Jsonnet virtual machine context. */
-struct JsonnetVm;
-
-/** Create a new Jsonnet virtual machine. */
-struct JsonnetVm *jsonnet_make(void);
-
-/** Set the maximum stack depth. */
-void jsonnet_max_stack(struct JsonnetVm *vm, unsigned v);
-
-/** Set the number of objects required before a garbage collection cycle is allowed. */
-void jsonnet_gc_min_objects(struct JsonnetVm *vm, unsigned v);
-
-/** Run the garbage collector after this amount of growth in the number of objects. */
-void jsonnet_gc_growth_trigger(struct JsonnetVm *vm, double v);
-
-/** Expect a string as output and don't JSON encode it. */
-void jsonnet_string_output(struct JsonnetVm *vm, int v);
-
-/** Callback used to load imports.
- *
- * The returned char* should be allocated with jsonnet_realloc.  It will be cleaned up by
- * libjsonnet when no-longer needed.
- *
- * \param ctx User pointer, given in jsonnet_import_callback.
- * \param base The directory containing the code that did the import.
- * \param rel The path imported by the code.
- * \param found_here Set this byref param to path to the file, absolute or relative to the
- *     process's CWD.  This is necessary so that imports from the content of the imported file can
- *     be resolved correctly.  Allocate memory with jsonnet_realloc.  Only use when *success = 0.
- * \param success Set this byref param to 1 to indicate success and 0 for failure.
- * \returns The content of the imported file, or an error message.
- */
-typedef char *JsonnetImportCallback(void *ctx, const char *base, const char *rel, char **found_here, int *success);
-
-/** An opaque type which can only be utilized via the jsonnet_json_* family of functions.
- */
-struct JsonnetJsonValue;
-
-/** If the value is a string, return it as UTF8 otherwise return NULL.
- */
-const char *jsonnet_json_extract_string(struct JsonnetVm *vm, const struct JsonnetJsonValue *v);
-
-/** If the value is a number, return 1 and store the number in out, otherwise return 0.
- */
-int jsonnet_json_extract_number(struct JsonnetVm *vm, const struct JsonnetJsonValue *v, double *out);
-
-/** Return 0 if the value is false, 1 if it is true, and 2 if it is not a bool.
- */
-int jsonnet_json_extract_bool(struct JsonnetVm *vm, const struct JsonnetJsonValue *v);
-
-/** Return 1 if the value is null, else 0.
- */
-int jsonnet_json_extract_null(struct JsonnetVm *vm, const struct JsonnetJsonValue *v);
-
-/** Convert the given UTF8 string to a JsonnetJsonValue.
- */
-struct JsonnetJsonValue *jsonnet_json_make_string(struct JsonnetVm *vm, const char *v);
-
-/** Convert the given double to a JsonnetJsonValue.
- */
-struct JsonnetJsonValue *jsonnet_json_make_number(struct JsonnetVm *vm, double v);
-
-/** Convert the given bool (1 or 0) to a JsonnetJsonValue.
- */
-struct JsonnetJsonValue *jsonnet_json_make_bool(struct JsonnetVm *vm, int v);
-
-/** Make a JsonnetJsonValue representing null.
- */
-struct JsonnetJsonValue *jsonnet_json_make_null(struct JsonnetVm *vm);
-
-/** Make a JsonnetJsonValue representing an array.
- *
- * Assign elements with jsonnet_json_array_append.
- */
-struct JsonnetJsonValue *jsonnet_json_make_array(struct JsonnetVm *vm);
-
-/** Add v to the end of the array.
- */
-void jsonnet_json_array_append(struct JsonnetVm *vm,
-                               struct JsonnetJsonValue *arr,
-                               struct JsonnetJsonValue *v);
-
-/** Make a JsonnetJsonValue representing an object with the given number of fields.
- *
- * Every index of the array must have a unique value assigned with jsonnet_json_array_element.
- */
-struct JsonnetJsonValue *jsonnet_json_make_object(struct JsonnetVm *vm);
-
-/** Add the field f to the object, bound to v.
- *
- * This replaces any previous binding of the field.
- */
-void jsonnet_json_object_append(struct JsonnetVm *vm,
-                                struct JsonnetJsonValue *obj,
-                                const char *f,
-                                struct JsonnetJsonValue *v);
-
-/** Clean up a JSON subtree.
- *
- * This is useful if you want to abort with an error mid-way through building a complex value.
- */
-void jsonnet_json_destroy(struct JsonnetVm *vm, struct JsonnetJsonValue *v);
-
-/** Callback to provide native extensions to Jsonnet.
- *
- * The returned JsonnetJsonValue* should be allocated with jsonnet_realloc.  It will be cleaned up
- * along with the objects rooted at argv by libjsonnet when no-longer needed.  Return a string upon
- * failure, which will appear in Jsonnet as an error.
- *
- * \param ctx User pointer, given in jsonnet_native_callback.
- * \param argc The number of arguments from Jsonnet code.
- * \param argv Array of arguments from Jsonnet code.
- * \param success Set this byref param to 1 to indicate success and 0 for failure.
- * \returns The content of the imported file, or an error message.
- */
-typedef struct JsonnetJsonValue *JsonnetNativeCallback(void *ctx,
-                                                       const struct JsonnetJsonValue * const *argv,
-                                                       int *success);
-
-/** Allocate, resize, or free a buffer.  This will abort if the memory cannot be allocated.  It will
- * only return NULL if sz was zero.
- *
- * \param buf If NULL, allocate a new buffer.  If an previously allocated buffer, resize it.
- * \param sz The size of the buffer to return.  If zero, frees the buffer.
- * \returns The new buffer.
- */
-char *jsonnet_realloc(struct JsonnetVm *vm, char *buf, size_t sz);
-
-/** Override the callback used to locate imports.
- */
-void jsonnet_import_callback(struct JsonnetVm *vm, JsonnetImportCallback *cb, void *ctx);
-
-/** Register a native extension.
- *
- * This will appear in Jsonnet as a function type and can be accessed from std.nativeExt("foo").
- *
- * DO NOT register native callbacks with side-effects!  Jsonnet is a lazy functional language and
- * will call your function when you least expect it, more times than you expect, or not at all.
- *
- * \param vm The vm.
- * \param name The name of the function as visible to Jsonnet code, e.g. "foo".
- * \param cb The PURE function that implements the behavior you want.
- * \param ctx User pointer, stash non-global state you need here.
- * \param params NULL-terminated array of the names of the params.  Must be valid identifiers.
- */
-void jsonnet_native_callback(struct JsonnetVm *vm, const char *name, JsonnetNativeCallback *cb,
-                             void *ctx, const char * const *params);
-
-/** Bind a Jsonnet external var to the given string.
- *
- * Argument values are copied so memory should be managed by caller.
- */
-void jsonnet_ext_var(struct JsonnetVm *vm, const char *key, const char *val);
-
-/** Bind a Jsonnet external var to the given code.
- *
- * Argument values are copied so memory should be managed by caller.
- */
-void jsonnet_ext_code(struct JsonnetVm *vm, const char *key, const char *val);
-
-/** Bind a string top-level argument for a top-level parameter.
- *
- * Argument values are copied so memory should be managed by caller.
- */
-void jsonnet_tla_var(struct JsonnetVm *vm, const char *key, const char *val);
-
-/** Bind a code top-level argument for a top-level parameter.
- *
- * Argument values are copied so memory should be managed by caller.
- */
-void jsonnet_tla_code(struct JsonnetVm *vm, const char *key, const char *val);
-
-/** Indentation level when reformatting (number of spaeces).
- *
- * \param n Number of spaces, must be > 0.
- */
-void jsonnet_fmt_indent(struct JsonnetVm *vm, int n);
-
-/** Indentation level when reformatting (number of spaeces).
- *
- * \param n Number of spaces, must be > 0.
- */
-void jsonnet_fmt_max_blank_lines(struct JsonnetVm *vm, int n);
-
-/** Preferred style for string literals ("" or '').
- *
- * \param c String style as a char ('d', 's', or 'l' (leave)).
- */
-void jsonnet_fmt_string(struct JsonnetVm *vm, int c);
-
-/** Preferred style for line comments (# or //).
- *
- * \param c Comment style as a char ('h', 's', or 'l' (leave)).
- */
-void jsonnet_fmt_comment(struct JsonnetVm *vm, int c);
-
-/** Whether to add an extra space on the inside of arrays.
- */
-void jsonnet_fmt_pad_arrays(struct JsonnetVm *vm, int v);
-
-/** Whether to add an extra space on the inside of objects.
- */
-void jsonnet_fmt_pad_objects(struct JsonnetVm *vm, int v);
-
-/** Use syntax sugar where possible with field names.
- */
-void jsonnet_fmt_pretty_field_names(struct JsonnetVm *vm, int v);
-
-/** If set to 1, will reformat the Jsonnet input after desugaring. */
-void jsonnet_fmt_debug_desugaring(struct JsonnetVm *vm, int v);
-
-/** Reformat a file containing Jsonnet code, return a Jsonnet string.
- *
- * The returned string should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param error Return by reference whether or not there was an error.
- * \returns Either Jsonnet code or the error message.
- */
-char *jsonnet_fmt_file(struct JsonnetVm *vm,
-                       const char *filename,
-                       int *error);
-
-/** Evaluate a string containing Jsonnet code, return a Jsonnet string.
- *
- * The returned string should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file (used in error messages).
- * \param snippet Jsonnet code to execute.
- * \param error Return by reference whether or not there was an error.
- * \returns Either JSON or the error message.
- */
-char *jsonnet_fmt_snippet(struct JsonnetVm *vm,
-                          const char *filename,
-                          const char *snippet,
-                          int *error);
-
-/** Set the number of lines of stack trace to display (0 for all of them). */
-void jsonnet_max_trace(struct JsonnetVm *vm, unsigned v);
-
-/** Add to the default import callback's library search path. */
-void jsonnet_jpath_add(struct JsonnetVm *vm, const char *v);
-
-/** Evaluate a file containing Jsonnet code, return a JSON string.
- *
- * The returned string should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param error Return by reference whether or not there was an error.
- * \returns Either JSON or the error message.
- */
-char *jsonnet_evaluate_file(struct JsonnetVm *vm,
-                            const char *filename,
-                            int *error);
-
-/** Evaluate a string containing Jsonnet code, return a JSON string.
- *
- * The returned string should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file (used in error messages).
- * \param snippet Jsonnet code to execute.
- * \param error Return by reference whether or not there was an error.
- * \returns Either JSON or the error message.
- */
-char *jsonnet_evaluate_snippet(struct JsonnetVm *vm,
-                               const char *filename,
-                               const char *snippet,
-                               int *error);
-
-/** Evaluate a file containing Jsonnet code, return a number of named JSON files.
- *
- * The returned character buffer contains an even number of strings, the filename and JSON for each
- * JSON file interleaved.  It should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param error Return by reference whether or not there was an error.
- * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
- */
-char *jsonnet_evaluate_file_multi(struct JsonnetVm *vm,
-                                  const char *filename,
-                                  int *error);
-
-/** Evaluate a string containing Jsonnet code, return a number of named JSON files.
- *
- * The returned character buffer contains an even number of strings, the filename and JSON for each
- * JSON file interleaved.  It should be cleaned up with jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param snippet Jsonnet code to execute.
- * \param error Return by reference whether or not there was an error.
- * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
- */
-char *jsonnet_evaluate_snippet_multi(struct JsonnetVm *vm,
-                                     const char *filename,
-                                     const char *snippet,
-                                     int *error);
-
-/** Evaluate a file containing Jsonnet code, return a number of JSON files.
- *
- * The returned character buffer contains several strings.  It should be cleaned up with
- * jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param error Return by reference whether or not there was an error.
- * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
- */
-char *jsonnet_evaluate_file_stream(struct JsonnetVm *vm,
-                                   const char *filename,
-                                   int *error);
-
-/** Evaluate a string containing Jsonnet code, return a number of JSON files.
- *
- * The returned character buffer contains several strings.  It should be cleaned up with
- * jsonnet_realloc.
- *
- * \param filename Path to a file containing Jsonnet code.
- * \param snippet Jsonnet code to execute.
- * \param error Return by reference whether or not there was an error.
- * \returns Either the error, or a sequence of strings separated by \0, terminated with \0\0.
- */
-char *jsonnet_evaluate_snippet_stream(struct JsonnetVm *vm,
-                                      const char *filename,
-                                      const char *snippet,
-                                      int *error);
-
-/** Complement of \see jsonnet_vm_make. */
-void jsonnet_destroy(struct JsonnetVm *vm);
-
-#endif  // LIB_JSONNET_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/md5.cpp b/vendor/github.com/strickyak/jsonnet_cgo/md5.cpp
deleted file mode 100644
index b51d2e9bdd68a47ba2dc31528080f607546ab1b6..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/md5.cpp
+++ /dev/null
@@ -1,363 +0,0 @@
-/* MD5
- converted to C++ class by Frank Thilo (thilo@unix-ag.org)
- for bzflag (http://www.bzflag.org)
- 
-   based on:
- 
-   md5.h and md5.c
-   reference implemantion of RFC 1321
- 
-   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-rights reserved.
- 
-License to copy and use this software is granted provided that it
-is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-Algorithm" in all material mentioning or referencing this software
-or this function.
- 
-License is also granted to make and use derivative works provided
-that such works are identified as "derived from the RSA Data
-Security, Inc. MD5 Message-Digest Algorithm" in all material
-mentioning or referencing the derived work.
- 
-RSA Data Security, Inc. makes no representations concerning either
-the merchantability of this software or the suitability of this
-software for any particular purpose. It is provided "as is"
-without express or implied warranty of any kind.
- 
-These notices must be retained in any copies of any part of this
-documentation and/or software.
- 
-*/
- 
-/* interface header */
-#include "md5.h"
- 
-/* system implementation headers */
-#include <cstdio>
- 
- 
-// Constants for MD5Transform routine.
-#define S11 7
-#define S12 12
-#define S13 17
-#define S14 22
-#define S21 5
-#define S22 9
-#define S23 14
-#define S24 20
-#define S31 4
-#define S32 11
-#define S33 16
-#define S34 23
-#define S41 6
-#define S42 10
-#define S43 15
-#define S44 21
- 
-///////////////////////////////////////////////
- 
-// F, G, H and I are basic MD5 functions.
-inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
-  return (x&y) | (~x&z);
-}
- 
-inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
-  return (x&z) | (y&~z);
-}
- 
-inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
-  return x^y^z;
-}
- 
-inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
-  return y ^ (x | ~z);
-}
- 
-// rotate_left rotates x left n bits.
-inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
-  return (x << n) | (x >> (32-n));
-}
- 
-// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
-// Rotation is separate from addition to prevent recomputation.
-inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
-  a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
-}
- 
-inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
-  a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
-}
- 
-inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
-  a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
-}
- 
-inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
-  a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
-}
- 
-//////////////////////////////////////////////
- 
-// default ctor, just initailize
-MD5::MD5()
-{
-  init();
-}
- 
-//////////////////////////////////////////////
- 
-// nifty shortcut ctor, compute MD5 for string and finalize it right away
-MD5::MD5(const std::string &text)
-{
-  init();
-  update(text.c_str(), text.length());
-  finalize();
-}
- 
-//////////////////////////////
- 
-void MD5::init()
-{
-  finalized=false;
- 
-  count[0] = 0;
-  count[1] = 0;
- 
-  // load magic initialization constants.
-  state[0] = 0x67452301;
-  state[1] = 0xefcdab89;
-  state[2] = 0x98badcfe;
-  state[3] = 0x10325476;
-}
- 
-//////////////////////////////
- 
-// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
-void MD5::decode(uint4 output[], const uint1 input[], size_type len)
-{
-  for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
-    output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
-      (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
-}
- 
-//////////////////////////////
- 
-// encodes input (uint4) into output (unsigned char). Assumes len is
-// a multiple of 4.
-void MD5::encode(uint1 output[], const uint4 input[], size_type len)
-{
-  for (size_type i = 0, j = 0; j < len; i++, j += 4) {
-    output[j] = input[i] & 0xff;
-    output[j+1] = (input[i] >> 8) & 0xff;
-    output[j+2] = (input[i] >> 16) & 0xff;
-    output[j+3] = (input[i] >> 24) & 0xff;
-  }
-}
- 
-//////////////////////////////
- 
-// apply MD5 algo on a block
-void MD5::transform(const uint1 block[blocksize])
-{
-  uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
-  decode (x, block, blocksize);
- 
-  /* Round 1 */
-  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
-  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
-  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
-  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
-  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
-  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
-  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
-  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
-  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
-  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
-  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
-  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
-  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
-  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
-  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
-  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
- 
-  /* Round 2 */
-  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
-  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
-  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
-  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
-  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
-  GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
-  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
-  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
-  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
-  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
-  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
-  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
-  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
-  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
-  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
-  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
- 
-  /* Round 3 */
-  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
-  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
-  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
-  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
-  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
-  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
-  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
-  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
-  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
-  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
-  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
-  HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
-  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
-  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
-  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
-  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
- 
-  /* Round 4 */
-  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
-  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
-  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
-  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
-  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
-  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
-  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
-  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
-  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
-  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
-  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
-  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
-  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
-  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
-  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
-  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
- 
-  state[0] += a;
-  state[1] += b;
-  state[2] += c;
-  state[3] += d;
- 
-  // Zeroize sensitive information.
-  memset(x, 0, sizeof x);
-}
- 
-//////////////////////////////
- 
-// MD5 block update operation. Continues an MD5 message-digest
-// operation, processing another message block
-void MD5::update(const unsigned char input[], size_type length)
-{
-  // compute number of bytes mod 64
-  size_type index = count[0] / 8 % blocksize;
- 
-  // Update number of bits
-  if ((count[0] += (length << 3)) < (length << 3))
-    count[1]++;
-  count[1] += (length >> 29);
- 
-  // number of bytes we need to fill in buffer
-  size_type firstpart = 64 - index;
- 
-  size_type i;
- 
-  // transform as many times as possible.
-  if (length >= firstpart)
-  {
-    // fill buffer first, transform
-    memcpy(&buffer[index], input, firstpart);
-    transform(buffer);
- 
-    // transform chunks of blocksize (64 bytes)
-    for (i = firstpart; i + blocksize <= length; i += blocksize)
-      transform(&input[i]);
- 
-    index = 0;
-  }
-  else
-    i = 0;
- 
-  // buffer remaining input
-  memcpy(&buffer[index], &input[i], length-i);
-}
- 
-//////////////////////////////
- 
-// for convenience provide a verson with signed char
-void MD5::update(const char input[], size_type length)
-{
-  update((const unsigned char*)input, length);
-}
- 
-//////////////////////////////
- 
-// MD5 finalization. Ends an MD5 message-digest operation, writing the
-// the message digest and zeroizing the context.
-MD5& MD5::finalize()
-{
-  static unsigned char padding[64] = {
-    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-  };
- 
-  if (!finalized) {
-    // Save number of bits
-    unsigned char bits[8];
-    encode(bits, count, 8);
- 
-    // pad out to 56 mod 64.
-    size_type index = count[0] / 8 % 64;
-    size_type padLen = (index < 56) ? (56 - index) : (120 - index);
-    update(padding, padLen);
- 
-    // Append length (before padding)
-    update(bits, 8);
- 
-    // Store state in digest
-    encode(digest, state, 16);
- 
-    // Zeroize sensitive information.
-    memset(buffer, 0, sizeof buffer);
-    memset(count, 0, sizeof count);
- 
-    finalized=true;
-  }
- 
-  return *this;
-}
- 
-//////////////////////////////
- 
-// return hex representation of digest as string
-std::string MD5::hexdigest() const
-{
-  if (!finalized)
-    return "";
- 
-  char buf[33];
-  for (int i=0; i<16; i++)
-    sprintf(buf+i*2, "%02x", digest[i]);
-  buf[32]=0;
- 
-  return std::string(buf);
-}
- 
-//////////////////////////////
- 
-std::ostream& operator<<(std::ostream& out, MD5 md5)
-{
-  return out << md5.hexdigest();
-}
- 
-//////////////////////////////
- 
-std::string md5(const std::string str)
-{
-    MD5 md5 = MD5(str);
- 
-    return md5.hexdigest();
-}
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/md5.h b/vendor/github.com/strickyak/jsonnet_cgo/md5.h
deleted file mode 100644
index d57b2c647bd2188da6a298ad3cc07642d112fd0b..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/md5.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/* MD5
- converted to C++ class by Frank Thilo (thilo@unix-ag.org)
- for bzflag (http://www.bzflag.org)
- 
-   based on:
- 
-   md5.h and md5.c
-   reference implementation of RFC 1321
- 
-   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-rights reserved.
- 
-License to copy and use this software is granted provided that it
-is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-Algorithm" in all material mentioning or referencing this software
-or this function.
- 
-License is also granted to make and use derivative works provided
-that such works are identified as "derived from the RSA Data
-Security, Inc. MD5 Message-Digest Algorithm" in all material
-mentioning or referencing the derived work.
- 
-RSA Data Security, Inc. makes no representations concerning either
-the merchantability of this software or the suitability of this
-software for any particular purpose. It is provided "as is"
-without express or implied warranty of any kind.
- 
-These notices must be retained in any copies of any part of this
-documentation and/or software.
- 
-*/
- 
-#ifndef BZF_MD5_H
-#define BZF_MD5_H
- 
-#include <cstring>
-#include <iostream>
- 
- 
-// a small class for calculating MD5 hashes of strings or byte arrays
-// it is not meant to be fast or secure
-//
-// usage: 1) feed it blocks of uchars with update()
-//      2) finalize()
-//      3) get hexdigest() string
-//      or
-//      MD5(std::string).hexdigest()
-//
-// assumes that char is 8 bit and int is 32 bit
-class MD5
-{
-public:
-  typedef unsigned int size_type; // must be 32bit
- 
-  MD5();
-  MD5(const std::string& text);
-  void update(const unsigned char *buf, size_type length);
-  void update(const char *buf, size_type length);
-  MD5& finalize();
-  std::string hexdigest() const;
-  friend std::ostream& operator<<(std::ostream&, MD5 md5);
- 
-private:
-  void init();
-  typedef unsigned char uint1; //  8bit
-  typedef unsigned int uint4;  // 32bit
-  enum {blocksize = 64}; // VC6 won't eat a const static int here
- 
-  void transform(const uint1 block[blocksize]);
-  static void decode(uint4 output[], const uint1 input[], size_type len);
-  static void encode(uint1 output[], const uint4 input[], size_type len);
- 
-  bool finalized;
-  uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
-  uint4 count[2];   // 64bit counter for number of bits (lo, hi)
-  uint4 state[4];   // digest so far
-  uint1 digest[16]; // the result
- 
-  // low level logic operations
-  static inline uint4 F(uint4 x, uint4 y, uint4 z);
-  static inline uint4 G(uint4 x, uint4 y, uint4 z);
-  static inline uint4 H(uint4 x, uint4 y, uint4 z);
-  static inline uint4 I(uint4 x, uint4 y, uint4 z);
-  static inline uint4 rotate_left(uint4 x, int n);
-  static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-};
- 
-std::string md5(const std::string str);
- 
-#endif
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/parser.cpp b/vendor/github.com/strickyak/jsonnet_cgo/parser.cpp
deleted file mode 100644
index b0d1ac9a8597c127370d09d6ba74cdf17b3fb64a..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/parser.cpp
+++ /dev/null
@@ -1,996 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <cstdlib>
-#include <cassert>
-#include <cmath>
-
-#include <list>
-#include <set>
-#include <sstream>
-#include <string>
-#include <iomanip>
-
-
-#include "ast.h"
-#include "desugarer.h"
-#include "lexer.h"
-#include "parser.h"
-#include "static_error.h"
-
-
-std::string jsonnet_unparse_number(double v)
-{
-    std::stringstream ss;
-    if (v == floor(v)) {
-        ss << std::fixed << std::setprecision(0) << v;
-    } else {
-        // See "What Every Computer Scientist Should Know About Floating-Point Arithmetic"
-        // Theorem 15
-        // http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
-        ss << std::setprecision(17);
-        ss << v;
-    }
-    return ss.str();
-}
-
-
-namespace {
-
-static bool op_is_unary(const std::string &op, UnaryOp &uop)
-{
-    auto it = unary_map.find(op);
-    if (it == unary_map.end()) return false;
-    uop = it->second;
-    return true;
-}
-
-static bool op_is_binary(const std::string &op, BinaryOp &bop)
-{
-    auto it = binary_map.find(op);
-    if (it == binary_map.end()) return false;
-    bop = it->second;
-    return true;
-}
-
-LocationRange span(const Token &begin)
-{
-    return LocationRange(begin.location.file, begin.location.begin, begin.location.end);
-}
-
-LocationRange span(const Token &begin, const Token &end)
-{
-    return LocationRange(begin.location.file, begin.location.begin, end.location.end);
-}
-
-LocationRange span(const Token &begin, AST *end)
-{
-    return LocationRange(begin.location.file, begin.location.begin, end->location.end);
-}
-
-/** Holds state while parsing a given token list.
- */
-class Parser {
-
-    // The private member functions are utilities for dealing with the token stream.
-
-    StaticError unexpected(const Token &tok, const std::string &while_)
-    {
-        std::stringstream ss;
-        ss << "Unexpected: " << tok.kind << " while " << while_;
-        return StaticError(tok.location, ss.str());
-    }
-
-    Token pop(void)
-    {
-        Token tok = peek();
-        tokens.pop_front();
-        return tok;
-    }
-
-    void push(Token tok) {
-        tokens.push_front(tok);
-    }
-
-    Token peek(void)
-    {
-        Token tok = tokens.front();
-        return tok;
-    }
-
-    /** Only call this is peek() is not an EOF token. */
-    Token doublePeek(void)
-    {
-        Tokens::iterator it = tokens.begin();  // First one.
-        it++; // Now pointing at the second one.
-        return *(it);
-    }
-
-    Token popExpect(Token::Kind k, const char *data=nullptr)
-    {
-        Token tok = pop();
-        if (tok.kind != k) {
-            std::stringstream ss;
-            ss << "Expected token " << k << " but got " << tok;
-            throw StaticError(tok.location, ss.str());
-        }
-        if (data != nullptr && tok.data != data) {
-            std::stringstream ss;
-            ss << "Expected operator " << data << " but got " << tok.data;
-            throw StaticError(tok.location, ss.str());
-        }
-        return tok;
-    }
-
-    std::list<Token> &tokens;
-    Allocator *alloc;
-
-    public:
-
-    Parser(Tokens &tokens, Allocator *alloc)
-      : tokens(tokens), alloc(alloc)
-    { }
-
-    /** Parse a comma-separated list of expressions.
-     *
-     * Allows an optional ending comma.
-     * \param exprs Expressions added here.
-     * \param end The token that ends the list (e.g. ] or )).
-     * \param element_kind Used in error messages when a comma was not found.
-     * \returns The last token (the one that matched parameter end).
-     */
-    Token parseArgs(ArgParams &args, Token::Kind end,
-                    const std::string &element_kind, bool &got_comma)
-    {
-        got_comma = false;
-        bool first = true;
-        do {
-            Token next = peek();
-            if (next.kind == end) {
-                // got_comma can be true or false here.
-                return pop();
-            }
-            if (!first && !got_comma) {
-                std::stringstream ss;
-                ss << "Expected a comma before next " << element_kind <<  ".";
-                throw StaticError(next.location, ss.str());
-            }
-            // Either id=expr or id or expr, but note that expr could be id==1 so this needs
-            // look-ahead.
-            Fodder id_fodder;
-            const Identifier *id = nullptr;
-            Fodder eq_fodder;
-            if (peek().kind == Token::IDENTIFIER) {
-                Token maybe_eq = doublePeek();
-                if (maybe_eq.kind == Token::OPERATOR && maybe_eq.data == "=") {
-                    id_fodder = peek().fodder;
-                    id = alloc->makeIdentifier(peek().data32());
-                    eq_fodder = maybe_eq.fodder;
-                    pop();  // id
-                    pop();  // eq
-                }
-            }
-            AST *expr = parse(MAX_PRECEDENCE);
-            got_comma = false;
-            first = false;
-            Fodder comma_fodder;
-            if (peek().kind == Token::COMMA) {
-                Token comma = pop();
-                comma_fodder = comma.fodder;
-                got_comma = true;
-            }
-            args.emplace_back(id_fodder, id, eq_fodder, expr, comma_fodder);
-        } while (true);
-    }
-
-    ArgParams parseParams(const std::string &element_kind, bool &got_comma, Fodder &close_fodder)
-    {
-        ArgParams params;
-        Token paren_r = parseArgs(params, Token::PAREN_R, element_kind, got_comma);
-
-        // Check they're all identifiers
-        // parseArgs returns f(x) with x as an expression.  Convert it here.
-        for (auto &p : params) {
-            if (p.id == nullptr) {
-                auto *pv = dynamic_cast<Var*>(p.expr);
-                if (pv == nullptr) {
-                    throw StaticError(p.expr->location,
-                                      "Could not parse parameter here.");
-
-                }
-                p.id = pv->id;
-                p.idFodder = pv->openFodder;
-                p.expr = nullptr;
-            }
-        }
-
-        close_fodder = paren_r.fodder;
-
-        return params;
-    }
-
-    Token parseBind(Local::Binds &binds)
-    {
-        Token var_id = popExpect(Token::IDENTIFIER);
-        auto *id = alloc->makeIdentifier(var_id.data32());
-        for (const auto &bind : binds) {
-            if (bind.var == id)
-                throw StaticError(var_id.location, "Duplicate local var: " + var_id.data);
-        }
-        bool is_function = false;
-        ArgParams params;
-        bool trailing_comma = false;
-        Fodder fodder_l, fodder_r;
-        if (peek().kind == Token::PAREN_L) {
-            Token paren_l = pop();
-            fodder_l = paren_l.fodder;
-            params = parseParams("function parameter", trailing_comma, fodder_r);
-            is_function = true;
-        }
-        Token eq = popExpect(Token::OPERATOR, "=");
-        AST *body = parse(MAX_PRECEDENCE);
-        Token delim = pop();
-        binds.emplace_back(var_id.fodder, id, eq.fodder, body, is_function, fodder_l, params,
-                           trailing_comma, fodder_r, delim.fodder);
-        return delim;
-    }
-
-
-    Token parseObjectRemainder(AST *&obj, const Token &tok)
-    {
-        ObjectFields fields;
-        std::set<std::string> literal_fields;  // For duplicate fields detection.
-        std::set<const Identifier *> binds;  // For duplicate locals detection.
-
-        bool got_comma = false;
-        bool first = true;
-        Token next = pop();
-
-        do {
-
-            if (next.kind == Token::BRACE_R) {
-                obj = alloc->make<Object>(
-                    span(tok, next), tok.fodder, fields, got_comma, next.fodder);
-                return next;
-
-            } else if (next.kind == Token::FOR) {
-                // It's a comprehension
-                unsigned num_fields = 0;
-                unsigned num_asserts = 0;
-                const ObjectField *field_ptr = nullptr;
-                for (const auto &field : fields) {
-                    if (field.kind == ObjectField::LOCAL) continue;
-                    if (field.kind == ObjectField::ASSERT) {
-                        num_asserts++;
-                        continue;
-                    }
-                    field_ptr = &field;
-                    num_fields++;
-                }
-                if (num_asserts > 0) {
-                    auto msg = "Object comprehension cannot have asserts.";
-                    throw StaticError(next.location, msg);
-                }
-                if (num_fields != 1) {
-                    auto msg = "Object comprehension can only have one field.";
-                    throw StaticError(next.location, msg);
-                }
-                const ObjectField &field = *field_ptr;
-
-                if (field.hide != ObjectField::INHERIT) {
-                    auto msg = "Object comprehensions cannot have hidden fields.";
-                    throw StaticError(next.location, msg);
-                }
-
-                if (field.kind != ObjectField::FIELD_EXPR) {
-                    auto msg = "Object comprehensions can only have [e] fields.";
-                    throw StaticError(next.location, msg);
-                }
-
-                std::vector<ComprehensionSpec> specs;
-                Token last = parseComprehensionSpecs(Token::BRACE_R, next.fodder, specs);
-                obj = alloc->make<ObjectComprehension>(
-                    span(tok, last), tok.fodder, fields, got_comma, specs, last.fodder);
-
-                return last;
-            }
-
-            if (!got_comma && !first)
-                throw StaticError(next.location, "Expected a comma before next field.");
-
-            first = false;
-            got_comma = false;
-
-            switch (next.kind) {
-                case Token::BRACKET_L: case Token::IDENTIFIER: case Token::STRING_DOUBLE:
-                case Token::STRING_SINGLE: case Token::STRING_BLOCK: {
-                    ObjectField::Kind kind;
-                    AST *expr1 = nullptr;
-                    const Identifier *id = nullptr;
-                    Fodder fodder1, fodder2;
-                    if (next.kind == Token::IDENTIFIER) {
-                        fodder1 = next.fodder;
-                        kind = ObjectField::FIELD_ID;
-                        id = alloc->makeIdentifier(next.data32());
-                    } else if (next.kind == Token::STRING_DOUBLE) {
-                        kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::DOUBLE,
-                            "", "");
-                    } else if (next.kind == Token::STRING_SINGLE) {
-                        kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::SINGLE,
-                            "", "");
-                    } else if (next.kind == Token::STRING_BLOCK) {
-                        kind = ObjectField::FIELD_STR;
-                        expr1 = alloc->make<LiteralString>(
-                            next.location, next.fodder, next.data32(), LiteralString::BLOCK,
-                            next.stringBlockIndent, next.stringBlockTermIndent);
-                    } else {
-                        kind = ObjectField::FIELD_EXPR;
-                        fodder1 = next.fodder;
-                        expr1 = parse(MAX_PRECEDENCE);
-                        Token bracket_r = popExpect(Token::BRACKET_R);
-                        fodder2 = bracket_r.fodder;
-                    }
-
-                    bool is_method = false;
-                    bool meth_comma = false;
-                    ArgParams params;
-                    Fodder fodder_l;
-                    Fodder fodder_r;
-                    if (peek().kind == Token::PAREN_L) {
-                        Token paren_l = pop();
-                        fodder_l = paren_l.fodder;
-                        params = parseParams("method parameter", meth_comma, fodder_r);
-                        is_method = true;
-                    }
-
-                    bool plus_sugar = false;
-
-                    Token op = popExpect(Token::OPERATOR);
-                    const char *od = op.data.c_str();
-                    if (*od == '+') {
-                        plus_sugar = true;
-                        od++;
-                    }
-                    unsigned colons = 0;
-                    for (; *od != '\0' ; ++od) {
-                        if (*od != ':') {
-                            throw StaticError(
-                                next.location,
-                                "Expected one of :, ::, :::, +:, +::, +:::, got: " + op.data);
-                        }
-                        ++colons;
-                    }
-                    ObjectField::Hide field_hide;
-                    switch (colons) {
-                        case 1:
-                        field_hide = ObjectField::INHERIT;
-                        break;
-
-                        case 2:
-                        field_hide = ObjectField::HIDDEN;
-                        break;
-
-                        case 3:
-                        field_hide = ObjectField::VISIBLE;
-                        break;
-
-                        default:
-                            throw StaticError(
-                                next.location,
-                                "Expected one of :, ::, :::, +:, +::, +:::, got: " + op.data);
-                    }
-
-                    // Basic checks for invalid Jsonnet code.
-                    if (is_method && plus_sugar) {
-                        throw StaticError(
-                            next.location, "Cannot use +: syntax sugar in a method: " + next.data);
-                    }
-                    if (kind != ObjectField::FIELD_EXPR) {
-                        if (!literal_fields.insert(next.data).second) {
-                            throw StaticError(next.location, "Duplicate field: "+next.data);
-                        }
-                    }
-
-                    AST *body = parse(MAX_PRECEDENCE);
-
-                    Fodder comma_fodder;
-                    next = pop();
-                    if (next.kind == Token::COMMA) {
-                        comma_fodder = next.fodder;
-                        next = pop();
-                        got_comma = true;
-                    }
-                    fields.emplace_back(
-                        kind, fodder1, fodder2, fodder_l, fodder_r, field_hide, plus_sugar,
-                        is_method, expr1, id, params, meth_comma, op.fodder, body, nullptr,
-                        comma_fodder);
-                }
-                break;
-
-                case Token::LOCAL: {
-                    Fodder local_fodder = next.fodder;
-                    Token var_id = popExpect(Token::IDENTIFIER);
-                    auto *id = alloc->makeIdentifier(var_id.data32());
-
-                    if (binds.find(id) != binds.end()) {
-                        throw StaticError(var_id.location, "Duplicate local var: " + var_id.data);
-                    }
-                    bool is_method = false;
-                    bool func_comma = false;
-                    ArgParams params;
-                    Fodder paren_l_fodder;
-                    Fodder paren_r_fodder;
-                    if (peek().kind == Token::PAREN_L) {
-                        Token paren_l = pop();
-                        paren_l_fodder = paren_l.fodder;
-                        is_method = true;
-                        params = parseParams("function parameter", func_comma, paren_r_fodder);
-                    }
-                    Token eq = popExpect(Token::OPERATOR, "=");
-                    AST *body = parse(MAX_PRECEDENCE);
-                    binds.insert(id);
-
-                    Fodder comma_fodder;
-                    next = pop();
-                    if (next.kind == Token::COMMA) {
-                        comma_fodder = next.fodder;
-                        next = pop();
-                        got_comma = true;
-                    }
-                    fields.push_back(
-                        ObjectField::Local(
-                            local_fodder, var_id.fodder, paren_l_fodder, paren_r_fodder,
-                            is_method, id, params, func_comma, eq.fodder, body, comma_fodder));
-
-                }
-                break;
-
-                case Token::ASSERT: {
-                    Fodder assert_fodder = next.fodder;
-                    AST *cond = parse(MAX_PRECEDENCE);
-                    AST *msg = nullptr;
-                    Fodder colon_fodder;
-                    if (peek().kind == Token::OPERATOR && peek().data == ":") {
-                        Token colon = pop();
-                        colon_fodder = colon.fodder;
-                        msg = parse(MAX_PRECEDENCE);
-                    }
-
-                    Fodder comma_fodder;
-                    next = pop();
-                    if (next.kind == Token::COMMA) {
-                        comma_fodder = next.fodder;
-                        next = pop();
-                        got_comma = true;
-                    }
-                    fields.push_back(ObjectField::Assert(assert_fodder, cond, colon_fodder, msg,
-                                     comma_fodder));
-                }
-                break;
-
-                default:
-                throw unexpected(next, "parsing field definition");
-            }
-
-
-        } while (true);
-    }
-
-    /** parses for x in expr for y in expr if expr for z in expr ... */
-    Token parseComprehensionSpecs(Token::Kind end, Fodder for_fodder,
-                                  std::vector<ComprehensionSpec> &specs)
-    {
-        while (true) {
-            LocationRange l;
-            Token id_token = popExpect(Token::IDENTIFIER);
-            const Identifier *id = alloc->makeIdentifier(id_token.data32());
-            Token in_token = popExpect(Token::IN);
-            AST *arr = parse(MAX_PRECEDENCE);
-            specs.emplace_back(ComprehensionSpec::FOR, for_fodder, id_token.fodder, id,
-                               in_token.fodder, arr);
-
-            Token maybe_if = pop();
-            for (; maybe_if.kind == Token::IF; maybe_if = pop()) {
-                AST *cond = parse(MAX_PRECEDENCE);
-                specs.emplace_back(ComprehensionSpec::IF, maybe_if.fodder, Fodder{}, nullptr,
-                                   Fodder{}, cond);
-            }
-            if (maybe_if.kind == end) {
-                return maybe_if;
-            }
-            if (maybe_if.kind != Token::FOR) {
-                std::stringstream ss;
-                ss << "Expected for, if or " << end << " after for clause, got: " << maybe_if;
-                throw StaticError(maybe_if.location, ss.str());
-            }
-            for_fodder = maybe_if.fodder;
-        }
-    }
-
-    AST *parseTerminal(void)
-    {
-        Token tok = pop();
-        switch (tok.kind) {
-            case Token::ASSERT:
-            case Token::BRACE_R:
-            case Token::BRACKET_R:
-            case Token::COMMA:
-            case Token::DOT:
-            case Token::ELSE:
-            case Token::ERROR:
-            case Token::FOR:
-            case Token::FUNCTION:
-            case Token::IF:
-            case Token::IN:
-            case Token::IMPORT:
-            case Token::IMPORTSTR:
-            case Token::LOCAL:
-            case Token::OPERATOR:
-            case Token::PAREN_R:
-            case Token::SEMICOLON:
-            case Token::TAILSTRICT:
-            case Token::THEN:
-            throw unexpected(tok, "parsing terminal");
-
-            case Token::END_OF_FILE:
-            throw StaticError(tok.location, "Unexpected end of file.");
-
-            case Token::BRACE_L: {
-                AST *obj;
-                parseObjectRemainder(obj, tok);
-                return obj;
-            }
-
-            case Token::BRACKET_L: {
-                Token next = peek();
-                if (next.kind == Token::BRACKET_R) {
-                    Token bracket_r = pop();
-                    return alloc->make<Array>(span(tok, next), tok.fodder, Array::Elements{},
-                                              false, bracket_r.fodder);
-                }
-                AST *first = parse(MAX_PRECEDENCE);
-                bool got_comma = false;
-                Fodder comma_fodder;
-                next = peek();
-                if (!got_comma && next.kind == Token::COMMA) {
-                    Token comma = pop();
-                    comma_fodder = comma.fodder;
-                    next = peek();
-                    got_comma = true;
-                }
-
-                if (next.kind == Token::FOR) {
-                    // It's a comprehension
-                    Token for_token = pop();
-                    std::vector<ComprehensionSpec> specs;
-                    Token last = parseComprehensionSpecs(Token::BRACKET_R, for_token.fodder, specs);
-                    return alloc->make<ArrayComprehension>(
-                        span(tok, last), tok.fodder, first, comma_fodder, got_comma, specs,
-                        last.fodder);
-                }
-
-                // Not a comprehension: It can have more elements.
-                Array::Elements elements;
-                elements.emplace_back(first, comma_fodder);
-                do {
-                    if (next.kind == Token::BRACKET_R) {
-                        Token bracket_r = pop();
-                        return alloc->make<Array>(
-                            span(tok, next), tok.fodder, elements, got_comma, bracket_r.fodder);
-                    }
-                    if (!got_comma) {
-                        std::stringstream ss;
-                        ss << "Expected a comma before next array element.";
-                        throw StaticError(next.location, ss.str());
-                    }
-                    AST *expr = parse(MAX_PRECEDENCE);
-                    comma_fodder.clear();
-                    got_comma = false;
-                    next = peek();
-                    if (next.kind == Token::COMMA) {
-                        Token comma = pop();
-                        comma_fodder = comma.fodder;
-                        next = peek();
-                        got_comma = true;
-                    }
-                    elements.emplace_back(expr, comma_fodder);
-                } while (true);
-            }
-
-            case Token::PAREN_L: {
-                auto *inner = parse(MAX_PRECEDENCE);
-                Token close = popExpect(Token::PAREN_R);
-                return alloc->make<Parens>(span(tok, close), tok.fodder, inner, close.fodder);
-            }
-
-            // Literals
-            case Token::NUMBER:
-            return alloc->make<LiteralNumber>(span(tok), tok.fodder, tok.data);
-
-            case Token::STRING_SINGLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::SINGLE, "", "");
-            case Token::STRING_DOUBLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::DOUBLE, "", "");
-            case Token::STRING_BLOCK:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::BLOCK,
-                tok.stringBlockIndent, tok.stringBlockTermIndent);
-            case Token::VERBATIM_STRING_SINGLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::VERBATIM_SINGLE, "", "");
-            case Token::VERBATIM_STRING_DOUBLE:
-            return alloc->make<LiteralString>(
-                span(tok), tok.fodder, tok.data32(), LiteralString::VERBATIM_DOUBLE, "", "");
-
-
-            case Token::FALSE:
-            return alloc->make<LiteralBoolean>(span(tok), tok.fodder, false);
-
-            case Token::TRUE:
-            return alloc->make<LiteralBoolean>(span(tok), tok.fodder, true);
-
-            case Token::NULL_LIT:
-            return alloc->make<LiteralNull>(span(tok), tok.fodder);
-
-            // Variables
-            case Token::DOLLAR:
-            return alloc->make<Dollar>(span(tok), tok.fodder);
-
-            case Token::IDENTIFIER:
-            return alloc->make<Var>(span(tok), tok.fodder, alloc->makeIdentifier(tok.data32()));
-
-            case Token::SELF:
-            return alloc->make<Self>(span(tok), tok.fodder);
-
-            case Token::SUPER: {
-                Token next = pop();
-                AST *index = nullptr;
-                const Identifier *id = nullptr;
-                Fodder id_fodder;
-                switch (next.kind) {
-                    case Token::DOT: {
-                        Token field_id = popExpect(Token::IDENTIFIER);
-                        id_fodder = field_id.fodder;
-                        id = alloc->makeIdentifier(field_id.data32());
-                    } break;
-                    case Token::BRACKET_L: {
-                        index = parse(MAX_PRECEDENCE);
-                        Token bracket_r = popExpect(Token::BRACKET_R);
-                        id_fodder = bracket_r.fodder;  // Not id_fodder, but use the same var.
-                    } break;
-                    default:
-                    throw StaticError(tok.location, "Expected . or [ after super.");
-                }
-                return alloc->make<SuperIndex>(span(tok), tok.fodder, next.fodder, index,
-                                               id_fodder, id);
-            }
-        }
-
-        std::cerr << "INTERNAL ERROR: Unknown tok kind: " << tok.kind << std::endl;
-        std::abort();
-        return nullptr;  // Quiet, compiler.
-    }
-
-    AST *parse(int precedence)
-    {
-        Token begin = peek();
-
-        switch (begin.kind) {
-
-            // These cases have effectively MAX_PRECEDENCE as the first
-            // call to parse will parse them.
-            case Token::ASSERT: {
-                pop();
-                AST *cond = parse(MAX_PRECEDENCE);
-                Fodder colonFodder;
-                AST *msg = nullptr;
-                if (peek().kind == Token::OPERATOR && peek().data == ":") {
-                    Token colon = pop();
-                    colonFodder = colon.fodder;
-                    msg = parse(MAX_PRECEDENCE);
-                }
-                Token semicolon = popExpect(Token::SEMICOLON);
-                AST *rest = parse(MAX_PRECEDENCE);
-                return alloc->make<Assert>(span(begin, rest), begin.fodder, cond, colonFodder,
-                                           msg, semicolon.fodder, rest);
-            }
-
-            case Token::ERROR: {
-                pop();
-                AST *expr = parse(MAX_PRECEDENCE);
-                return alloc->make<Error>(span(begin, expr), begin.fodder, expr);
-            }
-
-            case Token::IF: {
-                pop();
-                AST *cond = parse(MAX_PRECEDENCE);
-                Token then = popExpect(Token::THEN);
-                AST *branch_true = parse(MAX_PRECEDENCE);
-                if (peek().kind == Token::ELSE) {
-                    Token else_ = pop();
-                    AST *branch_false = parse(MAX_PRECEDENCE);
-                    return alloc->make<Conditional>(
-                        span(begin, branch_false), begin.fodder, cond, then.fodder, branch_true,
-                        else_.fodder, branch_false);
-                }
-                return alloc->make<Conditional>(span(begin, branch_true), begin.fodder, cond,
-                                                then.fodder, branch_true, Fodder{}, nullptr);
-            }
-
-            case Token::FUNCTION: {
-                pop();  // Still available in 'begin'.
-                Token paren_l = pop();
-                if (paren_l.kind == Token::PAREN_L) {
-                    std::vector<AST*> params_asts;
-                    bool got_comma;
-                    Fodder paren_r_fodder;
-                    ArgParams params = parseParams(
-                        "function parameter", got_comma, paren_r_fodder);
-                    AST *body = parse(MAX_PRECEDENCE);
-                    return alloc->make<Function>(
-                        span(begin, body), begin.fodder, paren_l.fodder, params, got_comma,
-                        paren_r_fodder, body);
-                } else {
-                    std::stringstream ss;
-                    ss << "Expected ( but got " << paren_l;
-                    throw StaticError(paren_l.location, ss.str());
-                }
-            }
-
-            case Token::IMPORT: {
-                pop();
-                AST *body = parse(MAX_PRECEDENCE);
-                if (auto *lit = dynamic_cast<LiteralString*>(body)) {
-                    if (lit->tokenKind == LiteralString::BLOCK) {
-                        throw StaticError(lit->location,
-                                          "Cannot use text blocks in import statements.");
-                    }
-                    return alloc->make<Import>(span(begin, body), begin.fodder, lit);
-                } else {
-                    std::stringstream ss;
-                    ss << "Computed imports are not allowed.";
-                    throw StaticError(body->location, ss.str());
-                }
-            }
-
-            case Token::IMPORTSTR: {
-                pop();
-                AST *body = parse(MAX_PRECEDENCE);
-                if (auto *lit = dynamic_cast<LiteralString*>(body)) {
-                    if (lit->tokenKind == LiteralString::BLOCK) {
-                        throw StaticError(lit->location,
-                                          "Cannot use text blocks in import statements.");
-                    }
-                    return alloc->make<Importstr>(span(begin, body), begin.fodder, lit);
-                } else {
-                    std::stringstream ss;
-                    ss << "Computed imports are not allowed.";
-                    throw StaticError(body->location, ss.str());
-                }
-            }
-
-            case Token::LOCAL: {
-                pop();
-                Local::Binds binds;
-                do {
-                    Token delim = parseBind(binds);
-                    if (delim.kind != Token::SEMICOLON && delim.kind != Token::COMMA) {
-                        std::stringstream ss;
-                        ss << "Expected , or ; but got " << delim;
-                        throw StaticError(delim.location, ss.str());
-                    }
-                    if (delim.kind == Token::SEMICOLON) break;
-                } while (true);
-                AST *body = parse(MAX_PRECEDENCE);
-                return alloc->make<Local>(span(begin, body), begin.fodder, binds, body);
-            }
-
-            default:
-
-            // Unary operator.
-            if (begin.kind == Token::OPERATOR) {
-                UnaryOp uop;
-                if (!op_is_unary(begin.data, uop)) {
-                    std::stringstream ss;
-                    ss << "Not a unary operator: " << begin.data;
-                    throw StaticError(begin.location, ss.str());
-                }
-                if (UNARY_PRECEDENCE == precedence) {
-                    Token op = pop();
-                    AST *expr = parse(precedence);
-                    return alloc->make<Unary>(span(op, expr), op.fodder, uop, expr);
-                }
-            }
-
-            // Base case
-            if (precedence == 0) return parseTerminal();
-
-            AST *lhs = parse(precedence - 1);
-
-            Fodder begin_fodder;
-
-            while (true) {
-
-                // Then next token must be a binary operator.
-
-                // The compiler can't figure out that this is never used uninitialized.
-                BinaryOp bop = BOP_PLUS;
-
-                // Check precedence is correct for this level.  If we're
-                // parsing operators with higher precedence, then return
-                // lhs and let lower levels deal with the operator.
-                switch (peek().kind) {
-                    // Logical / arithmetic binary operator.
-                    case Token::IN:
-                    case Token::OPERATOR:
-                    if (peek().data == ":") {
-                        // Special case for the colons in assert.
-                        // Since COLON is no-longer a special token, we have to make sure it
-                        // does not trip the op_is_binary test below.  It should
-                        // terminate parsing of the expression here, returning control
-                        // to the parsing of the actual assert AST.
-                        return lhs;
-                    }
-                    if (peek().data == "::") {
-                        // Special case for [e::]
-                        // We need to stop parsing e when we see the :: and
-                        // avoid tripping the op_is_binary test below.
-                        return lhs;
-                    }
-                    if (!op_is_binary(peek().data, bop)) {
-                        std::stringstream ss;
-                        ss << "Not a binary operator: " << peek().data;
-                        throw StaticError(peek().location, ss.str());
-                    }
-                    if (precedence_map[bop] != precedence) return lhs;
-                    break;
-
-                    // Index, Apply
-                    case Token::DOT: case Token::BRACKET_L:
-                    case Token::PAREN_L: case Token::BRACE_L:
-                    if (APPLY_PRECEDENCE != precedence) return lhs;
-                    break;
-
-                    default:
-                    return lhs;
-                }
-
-                Token op = pop();
-                if (op.kind == Token::BRACKET_L) {
-                    bool is_slice;
-                    AST *first = nullptr;
-                    Fodder second_fodder;
-                    AST *second = nullptr;
-                    Fodder third_fodder;
-                    AST *third = nullptr;
-
-                    if (peek().kind == Token::BRACKET_R)
-                        throw unexpected(pop(), "parsing index");
-
-                    if (peek().data != ":" && peek().data != "::") {
-                        first = parse(MAX_PRECEDENCE);
-                    }
-
-                    if (peek().kind == Token::OPERATOR && peek().data == "::") {
-                        // Handle ::
-                        is_slice = true;
-                        Token joined = pop();
-                        second_fodder = joined.fodder;
-
-                        if (peek().kind != Token::BRACKET_R)
-                            third = parse(MAX_PRECEDENCE);
-
-                    } else if (peek().kind != Token::BRACKET_R) {
-                        is_slice = true;
-                        Token delim = pop();
-                        if (delim.data != ":")
-                            throw unexpected(delim, "parsing slice");
-
-                        second_fodder = delim.fodder;
-
-                        if (peek().data != ":" && peek().kind != Token::BRACKET_R)
-                            second = parse(MAX_PRECEDENCE);
-
-                        if (peek().kind != Token::BRACKET_R) {
-                            Token delim = pop();
-                            if (delim.data != ":")
-                                throw unexpected(delim, "parsing slice");
-
-                            third_fodder = delim.fodder;
-
-                            if (peek().kind != Token::BRACKET_R)
-                                third = parse(MAX_PRECEDENCE);
-                        }
-                    } else {
-                        is_slice = false;
-                    }
-                    Token end = popExpect(Token::BRACKET_R);
-                    lhs = alloc->make<Index>(span(begin, end), begin_fodder, lhs, op.fodder,
-                                             is_slice, first, second_fodder, second,
-                                             third_fodder, third, end.fodder);
-
-                } else if (op.kind == Token::DOT) {
-                    Token field_id = popExpect(Token::IDENTIFIER);
-                    const Identifier *id = alloc->makeIdentifier(field_id.data32());
-                    lhs = alloc->make<Index>(span(begin, field_id), begin_fodder, lhs,
-                                             op.fodder, field_id.fodder, id);
-
-                } else if (op.kind == Token::PAREN_L) {
-                    ArgParams args;
-                    bool got_comma;
-                    Token end = parseArgs(args, Token::PAREN_R, "function argument", got_comma);
-                    bool tailstrict = false;
-                    Fodder tailstrict_fodder;
-                    if (peek().kind == Token::TAILSTRICT) {
-                        Token tailstrict_token = pop();
-                        tailstrict_fodder = tailstrict_token.fodder;
-                        tailstrict = true;
-                    }
-                    lhs = alloc->make<Apply>(span(begin, end), begin_fodder, lhs, op.fodder,
-                                             args, got_comma, end.fodder, tailstrict_fodder,
-                                             tailstrict);
-
-                } else if (op.kind == Token::BRACE_L) {
-                    AST *obj;
-                    Token end = parseObjectRemainder(obj, op);
-                    lhs = alloc->make<ApplyBrace>(span(begin, end), begin_fodder, lhs, obj);
-
-                } else if (op.kind == Token::IN) {
-                    if (peek().kind == Token::SUPER) {
-                        Token super = pop();
-                        lhs = alloc->make<InSuper>(
-                            span(begin, super), begin_fodder, lhs, op.fodder, super.fodder);
-                    } else {
-                        AST *rhs = parse(precedence - 1);
-                        lhs = alloc->make<Binary>(
-                            span(begin, rhs), begin_fodder, lhs, op.fodder, bop, rhs);
-                    }
-
-                } else {
-                    // Logical / arithmetic binary operator.
-                    assert(op.kind == Token::OPERATOR);
-                    AST *rhs = parse(precedence - 1);
-                    lhs = alloc->make<Binary>(span(begin, rhs), begin_fodder, lhs, op.fodder,
-                                              bop, rhs);
-                }
-
-                begin_fodder.clear();
-            }
-        }
-    }
-
-};
-
-}  // namespace
-
-AST *jsonnet_parse(Allocator *alloc, Tokens &tokens)
-{
-    Parser parser(tokens, alloc);
-    AST *expr = parser.parse(MAX_PRECEDENCE);
-    if (tokens.front().kind != Token::END_OF_FILE) {
-        std::stringstream ss;
-        ss << "Did not expect: " << tokens.front();
-        throw StaticError(tokens.front().location, ss.str());
-    }
-
-    return expr;
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/parser.h b/vendor/github.com/strickyak/jsonnet_cgo/parser.h
deleted file mode 100644
index ab4d173dfe8ac59c05cfe16b792d55ee667770d7..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/parser.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_PARSER_H
-#define JSONNET_PARSER_H
-
-#include <string>
-
-#include "ast.h"
-#include "lexer.h"
-#include "unicode.h"
-
-/** Parse a given JSON++ string.
- *
- * \param alloc Used to allocate the AST nodes.  The Allocator must outlive the
- * AST pointer returned.
- * \param tokens The list of tokens (all tokens are popped except EOF).
- * \returns The parsed abstract syntax tree.
- */
-AST *jsonnet_parse(Allocator *alloc, Tokens &tokens);
-
-/** Outputs a number, trying to preserve precision as well as possible.
- */
-std::string jsonnet_unparse_number(double v);
-
-/** The inverse of jsonnet_parse.
- */
-std::string jsonnet_unparse_jsonnet(const AST *ast, const Fodder &final_fodder, unsigned indent,
-                                    bool pad_arrays, bool pad_objects, char comment_style);
-
-#endif  // JSONNET_PARSER_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/pass.cpp b/vendor/github.com/strickyak/jsonnet_cgo/pass.cpp
deleted file mode 100644
index ce274a54cd1f8f8574fdfa6b037149e327a8a9e5..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/pass.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include "pass.h"
-
-void CompilerPass::fodder(Fodder &fodder)
-{
-    for (auto &f : fodder)
-        fodderElement(f);
-}
-
-void CompilerPass::specs(std::vector<ComprehensionSpec> &specs)
-{
-    for (auto &spec : specs) {
-        fodder(spec.openFodder);
-        switch (spec.kind) {
-            case ComprehensionSpec::FOR:
-            fodder(spec.varFodder);
-            fodder(spec.inFodder);
-            expr(spec.expr);
-            break;
-            case ComprehensionSpec::IF:
-            expr(spec.expr);
-            break;
-        }
-    }
-}
-
-void CompilerPass::params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r)
-{
-    fodder(fodder_l);
-    for (auto &param : params) {
-        fodder(param.idFodder);
-        if (param.expr) {
-            fodder(param.eqFodder);
-            expr(param.expr);
-        }
-        fodder(param.commaFodder);
-    }
-    fodder(fodder_r);
-}
-
-void CompilerPass::fieldParams(ObjectField &field)
-{
-    if (field.methodSugar) {
-        params(field.fodderL, field.params, field.fodderR);
-    }
-}
-
-void CompilerPass::fields(ObjectFields &fields)
-{
-    for (auto &field : fields) {
-
-        switch (field.kind) {
-            case ObjectField::LOCAL: {
-                fodder(field.fodder1);
-                fodder(field.fodder2);
-                fieldParams(field);
-                fodder(field.opFodder);
-                expr(field.expr2);
-            } break;
-
-            case ObjectField::FIELD_ID:
-            case ObjectField::FIELD_STR:
-            case ObjectField::FIELD_EXPR: {
-                if (field.kind == ObjectField::FIELD_ID) {
-                    fodder(field.fodder1);
-
-                } else if (field.kind == ObjectField::FIELD_STR) {
-                    expr(field.expr1);
-
-                } else if (field.kind == ObjectField::FIELD_EXPR) {
-                    fodder(field.fodder1);
-                    expr(field.expr1);
-                    fodder(field.fodder2);
-                }
-                fieldParams(field);
-                fodder(field.opFodder);
-                expr(field.expr2);
-
-            } break;
-
-            case ObjectField::ASSERT: {
-                fodder(field.fodder1);
-                expr(field.expr2);
-                if (field.expr3 != nullptr) {
-                    fodder(field.opFodder);
-                    expr(field.expr3);
-                }
-            } break;
-        }
-
-        fodder(field.commaFodder);
-    }
-}
-
-void CompilerPass::expr(AST *&ast_)
-{
-    fodder(ast_->openFodder);
-    visitExpr(ast_);
-}
-
-void CompilerPass::visit(Apply *ast)
-{
-    expr(ast->target);
-    fodder(ast->fodderL);
-    for (auto &arg : ast->args) {
-        expr(arg.expr);
-        fodder(arg.commaFodder);
-    }
-    fodder(ast->fodderR);
-    if (ast->tailstrict) {
-        fodder(ast->tailstrictFodder);
-    }
-}
-
-void CompilerPass::visit(ApplyBrace *ast)
-{
-    expr(ast->left);
-    expr(ast->right);
-}
-
-void CompilerPass::visit(Array *ast)
-{
-    for (auto &element : ast->elements) {
-        expr(element.expr);
-        fodder(element.commaFodder);
-    }
-    fodder(ast->closeFodder);
-}
-
-void CompilerPass::visit(ArrayComprehension *ast)
-{
-    expr(ast->body);
-    fodder(ast->commaFodder);
-    specs(ast->specs);
-    fodder(ast->closeFodder);
-}
-
-void CompilerPass::visit(Assert *ast)
-{
-    expr(ast->cond);
-    if (ast->message != nullptr) {
-        fodder(ast->colonFodder);
-        expr(ast->message);
-    }
-    fodder(ast->semicolonFodder);
-    expr(ast->rest);
-}
-
-void CompilerPass::visit(Binary *ast)
-{
-    expr(ast->left);
-    fodder(ast->opFodder);
-    expr(ast->right);
-}
-
-void CompilerPass::visit(Conditional *ast)
-{
-    expr(ast->cond);
-    fodder(ast->thenFodder);
-    if (ast->branchFalse != nullptr) {
-        expr(ast->branchTrue);
-        fodder(ast->elseFodder);
-        expr(ast->branchFalse);
-    } else {
-        expr(ast->branchTrue);
-    }
-}
-
-void CompilerPass::visit(Error *ast)
-{
-    expr(ast->expr);
-}
-
-void CompilerPass::visit(Function *ast)
-{
-    params(ast->parenLeftFodder, ast->params, ast->parenRightFodder);
-    expr(ast->body);
-}
-
-void CompilerPass::visit(Import *ast)
-{
-    visit(ast->file);
-}
-
-void CompilerPass::visit(Importstr *ast)
-{
-    visit(ast->file);
-}
-
-void CompilerPass::visit(InSuper *ast)
-{
-    expr(ast->element);
-}
-
-void CompilerPass::visit(Index *ast)
-{
-    expr(ast->target);
-    if (ast->id != nullptr) {
-    } else {
-        if (ast->isSlice) {
-            if (ast->index != nullptr)
-                expr(ast->index);
-            if (ast->end != nullptr)
-                expr(ast->end);
-            if (ast->step != nullptr)
-                expr(ast->step);
-        } else {
-            expr(ast->index);
-        }
-    }
-}
-
-void CompilerPass::visit(Local *ast)
-{
-    assert(ast->binds.size() > 0);
-    for (auto &bind : ast->binds) {
-        fodder(bind.varFodder);
-        if (bind.functionSugar) {
-            params(bind.parenLeftFodder, bind.params, bind.parenRightFodder);
-        } 
-        fodder(bind.opFodder);
-        expr(bind.body);
-        fodder(bind.closeFodder);
-    }
-    expr(ast->body);
-}
-
-void CompilerPass::visit(Object *ast)
-{
-    fields(ast->fields);
-    fodder(ast->closeFodder);
-}
-
-void CompilerPass::visit(DesugaredObject *ast)
-{
-    for (AST *assert : ast->asserts) {
-        expr(assert);
-    }
-    for (auto &field : ast->fields) {
-        expr(field.name);
-        expr(field.body);
-    }
-}
-
-void CompilerPass::visit(ObjectComprehension *ast)
-{
-    fields(ast->fields);
-    specs(ast->specs);
-    fodder(ast->closeFodder);
-}
-
-void CompilerPass::visit(ObjectComprehensionSimple *ast)
-{
-    expr(ast->field);
-    expr(ast->value);
-    expr(ast->array);
-}
-
-void CompilerPass::visit(Parens *ast)
-{
-    expr(ast->expr);
-    fodder(ast->closeFodder);
-}
-
-void CompilerPass::visit(SuperIndex *ast)
-{
-    if (ast->id != nullptr) {
-    } else {
-        expr(ast->index);
-    }
-}
-
-void CompilerPass::visit(Unary *ast)
-{
-    expr(ast->expr);
-}
-
-void CompilerPass::visitExpr(AST *&ast_)
-{
-    if (auto *ast = dynamic_cast<Apply*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Dollar*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Import*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Importstr*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<InSuper*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<LiteralBoolean*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<LiteralNumber*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<LiteralNull*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Self*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<SuperIndex*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
-        visit(ast);
-    } else if (auto *ast = dynamic_cast<Var*>(ast_)) {
-        visit(ast);
-
-    } else {
-        std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-        std::abort();
-
-    }
-}
-
-void CompilerPass::file(AST *&body, Fodder &final_fodder)
-{
-    expr(body);
-    fodder(final_fodder);
-}
-
-/** A pass that clones the AST it is given. */
-class ClonePass : public CompilerPass {
-    public:
-    ClonePass(Allocator &alloc) : CompilerPass(alloc) { }
-    virtual void expr(AST *&ast);
-};
-
-void ClonePass::expr(AST *&ast_)
-{
-    if (auto *ast = dynamic_cast<Apply*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<ApplyBrace*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Array*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<ArrayComprehension*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Assert*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Binary*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Dollar*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Error*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Function*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Import*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Importstr*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<InSuper*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Index*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Local*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<LiteralBoolean*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<LiteralNumber*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<LiteralString*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<LiteralNull*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Object*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<ObjectComprehension*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Parens*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Self*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<SuperIndex*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Unary*>(ast_)) {
-        ast_ = alloc.clone(ast);
-    } else if (auto *ast = dynamic_cast<Var*>(ast_)) {
-        ast_ = alloc.clone(ast);
-
-    } else {
-        std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-        std::abort();
-
-    }
-
-    CompilerPass::expr(ast_);
-}
-
-AST *clone_ast(Allocator &alloc, AST *ast)
-{
-    AST *r = ast;
-    ClonePass(alloc).expr(r);
-    return r;
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/pass.h b/vendor/github.com/strickyak/jsonnet_cgo/pass.h
deleted file mode 100644
index 10c3c9d85dbc7faa6a5b4e684072e6c949a5b891..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/pass.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_PASS_H
-#define JSONNET_PASS_H
-
-#include "ast.h"
-
-/** A generic Pass that does nothing but can be extended to easily define real passes.
- */
-class CompilerPass {
-    public:
-
-    protected:
-    Allocator &alloc;
-
-    public:
-    CompilerPass(Allocator &alloc) : alloc(alloc) { }
-
-    virtual void fodderElement(FodderElement &) { }
-
-    virtual void fodder(Fodder &fodder);
-
-    virtual void specs(std::vector<ComprehensionSpec> &specs);
-
-    virtual void params(Fodder &fodder_l, ArgParams &params, Fodder &fodder_r);
-
-    virtual void fieldParams(ObjectField &field);
-
-    virtual void fields(ObjectFields &fields);
-
-    virtual void expr(AST *&ast_);
-
-    virtual void visit(Apply *ast);
-
-    virtual void visit(ApplyBrace *ast);
-
-    virtual void visit(Array *ast);
-
-    virtual void visit(ArrayComprehension *ast);
-
-    virtual void visit(Assert *ast);
-
-    virtual void visit(Binary *ast);
-
-    virtual void visit(BuiltinFunction *) { }
-
-    virtual void visit(Conditional *ast);
-
-    virtual void visit(Dollar *) { }
-
-    virtual void visit(Error *ast);
-
-    virtual void visit(Function *ast);
-
-    virtual void visit(Import *ast);
-
-    virtual void visit(Importstr *ast);
-
-    virtual void visit(InSuper *ast);
-
-    virtual void visit(Index *ast);
-
-    virtual void visit(Local *ast);
-
-    virtual void visit(LiteralBoolean *) { }
-
-    virtual void visit(LiteralNumber *) { }
-
-    virtual void visit(LiteralString *) { }
-
-    virtual void visit(LiteralNull *) { }
-
-    virtual void visit(Object *ast);
-
-    virtual void visit(DesugaredObject *ast);
-
-    virtual void visit(ObjectComprehension *ast);
-
-    virtual void visit(ObjectComprehensionSimple *ast);
-    
-    virtual void visit(Parens *ast);
-
-    virtual void visit(Self *) { }
-
-    virtual void visit(SuperIndex *ast);
-
-    virtual void visit(Unary *ast);
-
-    virtual void visit(Var *) { }
-
-    virtual void visitExpr(AST *&ast_);
-
-    virtual void file(AST *&body, Fodder &final_fodder);
-};
-
-
-/** Return an equivalent AST that can be modified without affecting the original.
- *
- * This is a deep copy.
- */
-AST *clone_ast(Allocator &alloc, AST *ast);
-
-#endif
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/state.h b/vendor/github.com/strickyak/jsonnet_cgo/state.h
deleted file mode 100644
index b009806abb0e9ec715abc8d8bd96b412d9a5e64f..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/state.h
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_STATE_H
-#define JSONNET_STATE_H
-
-namespace {
-
-/** Mark & sweep: advanced by 1 each GC cycle.
- */
-typedef unsigned char GarbageCollectionMark;
-
-/** Supertype of everything that is allocated on the heap.
- */
-struct HeapEntity {
-    GarbageCollectionMark mark;
-    virtual ~HeapEntity() { }
-};
-
-/** Tagged union of all values.
- *
- * Primitives (<= 8 bytes) are copied by value.  Otherwise a pointer to a HeapEntity is used.
- */
-struct Value {
-    enum Type {
-        NULL_TYPE = 0x0,  // Unfortunately NULL is a macro in C.
-        BOOLEAN = 0x1,
-        DOUBLE = 0x2,
-
-        ARRAY = 0x10,
-        FUNCTION = 0x11,
-        OBJECT = 0x12,
-        STRING = 0x13
-    };
-    Type t;
-    union {
-        HeapEntity *h;
-        double d;
-        bool b;
-    } v;
-    bool isHeap(void) const
-    {
-        return t & 0x10;
-    }
-};
-
-/** Convert the type into a string, for error messages. */
-std::string type_str(Value::Type t)
-{
-    switch (t) {
-        case Value::NULL_TYPE: return "null";
-        case Value::BOOLEAN: return "boolean";
-        case Value::DOUBLE: return "double";
-        case Value::ARRAY: return "array";
-        case Value::FUNCTION: return "function";
-        case Value::OBJECT: return "object";
-        case Value::STRING: return "string";
-        default:
-        std::cerr << "INTERNAL ERROR: Unknown type: " << t << std::endl;
-        std::abort();
-        return "";  // Quiet, compiler.
-    }
-}
-
-/** Convert the value's type into a string, for error messages. */
-std::string type_str(const Value &v)
-{
-    return type_str(v.t);
-}
-
-struct HeapThunk;
-
-/** Stores the values bound to variables.
- *
- * Each nested local statement, function call, and field access has its own binding frame to
- * give the values for the local variable, function parameters, or upValues.
- */
-typedef std::map<const Identifier*, HeapThunk*> BindingFrame;
-
-/** Supertype of all objects.  Types of Value::OBJECT will point at these.  */
-struct HeapObject : public HeapEntity {
-};
-
-/** Hold an unevaluated expression.  This implements lazy semantics.
- */
-struct HeapThunk : public HeapEntity {
-    /** Whether or not the thunk was forced. */
-    bool filled;
-
-    /** The result when the thunk was forced, if filled == true. */
-    Value content;
-
-    /** Used in error tracebacks. */
-    const Identifier *name;
-
-    /** The captured environment.
-     *
-     * Note, this is non-const because we have to add cyclic references to it.
-     */
-    BindingFrame upValues;
-
-    /** The captured self variable, or nullptr if there was none.  \see CallFrame. */
-    HeapObject *self;
-
-    /** The offset from the captured self variable. \see CallFrame. */
-    unsigned offset;
-
-    /** Evaluated to force the thunk. */
-    const AST *body;
-
-    HeapThunk(const Identifier *name, HeapObject *self, unsigned offset, const AST *body)
-      : filled(false), name(name), self(self), offset(offset), body(body)
-    { }
-
-    void fill(const Value &v)
-    {
-        content = v;
-        filled = true;
-        self = nullptr;
-        upValues.clear();
-    }
-};
-
-struct HeapArray : public HeapEntity {
-    // It is convenient for this to not be const, so that we can add elements to it one at a
-    // time after creation.  Thus, elements are not GCed as the array is being
-    // created.
-    std::vector<HeapThunk*> elements;
-    HeapArray(const std::vector<HeapThunk*> &elements)
-      : elements(elements)
-    { }
-};
-
-/** Supertype of all objects that are not super objects or extended objects.  */
-struct HeapLeafObject : public HeapObject {
-};
-
-/** Objects created via the simple object constructor construct. */
-struct HeapSimpleObject : public HeapLeafObject {
-    /** The captured environment. */
-    const BindingFrame upValues;
-
-    struct Field {
-        /** Will the field appear in output? */
-        ObjectField::Hide hide;
-        /** Expression that is evaluated when indexing this field. */
-        AST *body;
-    };
-
-    /** The fields.
-     *
-     * These are evaluated in the captured environment and with self and super bound
-     * dynamically.
-     */
-    const std::map<const Identifier*, Field> fields;
-
-    /** The object's invariants.
-     *
-     * These are evaluated in the captured environment with self and super bound.
-     */
-    std::vector<AST*> asserts;
-
-    HeapSimpleObject(const BindingFrame &up_values,
-                     const std::map<const Identifier*, Field> fields, std::vector<AST*> asserts)
-      : upValues(up_values), fields(fields), asserts(asserts)
-    { }
-};
-
-/** Objects created by the + construct. */
-struct HeapExtendedObject : public HeapObject {
-    /** The left hand side of the construct. */
-    HeapObject *left;
-
-    /** The right hand side of the construct. */
-    HeapObject *right;
-
-    HeapExtendedObject(HeapObject *left, HeapObject *right)
-      : left(left), right(right)
-    { }
-};
-
-/** Objects created by the ObjectComprehensionSimple construct. */
-struct HeapComprehensionObject : public HeapLeafObject {
-
-    /** The captured environment. */
-    const BindingFrame upValues;
-
-    /** The expression used to compute the field values.  */
-    const AST* value;
-
-    /** The identifier of bound variable in that construct.  */
-    const Identifier * const id;
-
-    /** Binding for id.
-     *
-     * For each field, holds the value that should be bound to id.  This is the corresponding
-     * array element from the original array used to define this object.  This should not really
-     * be a thunk, but it makes the implementation easier.
-     *
-     * It is convenient to make this non-const to allow building up the values one by one, so that
-     * the garbage collector can see them at each intermediate point.
-     */
-    std::map<const Identifier*, HeapThunk*> compValues;
-
-    HeapComprehensionObject(const BindingFrame &up_values, const AST *value,
-                            const Identifier *id,
-                            const std::map<const Identifier*, HeapThunk*> &comp_values)
-      : upValues(up_values), value(value), id(id), compValues(comp_values)
-    { }
-};
-
-/** Stores the function itself and also the captured environment.
- *
- * Either body is non-null and builtinName is "", or body is null and builtin refers to a built-in
- * function.  In the former case, the closure represents a user function, otherwise calling it
- * will trigger the builtin function to execute.  Params is empty when the function is a
- * builtin.
- */
-struct HeapClosure : public HeapEntity {
-    /** The captured environment. */
-    const BindingFrame upValues;
-    /** The captured self variable, or nullptr if there was none.  \see Frame. */
-    HeapObject *self;
-    /** The offset from the captured self variable.  \see Frame.*/
-    unsigned offset;
-    struct Param {
-        const Identifier *id;
-        const AST *def;
-        Param(const Identifier *id, const AST *def)
-          : id(id), def(def)
-        { }
-    };
-    typedef std::vector<Param> Params;
-    const Params params;
-    const AST *body;
-    std::string builtinName;
-    HeapClosure(const BindingFrame &up_values,
-                HeapObject *self,
-                unsigned offset,
-                const Params &params,
-                const AST *body, const std::string &builtin_name)
-      : upValues(up_values), self(self), offset(offset),
-        params(params), body(body), builtinName(builtin_name)
-    { }
-};
-
-/** Stores a simple string on the heap. */
-struct HeapString : public HeapEntity {
-    const UString value;
-    HeapString(const UString &value)
-      : value(value)
-    { }
-};
-
-/** The heap does memory management, i.e. garbage collection. */
-class Heap {
-
-    /** How many objects must exist in the heap before we bother doing garbage collection?
-     */
-    unsigned gcTuneMinObjects;
-
-    /** How much must the heap have grown since the last cycle to trigger a collection?
-     */
-    double gcTuneGrowthTrigger;
-
-    /** Value used to mark entities at the last garbage collection cycle. */
-    GarbageCollectionMark lastMark;
-
-    /** The heap entities (strings, arrays, objects, functions, etc).
-     *
-     * Not all may be reachable, all should have o->mark == this->lastMark.  Entities are
-     * removed from the heap via O(1) swap with last element, so the ordering of entities is
-     * arbitrary and changes every garbage collection cycle.
-     */
-    std::vector<HeapEntity*> entities;
-
-    /** The number of heap entities at the last garbage collection cycle. */
-    unsigned long lastNumEntities;
-
-    /** The number of heap entities now. */
-    unsigned long numEntities;
-
-    /** Add the HeapEntity inside v to vec, if the value exists on the heap.   
-     */
-    void addIfHeapEntity(Value v, std::vector<HeapEntity*> &vec)
-    {
-        if (v.isHeap()) vec.push_back(v.v.h);
-    }
-
-    /** Add the HeapEntity inside v to vec, if the value exists on the heap.   
-     */
-    void addIfHeapEntity(HeapEntity *v, std::vector<HeapEntity*> &vec)
-    {
-        vec.push_back(v);
-    }
-
-    public:
-
-    Heap(unsigned gc_tune_min_objects, double gc_tune_growth_trigger)
-      : gcTuneMinObjects(gc_tune_min_objects), gcTuneGrowthTrigger(gc_tune_growth_trigger),
-        lastMark(0), lastNumEntities(0), numEntities(0)
-    {
-    }
-
-    ~Heap(void)
-    {
-        // Nothing is marked, everything will be collected.
-        sweep();
-    }
-
-    /** Garbage collection: Mark v, and entities reachable from v. */
-    void markFrom(Value v)
-    {
-        if (v.isHeap()) markFrom(v.v.h);
-    }
-
-    /** Garbage collection: Mark heap entities reachable from the given heap entity. */
-    void markFrom(HeapEntity *from)
-    {
-        assert(from != nullptr);
-        const GarbageCollectionMark thisMark = lastMark + 1;
-        struct State {
-            HeapEntity *ent;
-            std::vector<HeapEntity*> children;
-            State(HeapEntity *ent) : ent(ent) { }
-        };
-
-        std::vector<State> stack;
-        stack.emplace_back(from);
-
-        while (stack.size() > 0) {
-            size_t curr_index = stack.size() - 1;
-            State &s = stack[curr_index];
-            HeapEntity *curr = s.ent;
-            if (curr->mark != thisMark) {
-                curr->mark = thisMark;
-
-                if (auto *obj = dynamic_cast<HeapSimpleObject*>(curr)) {
-                    for (auto upv : obj->upValues)
-                        addIfHeapEntity(upv.second, s.children);
-
-                } else if (auto *obj = dynamic_cast<HeapExtendedObject*>(curr)) {
-                    addIfHeapEntity(obj->left, s.children);
-                    addIfHeapEntity(obj->right, s.children);
-
-                } else if (auto *obj = dynamic_cast<HeapComprehensionObject*>(curr)) {
-                    for (auto upv : obj->upValues)
-                        addIfHeapEntity(upv.second, s.children);
-                    for (auto upv : obj->compValues)
-                        addIfHeapEntity(upv.second, s.children);
-
-
-                } else if (auto *arr = dynamic_cast<HeapArray*>(curr)) {
-                    for (auto el : arr->elements)
-                        addIfHeapEntity(el, s.children);
-
-                } else if (auto *func = dynamic_cast<HeapClosure*>(curr)) {
-                    for (auto upv : func->upValues)
-                        addIfHeapEntity(upv.second, s.children);
-                    if (func->self)
-                        addIfHeapEntity(func->self, s.children);
-
-                } else if (auto *thunk = dynamic_cast<HeapThunk*>(curr)) {
-                    if (thunk->filled) {
-                        if (thunk->content.isHeap())
-                            addIfHeapEntity(thunk->content.v.h, s.children);
-                    } else {
-                        for (auto upv : thunk->upValues)
-                            addIfHeapEntity(upv.second, s.children);
-                        if (thunk->self)
-                            addIfHeapEntity(thunk->self, s.children);
-                    }
-                }
-            }
-
-            if (s.children.size() > 0) {
-                HeapEntity *next = s.children[s.children.size() - 1];
-                s.children.pop_back();
-                stack.emplace_back(next);  // CAUTION: s invalidated here
-            } else {
-                stack.pop_back();  // CAUTION: s invalidated here
-            }
-        }
-    }
-
-    /** Delete everything that was not marked since the last collection. */
-    void sweep(void)
-    {
-        lastMark++;
-        // Heap shrinks during this loop.  Do not cache entities.size().
-        for (unsigned long i=0 ; i<entities.size() ; ++i) {
-            HeapEntity *x = entities[i];
-            if (x->mark != lastMark) {
-                delete x;
-                if (i != entities.size() - 1) {
-                    // Swap it with the back.
-                    entities[i] = entities[entities.size()-1];
-                }
-                entities.pop_back();
-                --i;
-            }
-        }
-        lastNumEntities = numEntities = entities.size();
-    }
-
-    /** Is it time to initiate a GC cycle? */
-    bool checkHeap(void)
-    {
-        return numEntities > gcTuneMinObjects
-            && numEntities > gcTuneGrowthTrigger * lastNumEntities;
-    }
-
-    /** Allocate a heap entity.
-     *
-     * If the heap is large enough (\see gcTuneMinObjects) and has grown by enough since the
-     * last collection cycle (\see gcTuneGrowthTrigger), a collection cycle is performed.
-    */
-    template <class T, class... Args> T* makeEntity(Args&&... args)
-    {
-        T *r = new T(std::forward<Args>(args)...);
-        entities.push_back(r);
-        r->mark = lastMark;
-        numEntities = entities.size();
-        return r;
-    }
-
-};
-
-}  // namespace
-
-#endif  // JSONNET_STATE_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/static_analysis.cpp b/vendor/github.com/strickyak/jsonnet_cgo/static_analysis.cpp
deleted file mode 100644
index 9f234f6b79867ab4783de449f579bc6e37111211..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/static_analysis.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <set>
-
-#include "static_analysis.h"
-#include "static_error.h"
-#include "ast.h"
-
-typedef std::set<const Identifier *> IdSet;
-
-/** Inserts all of s into r. */
-static void append(IdSet &r, const IdSet &s)
-{
-    r.insert(s.begin(), s.end());
-}
-
-/** Statically analyse the given ast.
- *
- * \param ast_ The AST.
- * \param in_object Whether or not ast_ is within the lexical scope of an object AST.
- * \param vars The variables defined within lexical scope of ast_.
- * \returns The free variables in ast_.
- */
-static IdSet static_analysis(AST *ast_, bool in_object, const IdSet &vars)
-{
-    IdSet r;
-
-    if (auto *ast = dynamic_cast<const Apply*>(ast_)) {
-        append(r, static_analysis(ast->target, in_object, vars));
-        for (const auto &arg : ast->args)
-            append(r, static_analysis(arg.expr, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Array*>(ast_)) {
-        for (auto & el : ast->elements)
-            append(r, static_analysis(el.expr, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Binary*>(ast_)) {
-        append(r, static_analysis(ast->left, in_object, vars));
-        append(r, static_analysis(ast->right, in_object, vars));
-
-    } else if (dynamic_cast<const BuiltinFunction*>(ast_)) {
-        // Nothing to do.
-
-    } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) {
-        append(r, static_analysis(ast->cond, in_object, vars));
-        append(r, static_analysis(ast->branchTrue, in_object, vars));
-        append(r, static_analysis(ast->branchFalse, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Error*>(ast_)) {
-        append(r, static_analysis(ast->expr, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Function*>(ast_)) {
-        auto new_vars = vars;
-        IdSet params;
-        for (const auto &p : ast->params) {
-            if (params.find(p.id) != params.end()) {
-                std::string msg = "Duplicate function parameter: " + encode_utf8(p.id->name);
-                throw StaticError(ast_->location, msg);
-            }
-            params.insert(p.id);
-            new_vars.insert(p.id);
-        }
-
-        auto fv = static_analysis(ast->body, in_object, new_vars);
-        for (const auto &p : ast->params) {
-            if (p.expr != nullptr)
-                append(fv, static_analysis(p.expr, in_object, new_vars));
-        }
-        for (const auto &p : ast->params)
-            fv.erase(p.id);
-        append(r, fv);
-
-    } else if (dynamic_cast<const Import*>(ast_)) {
-        // Nothing to do.
-
-    } else if (dynamic_cast<const Importstr*>(ast_)) {
-        // Nothing to do.
-
-    } else if (auto *ast = dynamic_cast<const InSuper*>(ast_)) {
-        if (!in_object)
-            throw StaticError(ast_->location, "Can't use super outside of an object.");
-        append(r, static_analysis(ast->element, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Index*>(ast_)) {
-        append(r, static_analysis(ast->target, in_object, vars));
-        append(r, static_analysis(ast->index, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Local*>(ast_)) {
-        IdSet ast_vars;
-        for (const auto &bind: ast->binds) {
-            ast_vars.insert(bind.var);
-        }
-        auto new_vars = vars;
-        append(new_vars, ast_vars);
-        IdSet fvs;
-        for (const auto &bind: ast->binds) {
-            append(fvs, static_analysis(bind.body, in_object, new_vars));
-        }
-
-        append(fvs, static_analysis(ast->body, in_object, new_vars));
-
-        for (const auto &bind: ast->binds)
-            fvs.erase(bind.var);
-
-        append(r, fvs);
-
-    } else if (dynamic_cast<const LiteralBoolean*>(ast_)) {
-        // Nothing to do.
-
-    } else if (dynamic_cast<const LiteralNumber*>(ast_)) {
-        // Nothing to do.
-
-    } else if (dynamic_cast<const LiteralString*>(ast_)) {
-        // Nothing to do.
-
-    } else if (dynamic_cast<const LiteralNull*>(ast_)) {
-        // Nothing to do.
-
-    } else if (auto *ast = dynamic_cast<DesugaredObject*>(ast_)) {
-        for (auto &field : ast->fields) {
-            append(r, static_analysis(field.name, in_object, vars));
-            append(r, static_analysis(field.body, true, vars));
-        }
-        for (AST *assert : ast->asserts) {
-            append(r, static_analysis(assert, true, vars));
-        }
-
-    } else if (auto *ast = dynamic_cast<ObjectComprehensionSimple*>(ast_)) {
-        auto new_vars = vars;
-        new_vars.insert(ast->id);
-        append(r, static_analysis(ast->field, false, new_vars));
-        append(r, static_analysis(ast->value, true, new_vars));
-        r.erase(ast->id);
-        append(r, static_analysis(ast->array, in_object, vars));
-
-    } else if (dynamic_cast<const Self*>(ast_)) {
-        if (!in_object)
-            throw StaticError(ast_->location, "Can't use self outside of an object.");
-
-    } else if (auto *ast = dynamic_cast<const SuperIndex*>(ast_)) {
-        if (!in_object)
-            throw StaticError(ast_->location, "Can't use super outside of an object.");
-        append(r, static_analysis(ast->index, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Unary*>(ast_)) {
-        append(r, static_analysis(ast->expr, in_object, vars));
-
-    } else if (auto *ast = dynamic_cast<const Var*>(ast_)) {
-        if (vars.find(ast->id) == vars.end()) {
-            throw StaticError(ast->location, "Unknown variable: "+encode_utf8(ast->id->name));
-        }
-        r.insert(ast->id);
-
-    } else {
-        std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_ << std::endl;
-        std::abort();
-
-    }
-
-    for (auto *id : r)
-        ast_->freeVariables.push_back(id);
-
-    return r;
-}
-
-void jsonnet_static_analysis(AST *ast)
-{
-    static_analysis(ast, false, IdSet{});
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/static_error.h b/vendor/github.com/strickyak/jsonnet_cgo/static_error.h
deleted file mode 100644
index 1b8b7e837f1a080856b1c2101f0812fd0411a356..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/static_error.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_STATIC_ERROR_H
-#define JSONNET_STATIC_ERROR_H
-
-#include <iostream>
-#include <sstream>
-
-struct Location {
-    unsigned long line;
-    unsigned long column;
-    Location(void)
-      : line(0), column(0)
-    { }
-    Location(unsigned long line_number, unsigned long column)
-      : line(line_number), column(column)
-    { }
-    bool isSet(void) const
-    {
-        return line != 0;
-    }
-};
-
-static inline std::ostream &operator<<(std::ostream &o, const Location &loc)
-{
-    o << loc.line << ":" << loc.column;
-    return o;
-}
-
-struct LocationRange {
-    std::string file;
-    Location begin, end;
-    LocationRange(void)
-    { }
-    /** This is useful for special locations, e.g. manifestation entry point. */
-    LocationRange(const std::string &msg)
-      : file(msg)
-    { }
-    LocationRange(const std::string &file, const Location &begin, const Location &end)
-      : file(file), begin(begin), end(end)
-    { }
-    bool isSet(void) const
-    {
-        return begin.isSet();
-    }
-};
-
-static inline std::ostream &operator<<(std::ostream &o, const LocationRange &loc)
-{
-    if (loc.file.length() > 0)
-        o << loc.file;
-    if (loc.isSet()) {
-        if (loc.file.length() > 0)
-            o << ":";
-        if (loc.begin.line == loc.end.line) {
-            if (loc.begin.column == loc.end.column) {
-                o << loc.begin;
-            } else {
-                o << loc.begin << "-" << loc.end.column;
-            }
-        } else {
-            o << "(" << loc.begin << ")-(" << loc.end << ")";
-        }
-    }
-    return o;
-}
-
-struct StaticError {
-    LocationRange location;
-    std::string msg;
-    StaticError(const std::string &msg)
-      : msg(msg)
-    {
-    }
-    StaticError(const std::string &filename, const Location &location, const std::string &msg)
-      : location(filename, location, location), msg(msg)
-    {
-    }
-    StaticError(const LocationRange &location, const std::string &msg)
-      : location(location), msg(msg)
-    {
-    }
-
-    std::string toString() const
-    {
-        std::stringstream ss;
-        if (location.isSet()) {
-            ss << location << ":";
-        }
-        ss << " " << msg;
-        return ss.str();
-    }
-};
-
-static inline std::ostream &operator<<(std::ostream &o, const StaticError &err)
-{
-    o << err.toString();
-    return o;
-}
-
-#endif  // JSONNET_ERROR_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/std.jsonnet.h b/vendor/github.com/strickyak/jsonnet_cgo/std.jsonnet.h
deleted file mode 100644
index 94e44061b155d233cf7945bf5b362c6ccf698e10..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/std.jsonnet.h
+++ /dev/null
@@ -1,2 +0,0 @@
-47,42,10,67,111,112,121,114,105,103,104,116,32,50,48,49,53,32,71,111,111,103,108,101,32,73,110,99,46,32,65,108,108,32,114,105,103,104,116,115,32,114,101,115,101,114,118,101,100,46,10,10,76,105,99,101,110,115,101,100,32,117,110,100,101,114,32,116,104,101,32,65,112,97,99,104,101,32,76,105,99,101,110,115,101,44,32,86,101,114,115,105,111,110,32,50,46,48,32,40,116,104,101,32,34,76,105,99,101,110,115,101,34,41,59,10,121,111,117,32,109,97,121,32,110,111,116,32,117,115,101,32,116,104,105,115,32,102,105,108,101,32,101,120,99,101,112,116,32,105,110,32,99,111,109,112,108,105,97,110,99,101,32,119,105,116,104,32,116,104,101,32,76,105,99,101,110,115,101,46,10,89,111,117,32,109,97,121,32,111,98,116,97,105,110,32,97,32,99,111,112,121,32,111,102,32,116,104,101,32,76,105,99,101,110,115,101,32,97,116,10,10,32,32,32,32,104,116,116,112,58,47,47,119,119,119,46,97,112,97,99,104,101,46,111,114,103,47,108,105,99,101,110,115,101,115,47,76,73,67,69,78,83,69,45,50,46,48,10,10,85,110,108,101,115,115,32,114,101,113,117,105,114,101,100,32,98,121,32,97,112,112,108,105,99,97,98,108,101,32,108,97,119,32,111,114,32,97,103,114,101,101,100,32,116,111,32,105,110,32,119,114,105,116,105,110,103,44,32,115,111,102,116,119,97,114,101,10,100,105,115,116,114,105,98,117,116,101,100,32,117,110,100,101,114,32,116,104,101,32,76,105,99,101,110,115,101,32,105,115,32,100,105,115,116,114,105,98,117,116,101,100,32,111,110,32,97,110,32,34,65,83,32,73,83,34,32,66,65,83,73,83,44,10,87,73,84,72,79,85,84,32,87,65,82,82,65,78,84,73,69,83,32,79,82,32,67,79,78,68,73,84,73,79,78,83,32,79,70,32,65,78,89,32,75,73,78,68,44,32,101,105,116,104,101,114,32,101,120,112,114,101,115,115,32,111,114,32,105,109,112,108,105,101,100,46,10,83,101,101,32,116,104,101,32,76,105,99,101,110,115,101,32,102,111,114,32,116,104,101,32,115,112,101,99,105,102,105,99,32,108,97,110,103,117,97,103,101,32,103,111,118,101,114,110,105,110,103,32,112,101,114,109,105,115,115,105,111,110,115,32,97,110,100,10,108,105,109,105,116,97,116,105,111,110,115,32,117,110,100,101,114,32,116,104,101,32,76,105,99,101,110,115,101,46,10,42,47,10,10,47,42,32,84,104,105,115,32,105,115,32,116,104,101,32,74,115,111,110,110,101,116,32,115,116,97,110,100,97,114,100,32,108,105,98,114,97,114,121,44,32,97,116,32,108,101,97,115,116,32,116,104,101,32,112,97,114,116,115,32,111,102,32,105,116,32,116,104,97,116,32,97,114,101,32,119,114,105,116,116,101,110,32,105,110,32,74,115,111,110,110,101,116,46,10,32,42,10,32,42,32,84,104,101,114,101,32,97,114,101,32,115,111,109,101,32,110,97,116,105,118,101,32,109,101,116,104,111,100,115,32,97,115,32,119,101,108,108,44,32,119,104,105,99,104,32,97,114,101,32,100,101,102,105,110,101,100,32,105,110,32,116,104,101,32,105,110,116,101,114,112,114,101,116,101,114,32,97,110,100,32,97,100,100,101,100,32,116,111,32,116,104,105,115,10,32,42,32,102,105,108,101,46,32,32,73,116,32,105,115,32,110,101,118,101,114,32,110,101,99,101,115,115,97,114,121,32,116,111,32,105,109,112,111,114,116,32,115,116,100,46,106,115,111,110,110,101,116,44,32,105,116,32,105,115,32,101,109,98,101,100,100,101,100,32,105,110,116,111,32,116,104,101,32,105,110,116,101,114,112,114,101,116,101,114,32,97,116,10,32,42,32,99,111,109,112,105,108,101,45,116,105,109,101,32,97,110,100,32,97,117,116,111,109,97,116,105,99,97,108,108,121,32,105,109,112,111,114,116,101,100,32,105,110,116,111,32,97,108,108,32,111,116,104,101,114,32,74,115,111,110,110,101,116,32,112,114,111,103,114,97,109,115,46,10,32,42,47,10,123,10,10,32,32,32,32,108,111,99,97,108,32,115,116,100,32,61,32,115,101,108,102,44,10,10,32,32,32,32,116,111,83,116,114,105,110,103,40,97,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,97,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,32,97,32,101,108,115,101,32,34,34,32,43,32,97,44,10,10,32,32,32,32,115,117,98,115,116,114,40,115,116,114,44,32,102,114,111,109,44,32,108,101,110,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,115,116,114,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,117,98,115,116,114,32,102,105,114,115,116,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,115,116,114,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,102,114,111,109,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,117,98,115,116,114,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,102,114,111,109,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,108,101,110,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,117,98,115,116,114,32,116,104,105,114,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,108,101,110,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,108,101,110,32,60,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,117,98,115,116,114,32,116,104,105,114,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,103,114,101,97,116,101,114,32,116,104,97,110,32,122,101,114,111,44,32,103,111,116,32,34,32,43,32,108,101,110,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,34,44,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,108,101,110,44,32,102,117,110,99,116,105,111,110,40,105,41,32,115,116,114,91,105,32,43,32,102,114,111,109,93,41,41,44,10,10,32,32,32,32,115,116,97,114,116,115,87,105,116,104,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,60,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,115,117,98,115,116,114,40,97,44,32,48,44,32,115,116,100,46,108,101,110,103,116,104,40,98,41,41,32,61,61,32,98,44,10,10,32,32,32,32,101,110,100,115,87,105,116,104,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,60,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,115,117,98,115,116,114,40,97,44,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,45,32,115,116,100,46,108,101,110,103,116,104,40,98,41,44,32,115,116,100,46,108,101,110,103,116,104,40,98,41,41,32,61,61,32,98,44,10,10,32,32,32,32,115,116,114,105,110,103,67,104,97,114,115,40,115,116,114,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,44,32,102,117,110,99,116,105,111,110,40,105,41,32,115,116,114,91,105,93,41,44,10,10,32,32,32,32,112,97,114,115,101,73,110,116,40,115,116,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,100,100,68,105,103,105,116,40,97,103,103,114,101,103,97,116,101,44,32,100,105,103,105,116,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,100,105,103,105,116,32,60,32,48,32,124,124,32,100,105,103,105,116,32,62,32,57,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,112,97,114,115,101,73,110,116,32,103,111,116,32,115,116,114,105,110,103,32,119,104,105,99,104,32,100,111,101,115,32,110,111,116,32,109,97,116,99,104,32,114,101,103,101,120,32,91,48,45,57,93,43,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,49,48,32,42,32,97,103,103,114,101,103,97,116,101,32,43,32,100,105,103,105,116,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,111,68,105,103,105,116,115,40,115,116,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,91,115,116,100,46,99,111,100,101,112,111,105,110,116,40,99,104,97,114,41,32,45,32,115,116,100,46,99,111,100,101,112,111,105,110,116,40,34,48,34,41,32,102,111,114,32,99,104,97,114,32,105,110,32,115,116,100,46,115,116,114,105,110,103,67,104,97,114,115,40,115,116,114,41,93,59,10,32,32,32,32,32,32,32,32,105,102,32,115,116,114,91,48,93,32,61,61,32,34,45,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,45,115,116,100,46,102,111,108,100,108,40,97,100,100,68,105,103,105,116,44,32,116,111,68,105,103,105,116,115,40,115,116,114,91,49,58,93,41,44,32,48,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,102,111,108,100,108,40,97,100,100,68,105,103,105,116,44,32,116,111,68,105,103,105,116,115,40,115,116,114,41,44,32,48,41,44,10,10,32,32,32,32,115,112,108,105,116,40,115,116,114,44,32,99,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,115,116,114,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,32,102,105,114,115,116,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,115,116,114,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,99,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,99,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,99,41,32,33,61,32,49,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,104,97,118,101,32,108,101,110,103,116,104,32,49,44,32,103,111,116,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,99,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,115,112,108,105,116,76,105,109,105,116,40,115,116,114,44,32,99,44,32,45,49,41,44,10,10,32,32,32,32,115,112,108,105,116,76,105,109,105,116,40,115,116,114,44,32,99,44,32,109,97,120,115,112,108,105,116,115,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,115,116,114,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,76,105,109,105,116,32,102,105,114,115,116,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,115,116,114,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,99,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,76,105,109,105,116,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,99,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,99,41,32,33,61,32,49,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,76,105,109,105,116,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,104,97,118,101,32,108,101,110,103,116,104,32,49,44,32,103,111,116,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,99,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,109,97,120,115,112,108,105,116,115,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,115,112,108,105,116,76,105,109,105,116,32,116,104,105,114,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,109,97,120,115,112,108,105,116,115,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,115,116,114,44,32,100,101,108,105,109,44,32,105,44,32,97,114,114,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,105,50,32,61,32,105,32,43,32,49,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,114,114,32,43,32,91,118,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,100,101,108,105,109,32,38,38,32,40,109,97,120,115,112,108,105,116,115,32,61,61,32,45,49,32,124,124,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,60,32,109,97,120,115,112,108,105,116,115,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,100,101,108,105,109,44,32,105,50,44,32,97,114,114,32,43,32,91,118,93,44,32,34,34,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,100,101,108,105,109,44,32,105,50,44,32,97,114,114,44,32,118,32,43,32,99,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,99,44,32,48,44,32,91,93,44,32,34,34,41,44,10,10,32,32,32,32,114,97,110,103,101,40,102,114,111,109,44,32,116,111,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,116,111,32,45,32,102,114,111,109,32,43,32,49,44,32,102,117,110,99,116,105,111,110,40,105,41,32,105,32,43,32,102,114,111,109,41,44,10,10,32,32,32,32,115,108,105,99,101,40,105,110,100,101,120,97,98,108,101,44,32,105,110,100,101,120,44,32,101,110,100,44,32,115,116,101,112,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,105,110,118,97,114,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,108,111,111,112,32,105,110,118,97,114,105,97,110,116,32,119,105,116,104,32,100,101,102,97,117,108,116,115,32,97,112,112,108,105,101,100,10,32,32,32,32,32,32,32,32,32,32,32,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,110,100,101,120,97,98,108,101,58,32,105,110,100,101,120,97,98,108,101,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,110,100,101,120,58,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,110,100,101,120,32,61,61,32,110,117,108,108,32,116,104,101,110,32,48,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,110,100,101,120,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,110,100,58,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,101,110,100,32,61,61,32,110,117,108,108,32,116,104,101,110,32,115,116,100,46,108,101,110,103,116,104,40,105,110,100,101,120,97,98,108,101,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,101,110,100,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,101,112,58,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,101,112,32,61,61,32,110,117,108,108,32,116,104,101,110,32,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,115,116,101,112,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,101,110,103,116,104,58,32,115,116,100,46,108,101,110,103,116,104,40,105,110,100,101,120,97,98,108,101,41,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,121,112,101,58,32,115,116,100,46,116,121,112,101,40,105,110,100,101,120,97,98,108,101,41,44,10,32,32,32,32,32,32,32,32,32,32,32,32,125,59,10,32,32,32,32,32,32,32,32,105,102,32,105,110,118,97,114,46,105,110,100,101,120,32,60,32,48,32,124,124,32,105,110,118,97,114,46,101,110,100,32,60,32,48,32,124,124,32,105,110,118,97,114,46,115,116,101,112,32,60,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,103,111,116,32,91,37,115,58,37,115,58,37,115,93,32,98,117,116,32,110,101,103,97,116,105,118,101,32,105,110,100,101,120,44,32,101,110,100,44,32,97,110,100,32,115,116,101,112,115,32,97,114,101,32,110,111,116,32,115,117,112,112,111,114,116,101,100,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,37,32,91,105,110,118,97,114,46,105,110,100,101,120,44,32,105,110,118,97,114,46,101,110,100,44,32,105,110,118,97,114,46,115,116,101,112,93,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,101,112,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,103,111,116,32,37,115,32,98,117,116,32,115,116,101,112,32,109,117,115,116,32,98,101,32,103,114,101,97,116,101,114,32,116,104,97,110,32,48,34,32,37,32,115,116,101,112,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,105,110,100,101,120,97,98,108,101,41,32,33,61,32,34,115,116,114,105,110,103,34,32,38,38,32,115,116,100,46,116,121,112,101,40,105,110,100,101,120,97,98,108,101,41,32,33,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,115,108,105,99,101,32,97,99,99,101,112,116,115,32,97,32,115,116,114,105,110,103,32,111,114,32,97,110,32,97,114,114,97,121,44,32,98,117,116,32,103,111,116,58,32,37,115,34,32,37,32,115,116,100,46,116,121,112,101,40,105,110,100,101,120,97,98,108,101,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,98,117,105,108,100,40,115,108,105,99,101,44,32,99,117,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,117,114,32,62,61,32,105,110,118,97,114,46,101,110,100,32,124,124,32,99,117,114,32,62,61,32,105,110,118,97,114,46,108,101,110,103,116,104,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,108,105,99,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,117,105,108,100,40,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,110,118,97,114,46,116,121,112,101,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,108,105,99,101,32,43,32,105,110,118,97,114,46,105,110,100,101,120,97,98,108,101,91,99,117,114,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,108,105,99,101,32,43,32,91,105,110,118,97,114,46,105,110,100,101,120,97,98,108,101,91,99,117,114,93,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,117,114,32,43,32,105,110,118,97,114,46,115,116,101,112,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,98,117,105,108,100,40,105,102,32,105,110,118,97,114,46,116,121,112,101,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,32,34,34,32,101,108,115,101,32,91,93,44,32,105,110,118,97,114,46,105,110,100,101,120,41,44,10,10,32,32,32,32,99,111,117,110,116,40,97,114,114,44,32,120,41,58,58,32,115,116,100,46,108,101,110,103,116,104,40,115,116,100,46,102,105,108,116,101,114,40,102,117,110,99,116,105,111,110,40,118,41,32,118,32,61,61,32,120,44,32,97,114,114,41,41,44,10,10,32,32,32,32,109,111,100,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,97,41,32,61,61,32,34,110,117,109,98,101,114,34,32,38,38,32,115,116,100,46,116,121,112,101,40,98,41,32,61,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,111,100,117,108,111,40,97,44,32,98,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,97,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,102,111,114,109,97,116,40,97,44,32,98,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,79,112,101,114,97,116,111,114,32,37,32,99,97,110,110,111,116,32,98,101,32,117,115,101,100,32,111,110,32,116,121,112,101,115,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,41,32,43,32,34,32,97,110,100,32,34,32,43,32,115,116,100,46,116,121,112,101,40,98,41,32,43,32,34,46,34,44,10,10,32,32,32,32,109,97,112,40,102,117,110,99,44,32,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,102,117,110,99,41,32,33,61,32,34,102,117,110,99,116,105,111,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,109,97,112,32,102,105,114,115,116,32,112,97,114,97,109,32,109,117,115,116,32,98,101,32,102,117,110,99,116,105,111,110,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,102,117,110,99,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,97,114,114,41,32,33,61,32,34,97,114,114,97,121,34,32,38,38,32,115,116,100,46,116,121,112,101,40,97,114,114,41,32,33,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,109,97,112,32,115,101,99,111,110,100,32,112,97,114,97,109,32,109,117,115,116,32,98,101,32,97,114,114,97,121,32,47,32,115,116,114,105,110,103,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,114,114,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,44,32,102,117,110,99,116,105,111,110,40,105,41,32,102,117,110,99,40,97,114,114,91,105,93,41,41,44,10,10,32,32,32,32,106,111,105,110,40,115,101,112,44,32,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,114,114,44,32,105,44,32,102,105,114,115,116,44,32,114,117,110,110,105,110,103,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,117,110,110,105,110,103,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,97,114,114,91,105,93,32,61,61,32,110,117,108,108,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,49,44,32,102,105,114,115,116,44,32,114,117,110,110,105,110,103,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,102,105,114,115,116,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,49,44,32,102,97,108,115,101,44,32,114,117,110,110,105,110,103,32,43,32,97,114,114,91,105,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,49,44,32,102,97,108,115,101,44,32,114,117,110,110,105,110,103,32,43,32,115,101,112,32,43,32,97,114,114,91,105,93,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,97,114,114,41,32,33,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,106,111,105,110,32,115,101,99,111,110,100,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,97,114,114,97,121,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,114,114,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,115,101,112,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,48,44,32,116,114,117,101,44,32,34,34,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,115,101,112,41,32,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,48,44,32,116,114,117,101,44,32,91,93,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,106,111,105,110,32,102,105,114,115,116,32,112,97,114,97,109,101,116,101,114,32,115,104,111,117,108,100,32,98,101,32,115,116,114,105,110,103,32,111,114,32,97,114,114,97,121,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,115,101,112,41,44,10,10,32,32,32,32,108,105,110,101,115,40,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,92,110,34,44,32,97,114,114,32,43,32,91,34,34,93,41,44,10,10,32,32,32,32,102,111,114,109,97,116,40,115,116,114,44,32,118,97,108,115,41,58,58,10,10,32,32,32,32,32,32,32,32,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,10,32,32,32,32,32,32,32,32,47,47,32,80,97,114,115,101,32,116,104,101,32,109,105,110,105,45,108,97,110,103,117,97,103,101,32,47,47,10,32,32,32,32,32,32,32,32,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,121,95,112,97,114,115,101,95,109,97,112,112,105,110,103,95,107,101,121,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,40,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,106,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,33,61,32,34,41,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,43,32,99,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,106,32,43,32,49,44,32,118,58,32,118,32,125,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,105,32,43,32,49,44,32,34,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,44,32,118,58,32,110,117,108,108,32,125,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,121,95,112,97,114,115,101,95,99,102,108,97,103,115,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,106,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,35,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,123,32,97,108,116,58,32,116,114,117,101,32,125,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,48,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,123,32,122,101,114,111,58,32,116,114,117,101,32,125,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,45,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,123,32,108,101,102,116,58,32,116,114,117,101,32,125,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,32,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,123,32,98,108,97,110,107,58,32,116,114,117,101,32,125,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,43,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,123,32,115,105,103,110,58,32,116,114,117,101,32,125,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,106,44,32,118,58,32,118,32,125,59,10,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,105,44,32,123,32,97,108,116,58,32,102,97,108,115,101,44,32,122,101,114,111,58,32,102,97,108,115,101,44,32,108,101,102,116,58,32,102,97,108,115,101,44,32,98,108,97,110,107,58,32,102,97,108,115,101,44,32,115,105,103,110,58,32,102,97,108,115,101,32,125,41,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,121,95,112,97,114,115,101,95,102,105,101,108,100,95,119,105,100,116,104,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,60,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,38,38,32,115,116,114,91,105,93,32,61,61,32,34,42,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,42,34,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,106,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,48,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,48,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,49,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,49,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,50,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,50,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,51,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,51,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,52,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,52,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,53,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,53,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,54,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,54,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,55,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,55,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,56,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,56,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,57,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,106,32,43,32,49,44,32,118,32,42,32,49,48,32,43,32,57,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,106,44,32,118,58,32,118,32,125,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,110,115,117,109,101,40,115,116,114,44,32,105,44,32,48,41,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,121,95,112,97,114,115,101,95,112,114,101,99,105,115,105,111,110,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,46,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,114,121,95,112,97,114,115,101,95,102,105,101,108,100,95,119,105,100,116,104,40,115,116,114,44,32,105,32,43,32,49,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,44,32,118,58,32,110,117,108,108,32,125,59,10,10,32,32,32,32,32,32,32,32,47,47,32,73,103,110,111,114,101,100,44,32,105,102,32,105,116,32,101,120,105,115,116,115,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,121,95,112,97,114,115,101,95,108,101,110,103,116,104,95,109,111,100,105,102,105,101,114,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,104,34,32,124,124,32,99,32,61,61,32,34,108,34,32,124,124,32,99,32,61,61,32,34,76,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,32,43,32,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,114,115,101,95,99,111,110,118,95,116,121,112,101,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,100,34,32,124,124,32,99,32,61,61,32,34,105,34,32,124,124,32,99,32,61,61,32,34,117,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,100,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,111,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,111,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,120,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,120,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,88,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,120,34,44,32,99,97,112,115,58,32,116,114,117,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,101,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,101,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,69,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,101,34,44,32,99,97,112,115,58,32,116,114,117,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,102,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,102,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,70,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,102,34,44,32,99,97,112,115,58,32,116,114,117,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,103,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,71,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,103,34,44,32,99,97,112,115,58,32,116,114,117,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,99,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,99,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,115,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,115,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,32,61,61,32,34,37,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,32,105,58,32,105,32,43,32,49,44,32,118,58,32,34,37,34,44,32,99,97,112,115,58,32,102,97,108,115,101,32,125,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,85,110,114,101,99,111,103,110,105,115,101,100,32,99,111,110,118,101,114,115,105,111,110,32,116,121,112,101,58,32,34,32,43,32,99,59,10,10,10,32,32,32,32,32,32,32,32,47,47,32,80,97,114,115,101,100,32,105,110,105,116,105,97,108,32,37,44,32,110,111,119,32,116,104,101,32,114,101,115,116,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,114,115,101,95,99,111,100,101,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,117,110,99,97,116,101,100,32,102,111,114,109,97,116,32,99,111,100,101,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,109,107,101,121,32,61,32,116,114,121,95,112,97,114,115,101,95,109,97,112,112,105,110,103,95,107,101,121,40,115,116,114,44,32,105,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,102,108,97,103,115,32,61,32,116,114,121,95,112,97,114,115,101,95,99,102,108,97,103,115,40,115,116,114,44,32,109,107,101,121,46,105,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,119,32,61,32,116,114,121,95,112,97,114,115,101,95,102,105,101,108,100,95,119,105,100,116,104,40,115,116,114,44,32,99,102,108,97,103,115,46,105,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,114,101,99,32,61,32,116,114,121,95,112,97,114,115,101,95,112,114,101,99,105,115,105,111,110,40,115,116,114,44,32,102,119,46,105,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,101,110,95,109,111,100,32,61,32,116,114,121,95,112,97,114,115,101,95,108,101,110,103,116,104,95,109,111,100,105,102,105,101,114,40,115,116,114,44,32,112,114,101,99,46,105,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,116,121,112,101,32,61,32,112,97,114,115,101,95,99,111,110,118,95,116,121,112,101,40,115,116,114,44,32,108,101,110,95,109,111,100,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,58,32,99,116,121,112,101,46,105,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,100,101,58,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,109,107,101,121,58,32,109,107,101,121,46,118,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,102,108,97,103,115,58,32,99,102,108,97,103,115,46,118,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,119,58,32,102,119,46,118,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,114,101,99,58,32,112,114,101,99,46,118,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,116,121,112,101,58,32,99,116,121,112,101,46,118,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,97,112,115,58,32,99,116,121,112,101,46,99,97,112,115,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,59,10,10,32,32,32,32,32,32,32,32,47,47,32,80,97,114,115,101,32,97,32,102,111,114,109,97,116,32,115,116,114,105,110,103,32,40,99,111,110,116,97,105,110,105,110,103,32,110,111,110,101,32,111,114,32,109,111,114,101,32,37,32,102,111,114,109,97,116,32,116,97,103,115,41,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,114,115,101,95,99,111,100,101,115,40,115,116,114,44,32,105,44,32,111,117,116,44,32,99,117,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,111,117,116,32,43,32,91,99,117,114,93,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,32,61,32,115,116,114,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,32,61,61,32,34,37,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,32,61,32,112,97,114,115,101,95,99,111,100,101,40,115,116,114,44,32,105,32,43,32,49,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,114,115,101,95,99,111,100,101,115,40,115,116,114,44,32,114,46,105,44,32,111,117,116,32,43,32,91,99,117,114,44,32,114,46,99,111,100,101,93,44,32,34,34,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,114,115,101,95,99,111,100,101,115,40,115,116,114,44,32,105,32,43,32,49,44,32,111,117,116,44,32,99,117,114,32,43,32,99,41,32,116,97,105,108,115,116,114,105,99,116,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,100,101,115,32,61,32,112,97,114,115,101,95,99,111,100,101,115,40,115,116,114,44,32,48,44,32,91,93,44,32,34,34,41,59,10,10,10,32,32,32,32,32,32,32,32,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,10,32,32,32,32,32,32,32,32,47,47,32,70,111,114,109,97,116,32,116,104,101,32,118,97,108,117,101,115,32,47,47,10,32,32,32,32,32,32,32,32,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,10,10,32,32,32,32,32,32,32,32,47,47,32,85,115,101,102,117,108,32,117,116,105,108,105,116,105,101,115,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,100,100,105,110,103,40,119,44,32,115,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,119,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,119,32,60,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,118,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,119,32,45,32,49,44,32,118,32,43,32,115,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,119,44,32,34,34,41,59,10,10,32,32,32,32,32,32,32,32,47,47,32,65,100,100,32,115,32,116,111,32,116,104,101,32,108,101,102,116,32,111,102,32,115,116,114,32,115,111,32,116,104,97,116,32,105,116,115,32,108,101,110,103,116,104,32,105,115,32,97,116,32,108,101,97,115,116,32,119,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,100,95,108,101,102,116,40,115,116,114,44,32,119,44,32,115,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,112,97,100,100,105,110,103,40,119,32,45,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,44,32,115,41,32,43,32,115,116,114,59,10,10,32,32,32,32,32,32,32,32,47,47,32,65,100,100,32,115,32,116,111,32,116,104,101,32,114,105,103,104,116,32,111,102,32,115,116,114,32,115,111,32,116,104,97,116,32,105,116,115,32,108,101,110,103,116,104,32,105,115,32,97,116,32,108,101,97,115,116,32,119,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,97,100,95,114,105,103,104,116,40,115,116,114,44,32,119,44,32,115,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,114,32,43,32,112,97,100,100,105,110,103,40,119,32,45,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,44,32,115,41,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,97,110,32,105,110,116,101,103,101,114,32,40,101,46,103,46,44,32,100,101,99,105,109,97,108,32,111,114,32,111,99,116,97,108,41,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,101,110,100,101,114,95,105,110,116,40,110,95,95,44,32,109,105,110,95,99,104,97,114,115,44,32,109,105,110,95,100,105,103,105,116,115,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,114,97,100,105,120,44,32,122,101,114,111,95,112,114,101,102,105,120,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,95,32,61,32,115,116,100,46,97,98,115,40,110,95,95,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,110,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,110,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,122,101,114,111,95,112,114,101,102,105,120,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,100,46,102,108,111,111,114,40,110,32,47,32,114,97,100,105,120,41,41,32,43,32,40,110,32,37,32,114,97,100,105,120,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,100,101,99,32,61,32,105,102,32,115,116,100,46,102,108,111,111,114,40,110,95,41,32,61,61,32,48,32,116,104,101,110,32,34,48,34,32,101,108,115,101,32,97,117,120,40,115,116,100,46,102,108,111,111,114,40,110,95,41,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,101,103,32,61,32,110,95,95,32,60,32,48,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,32,61,32,109,105,110,95,99,104,97,114,115,32,45,32,40,105,102,32,110,101,103,32,124,124,32,98,108,97,110,107,32,124,124,32,115,105,103,110,32,116,104,101,110,32,49,32,101,108,115,101,32,48,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,50,32,61,32,115,116,100,46,109,97,120,40,122,112,44,32,109,105,110,95,100,105,103,105,116,115,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,100,101,99,50,32,61,32,112,97,100,95,108,101,102,116,40,100,101,99,44,32,122,112,50,44,32,34,48,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,40,105,102,32,110,101,103,32,116,104,101,110,32,34,45,34,32,101,108,115,101,32,105,102,32,115,105,103,110,32,116,104,101,110,32,34,43,34,32,101,108,115,101,32,105,102,32,98,108,97,110,107,32,116,104,101,110,32,34,32,34,32,101,108,115,101,32,34,34,41,32,43,32,100,101,99,50,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,97,110,32,105,110,116,101,103,101,114,32,105,110,32,104,101,120,97,100,101,99,105,109,97,108,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,101,110,100,101,114,95,104,101,120,40,110,95,95,44,32,109,105,110,95,99,104,97,114,115,44,32,109,105,110,95,100,105,103,105,116,115,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,97,100,100,95,122,101,114,111,120,44,32,99,97,112,105,116,97,108,115,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,117,109,101,114,97,108,115,32,61,32,91,48,44,32,49,44,32,50,44,32,51,44,32,52,44,32,53,44,32,54,44,32,55,44,32,56,44,32,57,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,102,32,99,97,112,105,116,97,108,115,32,116,104,101,110,32,91,34,65,34,44,32,34,66,34,44,32,34,67,34,44,32,34,68,34,44,32,34,69,34,44,32,34,70,34,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,91,34,97,34,44,32,34,98,34,44,32,34,99,34,44,32,34,100,34,44,32,34,101,34,44,32,34,102,34,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,95,32,61,32,115,116,100,46,97,98,115,40,110,95,95,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,110,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,110,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,100,46,102,108,111,111,114,40,110,32,47,32,49,54,41,41,32,43,32,110,117,109,101,114,97,108,115,91,110,32,37,32,49,54,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,104,101,120,32,61,32,105,102,32,115,116,100,46,102,108,111,111,114,40,110,95,41,32,61,61,32,48,32,116,104,101,110,32,34,48,34,32,101,108,115,101,32,97,117,120,40,115,116,100,46,102,108,111,111,114,40,110,95,41,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,101,103,32,61,32,110,95,95,32,60,32,48,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,32,61,32,109,105,110,95,99,104,97,114,115,32,45,32,40,105,102,32,110,101,103,32,124,124,32,98,108,97,110,107,32,124,124,32,115,105,103,110,32,116,104,101,110,32,49,32,101,108,115,101,32,48,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,45,32,40,105,102,32,97,100,100,95,122,101,114,111,120,32,116,104,101,110,32,50,32,101,108,115,101,32,48,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,50,32,61,32,115,116,100,46,109,97,120,40,122,112,44,32,109,105,110,95,100,105,103,105,116,115,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,104,101,120,50,32,61,32,40,105,102,32,97,100,100,95,122,101,114,111,120,32,116,104,101,110,32,40,105,102,32,99,97,112,105,116,97,108,115,32,116,104,101,110,32,34,48,88,34,32,101,108,115,101,32,34,48,120,34,41,32,101,108,115,101,32,34,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,112,97,100,95,108,101,102,116,40,104,101,120,44,32,122,112,50,44,32,34,48,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,40,105,102,32,110,101,103,32,116,104,101,110,32,34,45,34,32,101,108,115,101,32,105,102,32,115,105,103,110,32,116,104,101,110,32,34,43,34,32,101,108,115,101,32,105,102,32,98,108,97,110,107,32,116,104,101,110,32,34,32,34,32,101,108,115,101,32,34,34,41,32,43,32,104,101,120,50,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,105,112,95,116,114,97,105,108,105,110,103,95,122,101,114,111,40,115,116,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,115,116,114,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,60,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,114,91,105,93,32,61,61,32,34,48,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,105,32,45,32,49,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,115,117,98,115,116,114,40,115,116,114,44,32,48,44,32,105,32,43,32,49,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,45,32,49,41,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,102,108,111,97,116,105,110,103,32,112,111,105,110,116,32,105,110,32,100,101,99,105,109,97,108,32,102,111,114,109,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,101,110,100,101,114,95,102,108,111,97,116,95,100,101,99,40,110,95,95,44,32,122,101,114,111,95,112,97,100,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,101,110,115,117,114,101,95,112,116,44,32,116,114,97,105,108,105,110,103,44,32,112,114,101,99,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,95,32,61,32,115,116,100,46,97,98,115,40,110,95,95,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,119,104,111,108,101,32,61,32,115,116,100,46,102,108,111,111,114,40,110,95,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,100,111,116,95,115,105,122,101,32,61,32,105,102,32,112,114,101,99,32,61,61,32,48,32,38,38,32,33,101,110,115,117,114,101,95,112,116,32,116,104,101,110,32,48,32,101,108,115,101,32,49,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,32,61,32,122,101,114,111,95,112,97,100,32,45,32,112,114,101,99,32,45,32,100,111,116,95,115,105,122,101,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,32,114,101,110,100,101,114,95,105,110,116,40,110,95,95,32,47,32,110,95,32,42,32,119,104,111,108,101,44,32,122,112,44,32,48,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,49,48,44,32,34,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,112,114,101,99,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,114,32,43,32,105,102,32,101,110,115,117,114,101,95,112,116,32,116,104,101,110,32,34,46,34,32,101,108,115,101,32,34,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,114,97,99,32,61,32,115,116,100,46,102,108,111,111,114,40,40,110,95,32,45,32,119,104,111,108,101,41,32,42,32,115,116,100,46,112,111,119,40,49,48,44,32,112,114,101,99,41,32,43,32,48,46,53,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,116,114,97,105,108,105,110,103,32,124,124,32,102,114,97,99,32,62,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,114,97,99,95,115,116,114,32,61,32,114,101,110,100,101,114,95,105,110,116,40,102,114,97,99,44,32,112,114,101,99,44,32,48,44,32,102,97,108,115,101,44,32,102,97,108,115,101,44,32,49,48,44,32,34,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,114,32,43,32,34,46,34,32,43,32,105,102,32,33,116,114,97,105,108,105,110,103,32,116,104,101,110,32,115,116,114,105,112,95,116,114,97,105,108,105,110,103,95,122,101,114,111,40,102,114,97,99,95,115,116,114,41,32,101,108,115,101,32,102,114,97,99,95,115,116,114,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,114,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,102,108,111,97,116,105,110,103,32,112,111,105,110,116,32,105,110,32,115,99,105,101,110,116,105,102,105,99,32,102,111,114,109,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,101,110,100,101,114,95,102,108,111,97,116,95,115,99,105,40,110,95,95,44,32,122,101,114,111,95,112,97,100,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,101,110,115,117,114,101,95,112,116,44,32,116,114,97,105,108,105,110,103,44,32,99,97,112,115,44,32,112,114,101,99,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,101,120,112,111,110,101,110,116,32,61,32,115,116,100,46,102,108,111,111,114,40,115,116,100,46,108,111,103,40,115,116,100,46,97,98,115,40,110,95,95,41,41,32,47,32,115,116,100,46,108,111,103,40,49,48,41,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,117,102,102,32,61,32,40,105,102,32,99,97,112,115,32,116,104,101,110,32,34,69,34,32,101,108,115,101,32,34,101,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,114,101,110,100,101,114,95,105,110,116,40,101,120,112,111,110,101,110,116,44,32,51,44,32,48,44,32,102,97,108,115,101,44,32,116,114,117,101,44,32,49,48,44,32,34,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,109,97,110,116,105,115,115,97,32,61,32,110,95,95,32,47,32,115,116,100,46,112,111,119,40,49,48,44,32,101,120,112,111,110,101,110,116,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,50,32,61,32,122,101,114,111,95,112,97,100,32,45,32,115,116,100,46,108,101,110,103,116,104,40,115,117,102,102,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,102,108,111,97,116,95,100,101,99,40,109,97,110,116,105,115,115,97,44,32,122,112,50,44,32,98,108,97,110,107,44,32,115,105,103,110,44,32,101,110,115,117,114,101,95,112,116,44,32,116,114,97,105,108,105,110,103,44,32,112,114,101,99,41,32,43,32,115,117,102,102,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,97,32,118,97,108,117,101,32,119,105,116,104,32,97,110,32,97,114,98,105,116,114,97,114,121,32,102,111,114,109,97,116,32,99,111,100,101,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,111,114,109,97,116,95,99,111,100,101,40,118,97,108,44,32,99,111,100,101,44,32,102,119,44,32,112,114,101,99,95,111,114,95,110,117,108,108,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,102,108,97,103,115,32,61,32,99,111,100,101,46,99,102,108,97,103,115,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,112,112,114,101,99,32,61,32,105,102,32,112,114,101,99,95,111,114,95,110,117,108,108,32,33,61,32,110,117,108,108,32,116,104,101,110,32,112,114,101,99,95,111,114,95,110,117,108,108,32,101,108,115,101,32,54,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,105,112,114,101,99,32,61,32,105,102,32,112,114,101,99,95,111,114,95,110,117,108,108,32,33,61,32,110,117,108,108,32,116,104,101,110,32,112,114,101,99,95,111,114,95,110,117,108,108,32,101,108,115,101,32,48,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,112,32,61,32,105,102,32,99,102,108,97,103,115,46,122,101,114,111,32,38,38,32,33,99,102,108,97,103,115,46,108,101,102,116,32,116,104,101,110,32,102,119,32,101,108,115,101,32,48,59,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,115,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,116,111,83,116,114,105,110,103,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,100,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,105,110,116,40,118,97,108,44,32,122,112,44,32,105,112,114,101,99,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,32,99,102,108,97,103,115,46,115,105,103,110,44,32,49,48,44,32,34,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,111,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,122,101,114,111,95,112,114,101,102,105,120,32,61,32,105,102,32,99,102,108,97,103,115,46,97,108,116,32,116,104,101,110,32,34,48,34,32,101,108,115,101,32,34,34,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,105,110,116,40,118,97,108,44,32,122,112,44,32,105,112,114,101,99,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,32,99,102,108,97,103,115,46,115,105,103,110,44,32,56,44,32,122,101,114,111,95,112,114,101,102,105,120,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,120,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,104,101,120,40,118,97,108,44,32,122,112,44,32,105,112,114,101,99,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,32,99,102,108,97,103,115,46,115,105,103,110,44,32,99,102,108,97,103,115,46,97,108,116,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,100,101,46,99,97,112,115,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,102,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,102,108,111,97,116,95,100,101,99,40,118,97,108,44,32,122,112,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,102,108,97,103,115,46,115,105,103,110,44,32,99,102,108,97,103,115,46,97,108,116,44,32,116,114,117,101,44,32,102,112,112,114,101,99,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,101,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,102,108,111,97,116,95,115,99,105,40,118,97,108,44,32,122,112,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,102,108,97,103,115,46,115,105,103,110,44,32,99,102,108,97,103,115,46,97,108,116,44,32,116,114,117,101,44,32,99,111,100,101,46,99,97,112,115,44,32,102,112,112,114,101,99,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,70,111,114,109,97,116,32,114,101,113,117,105,114,101,100,32,110,117,109,98,101,114,32,97,116,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,105,32,43,32,34,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,101,120,112,111,110,101,110,116,32,61,32,115,116,100,46,102,108,111,111,114,40,115,116,100,46,108,111,103,40,115,116,100,46,97,98,115,40,118,97,108,41,41,32,47,32,115,116,100,46,108,111,103,40,49,48,41,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,101,120,112,111,110,101,110,116,32,60,32,45,52,32,124,124,32,101,120,112,111,110,101,110,116,32,62,61,32,102,112,112,114,101,99,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,102,108,111,97,116,95,115,99,105,40,118,97,108,44,32,122,112,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,32,99,102,108,97,103,115,46,115,105,103,110,44,32,99,102,108,97,103,115,46,97,108,116,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,102,108,97,103,115,46,97,108,116,44,32,99,111,100,101,46,99,97,112,115,44,32,102,112,112,114,101,99,32,45,32,49,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,100,105,103,105,116,115,95,98,101,102,111,114,101,95,112,116,32,61,32,115,116,100,46,109,97,120,40,49,44,32,101,120,112,111,110,101,110,116,32,43,32,49,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,101,110,100,101,114,95,102,108,111,97,116,95,100,101,99,40,118,97,108,44,32,122,112,44,32,99,102,108,97,103,115,46,98,108,97,110,107,44,32,99,102,108,97,103,115,46,115,105,103,110,44,32,99,102,108,97,103,115,46,97,108,116,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,102,108,97,103,115,46,97,108,116,44,32,102,112,112,114,101,99,32,45,32,100,105,103,105,116,115,95,98,101,102,111,114,101,95,112,116,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,99,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,61,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,99,104,97,114,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,118,97,108,41,32,61,61,32,49,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,118,97,108,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,37,99,32,101,120,112,101,99,116,101,100,32,49,45,115,105,122,101,100,32,115,116,114,105,110,103,32,103,111,116,58,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,37,99,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,32,47,32,115,116,114,105,110,103,44,32,103,111,116,58,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,85,110,107,110,111,119,110,32,99,111,100,101,58,32,34,32,43,32,99,111,100,101,46,99,116,121,112,101,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,97,32,112,97,114,115,101,100,32,102,111,114,109,97,116,32,115,116,114,105,110,103,32,119,105,116,104,32,97,110,32,97,114,114,97,121,32,111,102,32,118,97,108,117,101,115,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,111,114,109,97,116,95,99,111,100,101,115,95,97,114,114,40,99,111,100,101,115,44,32,97,114,114,44,32,105,44,32,106,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,99,111,100,101,115,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,106,32,60,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,84,111,111,32,109,97,110,121,32,118,97,108,117,101,115,32,116,111,32,102,111,114,109,97,116,58,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,43,32,34,44,32,101,120,112,101,99,116,101,100,32,34,32,43,32,106,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,118,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,100,101,32,61,32,99,111,100,101,115,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,99,111,100,101,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,97,114,114,40,99,111,100,101,115,44,32,97,114,114,44,32,105,32,43,32,49,44,32,106,44,32,118,32,43,32,99,111,100,101,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,109,112,32,61,32,105,102,32,99,111,100,101,46,102,119,32,61,61,32,34,42,34,32,116,104,101,110,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,58,32,106,32,43,32,49,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,119,58,32,105,102,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,78,111,116,32,101,110,111,117,103,104,32,118,97,108,117,101,115,32,116,111,32,102,111,114,109,97,116,58,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,114,114,91,106,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,32,101,108,115,101,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,58,32,106,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,119,58,32,99,111,100,101,46,102,119,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,109,112,50,32,61,32,105,102,32,99,111,100,101,46,112,114,101,99,32,61,61,32,34,42,34,32,116,104,101,110,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,58,32,116,109,112,46,106,32,43,32,49,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,114,101,99,58,32,105,102,32,116,109,112,46,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,78,111,116,32,101,110,111,117,103,104,32,118,97,108,117,101,115,32,116,111,32,102,111,114,109,97,116,58,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,114,114,91,116,109,112,46,106,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,32,101,108,115,101,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,58,32,116,109,112,46,106,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,114,101,99,58,32,99,111,100,101,46,112,114,101,99,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,125,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,106,50,32,61,32,116,109,112,50,46,106,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,118,97,108,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,106,50,32,60,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,114,114,91,106,50,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,78,111,116,32,101,110,111,117,103,104,32,118,97,108,117,101,115,32,116,111,32,102,111,114,109,97,116,44,32,103,111,116,32,34,32,43,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,37,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,37,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,40,118,97,108,44,32,99,111,100,101,44,32,116,109,112,46,102,119,44,32,116,109,112,50,46,112,114,101,99,44,32,106,50,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,95,112,97,100,100,101,100,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,102,108,97,103,115,46,108,101,102,116,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,100,95,114,105,103,104,116,40,115,44,32,116,109,112,46,102,119,44,32,34,32,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,100,95,108,101,102,116,40,115,44,32,116,109,112,46,102,119,44,32,34,32,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,106,51,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,37,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,50,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,106,50,32,43,32,49,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,97,114,114,40,99,111,100,101,115,44,32,97,114,114,44,32,105,32,43,32,49,44,32,106,51,44,32,118,32,43,32,115,95,112,97,100,100,101,100,41,32,116,97,105,108,115,116,114,105,99,116,59,10,10,32,32,32,32,32,32,32,32,47,47,32,82,101,110,100,101,114,32,97,32,112,97,114,115,101,100,32,102,111,114,109,97,116,32,115,116,114,105,110,103,32,119,105,116,104,32,97,110,32,111,98,106,101,99,116,32,111,102,32,118,97,108,117,101,115,46,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,111,114,109,97,116,95,99,111,100,101,115,95,111,98,106,40,99,111,100,101,115,44,32,111,98,106,44,32,105,44,32,118,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,99,111,100,101,115,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,118,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,111,100,101,32,61,32,99,111,100,101,115,91,105,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,99,111,100,101,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,111,98,106,40,99,111,100,101,115,44,32,111,98,106,44,32,105,32,43,32,49,44,32,118,32,43,32,99,111,100,101,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,109,107,101,121,32,61,61,32,110,117,108,108,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,77,97,112,112,105,110,103,32,107,101,121,115,32,114,101,113,117,105,114,101,100,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,100,101,46,109,107,101,121,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,119,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,102,119,32,61,61,32,34,42,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,67,97,110,110,111,116,32,117,115,101,32,42,32,102,105,101,108,100,32,119,105,100,116,104,32,119,105,116,104,32,111,98,106,101,99,116,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,100,101,46,102,119,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,114,101,99,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,112,114,101,99,32,61,61,32,34,42,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,67,97,110,110,111,116,32,117,115,101,32,42,32,112,114,101,99,105,115,105,111,110,32,119,105,116,104,32,111,98,106,101,99,116,46,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,111,100,101,46,112,114,101,99,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,118,97,108,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,111,98,106,101,99,116,72,97,115,65,108,108,40,111,98,106,44,32,102,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,111,98,106,91,102,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,78,111,32,115,117,99,104,32,102,105,101,108,100,58,32,34,32,43,32,102,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,116,121,112,101,32,61,61,32,34,37,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,37,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,40,118,97,108,44,32,99,111,100,101,44,32,102,119,44,32,112,114,101,99,44,32,102,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,95,112,97,100,100,101,100,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,111,100,101,46,99,102,108,97,103,115,46,108,101,102,116,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,100,95,114,105,103,104,116,40,115,44,32,102,119,44,32,34,32,34,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,112,97,100,95,108,101,102,116,40,115,44,32,102,119,44,32,34,32,34,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,111,98,106,40,99,111,100,101,115,44,32,111,98,106,44,32,105,32,43,32,49,44,32,118,32,43,32,115,95,112,97,100,100,101,100,41,32,116,97,105,108,115,116,114,105,99,116,59,10,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,115,41,32,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,97,114,114,40,99,111,100,101,115,44,32,118,97,108,115,44,32,48,44,32,48,44,32,34,34,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,115,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,111,98,106,40,99,111,100,101,115,44,32,118,97,108,115,44,32,48,44,32,34,34,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,109,97,116,95,99,111,100,101,115,95,97,114,114,40,99,111,100,101,115,44,32,91,118,97,108,115,93,44,32,48,44,32,48,44,32,34,34,41,44,10,10,32,32,32,32,102,111,108,100,114,40,102,117,110,99,44,32,97,114,114,44,32,105,110,105,116,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,114,117,110,110,105,110,103,44,32,105,100,120,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,100,120,32,60,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,117,110,110,105,110,103,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,102,117,110,99,40,97,114,114,91,105,100,120,93,44,32,114,117,110,110,105,110,103,41,44,32,105,100,120,32,45,32,49,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,105,110,105,116,44,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,45,32,49,41,44,10,10,32,32,32,32,102,111,108,100,108,40,102,117,110,99,44,32,97,114,114,44,32,105,110,105,116,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,114,117,110,110,105,110,103,44,32,105,100,120,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,100,120,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,117,110,110,105,110,103,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,102,117,110,99,40,114,117,110,110,105,110,103,44,32,97,114,114,91,105,100,120,93,41,44,32,105,100,120,32,43,32,49,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,97,117,120,40,102,117,110,99,44,32,97,114,114,44,32,105,110,105,116,44,32,48,41,44,10,10,10,32,32,32,32,102,105,108,116,101,114,77,97,112,40,102,105,108,116,101,114,95,102,117,110,99,44,32,109,97,112,95,102,117,110,99,44,32,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,102,105,108,116,101,114,95,102,117,110,99,41,32,33,61,32,34,102,117,110,99,116,105,111,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,102,105,108,116,101,114,77,97,112,32,102,105,114,115,116,32,112,97,114,97,109,32,109,117,115,116,32,98,101,32,102,117,110,99,116,105,111,110,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,102,105,108,116,101,114,95,102,117,110,99,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,109,97,112,95,102,117,110,99,41,32,33,61,32,34,102,117,110,99,116,105,111,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,102,105,108,116,101,114,77,97,112,32,115,101,99,111,110,100,32,112,97,114,97,109,32,109,117,115,116,32,98,101,32,102,117,110,99,116,105,111,110,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,109,97,112,95,102,117,110,99,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,97,114,114,41,32,33,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,40,34,115,116,100,46,102,105,108,116,101,114,77,97,112,32,116,104,105,114,100,32,112,97,114,97,109,32,109,117,115,116,32,98,101,32,97,114,114,97,121,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,114,114,41,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,97,112,40,109,97,112,95,102,117,110,99,44,32,115,116,100,46,102,105,108,116,101,114,40,102,105,108,116,101,114,95,102,117,110,99,44,32,97,114,114,41,41,44,10,10,32,32,32,32,97,115,115,101,114,116,69,113,117,97,108,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,97,32,61,61,32,98,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,116,114,117,101,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,65,115,115,101,114,116,105,111,110,32,102,97,105,108,101,100,46,32,34,32,43,32,97,32,43,32,34,32,33,61,32,34,32,43,32,98,44,10,10,32,32,32,32,97,98,115,40,110,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,110,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,97,98,115,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,110,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,110,32,62,32,48,32,116,104,101,110,32,110,32,101,108,115,101,32,45,110,44,10,10,32,32,32,32,109,97,120,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,97,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,109,97,120,32,102,105,114,115,116,32,112,97,114,97,109,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,98,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,109,97,120,32,115,101,99,111,110,100,32,112,97,114,97,109,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,98,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,97,32,62,32,98,32,116,104,101,110,32,97,32,101,108,115,101,32,98,44,10,10,32,32,32,32,109,105,110,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,97,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,109,97,120,32,102,105,114,115,116,32,112,97,114,97,109,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,97,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,98,41,32,33,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,115,116,100,46,109,97,120,32,115,101,99,111,110,100,32,112,97,114,97,109,32,101,120,112,101,99,116,101,100,32,110,117,109,98,101,114,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,98,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,97,32,60,32,98,32,116,104,101,110,32,97,32,101,108,115,101,32,98,44,10,10,32,32,32,32,102,108,97,116,116,101,110,65,114,114,97,121,115,40,97,114,114,115,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,102,111,108,100,108,40,102,117,110,99,116,105,111,110,40,97,44,32,98,41,32,97,32,43,32,98,44,32,97,114,114,115,44,32,91,93,41,44,10,10,32,32,32,32,109,97,110,105,102,101,115,116,73,110,105,40,105,110,105,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,98,111,100,121,95,108,105,110,101,115,40,98,111,100,121,41,32,61,32,91,34,37,115,32,61,32,37,115,34,32,37,32,91,107,44,32,98,111,100,121,91,107,93,93,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,98,111,100,121,41,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,101,99,116,105,111,110,95,108,105,110,101,115,40,115,110,97,109,101,44,32,115,98,111,100,121,41,32,61,32,91,34,91,37,115,93,34,32,37,32,91,115,110,97,109,101,93,93,32,43,32,98,111,100,121,95,108,105,110,101,115,40,115,98,111,100,121,41,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,109,97,105,110,95,98,111,100,121,32,61,32,105,102,32,115,116,100,46,111,98,106,101,99,116,72,97,115,40,105,110,105,44,32,34,109,97,105,110,34,41,32,116,104,101,110,32,98,111,100,121,95,108,105,110,101,115,40,105,110,105,46,109,97,105,110,41,32,101,108,115,101,32,91,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,108,108,95,115,101,99,116,105,111,110,115,32,61,32,91,115,101,99,116,105,111,110,95,108,105,110,101,115,40,107,44,32,105,110,105,46,115,101,99,116,105,111,110,115,91,107,93,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,105,110,105,46,115,101,99,116,105,111,110,115,41,93,59,10,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,92,110,34,44,32,109,97,105,110,95,98,111,100,121,32,43,32,115,116,100,46,102,108,97,116,116,101,110,65,114,114,97,121,115,40,97,108,108,95,115,101,99,116,105,111,110,115,41,32,43,32,91,34,34,93,41,44,10,10,32,32,32,32,101,115,99,97,112,101,83,116,114,105,110,103,74,115,111,110,40,115,116,114,95,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,32,115,116,100,46,116,111,83,116,114,105,110,103,40,115,116,114,95,41,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,97,110,115,40,99,104,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,104,32,61,61,32,34,92,34,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,92,34,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,92,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,92,92,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,98,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,98,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,102,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,102,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,110,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,114,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,99,104,32,61,61,32,34,92,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,116,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,99,112,32,61,32,115,116,100,46,99,111,100,101,112,111,105,110,116,40,99,104,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,112,32,60,32,51,50,32,124,124,32,40,99,112,32,62,61,32,49,50,54,32,38,38,32,99,112,32,60,61,32,49,53,57,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,92,92,117,37,48,52,120,34,32,37,32,91,99,112,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,104,59,10,32,32,32,32,32,32,32,32,34,92,34,37,115,92,34,34,32,37,32,115,116,100,46,106,111,105,110,40,34,34,44,32,91,116,114,97,110,115,40,99,104,41,32,102,111,114,32,99,104,32,105,110,32,115,116,100,46,115,116,114,105,110,103,67,104,97,114,115,40,115,116,114,41,93,41,44,10,10,32,32,32,32,101,115,99,97,112,101,83,116,114,105,110,103,80,121,116,104,111,110,40,115,116,114,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,101,115,99,97,112,101,83,116,114,105,110,103,74,115,111,110,40,115,116,114,41,44,10,10,32,32,32,32,101,115,99,97,112,101,83,116,114,105,110,103,66,97,115,104,40,115,116,114,95,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,32,115,116,100,46,116,111,83,116,114,105,110,103,40,115,116,114,95,41,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,97,110,115,40,99,104,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,104,32,61,61,32,34,39,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,39,92,34,39,92,34,39,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,104,59,10,32,32,32,32,32,32,32,32,34,39,37,115,39,34,32,37,32,115,116,100,46,106,111,105,110,40,34,34,44,32,91,116,114,97,110,115,40,99,104,41,32,102,111,114,32,99,104,32,105,110,32,115,116,100,46,115,116,114,105,110,103,67,104,97,114,115,40,115,116,114,41,93,41,44,10,10,32,32,32,32,101,115,99,97,112,101,83,116,114,105,110,103,68,111,108,108,97,114,115,40,115,116,114,95,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,32,115,116,100,46,116,111,83,116,114,105,110,103,40,115,116,114,95,41,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,114,97,110,115,40,99,104,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,99,104,32,61,61,32,34,36,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,36,36,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,99,104,59,10,32,32,32,32,32,32,32,32,115,116,100,46,102,111,108,100,108,40,102,117,110,99,116,105,111,110,40,97,44,32,98,41,32,97,32,43,32,116,114,97,110,115,40,98,41,44,32,115,116,100,46,115,116,114,105,110,103,67,104,97,114,115,40,115,116,114,41,44,32,34,34,41,44,10,10,32,32,32,32,109,97,110,105,102,101,115,116,74,115,111,110,40,118,97,108,117,101,41,58,58,32,115,116,100,46,109,97,110,105,102,101,115,116,74,115,111,110,69,120,40,118,97,108,117,101,44,32,34,32,32,32,32,34,41,44,10,10,32,32,32,32,109,97,110,105,102,101,115,116,74,115,111,110,69,120,40,118,97,108,117,101,44,32,105,110,100,101,110,116,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,118,44,32,112,97,116,104,44,32,99,105,110,100,101,110,116,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,118,32,61,61,32,116,114,117,101,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,116,114,117,101,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,118,32,61,61,32,102,97,108,115,101,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,102,97,108,115,101,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,118,32,61,61,32,110,117,108,108,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,110,117,108,108,34,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,41,32,61,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,34,32,43,32,118,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,101,115,99,97,112,101,83,116,114,105,110,103,74,115,111,110,40,118,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,41,32,61,61,32,34,102,117,110,99,116,105,111,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,84,114,105,101,100,32,116,111,32,109,97,110,105,102,101,115,116,32,102,117,110,99,116,105,111,110,32,97,116,32,34,32,43,32,112,97,116,104,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,41,32,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,97,110,103,101,32,61,32,115,116,100,46,114,97,110,103,101,40,48,44,32,115,116,100,46,108,101,110,103,116,104,40,118,41,32,45,32,49,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,101,119,95,105,110,100,101,110,116,32,61,32,99,105,110,100,101,110,116,32,43,32,105,110,100,101,110,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,105,110,101,115,32,61,32,91,34,91,92,110,34,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,115,116,100,46,106,111,105,110,40,91,34,44,92,110,34,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,91,91,110,101,119,95,105,110,100,101,110,116,32,43,32,97,117,120,40,118,91,105,93,44,32,112,97,116,104,32,43,32,91,105,93,44,32,110,101,119,95,105,110,100,101,110,116,41,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,105,32,105,110,32,114,97,110,103,101,93,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,91,34,92,110,34,32,43,32,99,105,110,100,101,110,116,32,43,32,34,93,34,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,34,44,32,108,105,110,101,115,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,118,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,105,110,101,115,32,61,32,91,34,123,92,110,34,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,115,116,100,46,106,111,105,110,40,91,34,44,92,110,34,93,44,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,91,91,99,105,110,100,101,110,116,32,43,32,105,110,100,101,110,116,32,43,32,34,92,34,34,32,43,32,107,32,43,32,34,92,34,58,32,34,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,97,117,120,40,118,91,107,93,44,32,112,97,116,104,32,43,32,91,107,93,44,32,99,105,110,100,101,110,116,32,43,32,105,110,100,101,110,116,41,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,118,41,93,41,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,43,32,91,34,92,110,34,32,43,32,99,105,110,100,101,110,116,32,43,32,34,125,34,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,34,44,32,108,105,110,101,115,41,59,10,32,32,32,32,32,32,32,32,97,117,120,40,118,97,108,117,101,44,32,91,93,44,32,34,34,41,44,10,10,32,32,32,32,109,97,110,105,102,101,115,116,89,97,109,108,83,116,114,101,97,109,40,118,97,108,117,101,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,118,97,108,117,101,41,32,33,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,109,97,110,105,102,101,115,116,89,97,109,108,83,116,114,101,97,109,32,111,110,108,121,32,116,97,107,101,115,32,97,114,114,97,121,115,44,32,103,111,116,32,34,32,43,32,115,116,100,46,116,121,112,101,40,118,97,108,117,101,41,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,34,45,45,45,92,110,34,32,43,32,115,116,100,46,106,111,105,110,40,34,92,110,45,45,45,92,110,34,44,32,91,115,116,100,46,109,97,110,105,102,101,115,116,74,115,111,110,40,101,41,32,102,111,114,32,101,32,105,110,32,118,97,108,117,101,93,41,32,43,32,39,92,110,46,46,46,92,110,39,44,10,10,10,32,32,32,32,109,97,110,105,102,101,115,116,80,121,116,104,111,110,40,111,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,111,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,105,101,108,100,115,32,61,32,91,34,37,115,58,32,37,115,34,32,37,32,91,115,116,100,46,101,115,99,97,112,101,83,116,114,105,110,103,80,121,116,104,111,110,40,107,41,44,32,115,116,100,46,109,97,110,105,102,101,115,116,80,121,116,104,111,110,40,111,91,107,93,41,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,111,41,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,34,123,37,115,125,34,32,37,32,91,115,116,100,46,106,111,105,110,40,34,44,32,34,44,32,102,105,101,108,100,115,41,93,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,111,41,32,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,34,91,37,115,93,34,32,37,32,91,115,116,100,46,106,111,105,110,40,34,44,32,34,44,32,91,115,116,100,46,109,97,110,105,102,101,115,116,80,121,116,104,111,110,40,111,50,41,32,102,111,114,32,111,50,32,105,110,32,111,93,41,93,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,111,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,34,37,115,34,32,37,32,91,115,116,100,46,101,115,99,97,112,101,83,116,114,105,110,103,80,121,116,104,111,110,40,111,41,93,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,111,41,32,61,61,32,34,102,117,110,99,116,105,111,110,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,99,97,110,110,111,116,32,109,97,110,105,102,101,115,116,32,102,117,110,99,116,105,111,110,34,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,116,121,112,101,40,111,41,32,61,61,32,34,110,117,109,98,101,114,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,116,111,83,116,114,105,110,103,40,111,41,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,111,32,61,61,32,116,114,117,101,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,34,84,114,117,101,34,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,111,32,61,61,32,102,97,108,115,101,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,34,70,97,108,115,101,34,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,111,32,61,61,32,110,117,108,108,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,34,78,111,110,101,34,44,10,10,32,32,32,32,109,97,110,105,102,101,115,116,80,121,116,104,111,110,86,97,114,115,40,99,111,110,102,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,118,97,114,115,32,61,32,91,34,37,115,32,61,32,37,115,34,32,37,32,91,107,44,32,115,116,100,46,109,97,110,105,102,101,115,116,80,121,116,104,111,110,40,99,111,110,102,91,107,93,41,93,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,99,111,110,102,41,93,59,10,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,92,110,34,44,32,118,97,114,115,32,43,32,91,34,34,93,41,44,10,10,10,32,32,32,32,108,111,99,97,108,32,98,97,115,101,54,52,95,116,97,98,108,101,32,61,32,34,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,48,49,50,51,52,53,54,55,56,57,43,47,34,44,10,32,32,32,32,108,111,99,97,108,32,98,97,115,101,54,52,95,105,110,118,32,61,32,123,32,91,98,97,115,101,54,52,95,116,97,98,108,101,91,105,93,93,58,32,105,32,102,111,114,32,105,32,105,110,32,115,116,100,46,114,97,110,103,101,40,48,44,32,54,51,41,32,125,44,10,10,32,32,32,32,98,97,115,101,54,52,40,105,110,112,117,116,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,98,121,116,101,115,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,105,110,112,117,116,41,32,61,61,32,34,115,116,114,105,110,103,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,97,112,40,102,117,110,99,116,105,111,110,40,99,41,32,115,116,100,46,99,111,100,101,112,111,105,110,116,40,99,41,44,32,105,110,112,117,116,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,110,112,117,116,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,114,114,44,32,105,44,32,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,105,32,43,32,49,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,54,32,77,83,66,32,111,102,32,105,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,50,53,50,41,32,62,62,32,50,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,50,32,76,83,66,32,111,102,32,105,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,51,41,32,60,60,32,52,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,61,61,34,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,51,44,32,114,32,43,32,115,116,114,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,105,32,43,32,50,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,54,32,77,83,66,32,111,102,32,105,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,50,53,50,41,32,62,62,32,50,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,50,32,76,83,66,32,111,102,32,105,44,32,52,32,77,83,66,32,111,102,32,105,43,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,51,41,32,60,60,32,52,32,124,32,40,97,114,114,91,105,32,43,32,49,93,32,38,32,50,52,48,41,32,62,62,32,52,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,52,32,76,83,66,32,111,102,32,105,43,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,32,43,32,49,93,32,38,32,49,53,41,32,60,60,32,50,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,34,61,34,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,51,44,32,114,32,43,32,115,116,114,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,116,114,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,54,32,77,83,66,32,111,102,32,105,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,50,53,50,41,32,62,62,32,50,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,50,32,76,83,66,32,111,102,32,105,44,32,52,32,77,83,66,32,111,102,32,105,43,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,93,32,38,32,51,41,32,60,60,32,52,32,124,32,40,97,114,114,91,105,32,43,32,49,93,32,38,32,50,52,48,41,32,62,62,32,52,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,52,32,76,83,66,32,111,102,32,105,43,49,44,32,50,32,77,83,66,32,111,102,32,105,43,50,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,32,43,32,49,93,32,38,32,49,53,41,32,60,60,32,50,32,124,32,40,97,114,114,91,105,32,43,32,50,93,32,38,32,49,57,50,41,32,62,62,32,54,93,32,43,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,54,32,76,83,66,32,111,102,32,105,43,50,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,98,97,115,101,54,52,95,116,97,98,108,101,91,40,97,114,114,91,105,32,43,32,50,93,32,38,32,54,51,41,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,114,114,44,32,105,32,43,32,51,44,32,114,32,43,32,115,116,114,41,32,116,97,105,108,115,116,114,105,99,116,59,10,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,115,97,110,105,116,121,32,61,32,115,116,100,46,102,111,108,100,108,40,102,117,110,99,116,105,111,110,40,114,44,32,97,41,32,114,32,38,38,32,40,97,32,60,32,50,53,54,41,44,32,98,121,116,101,115,44,32,116,114,117,101,41,59,10,32,32,32,32,32,32,32,32,105,102,32,33,115,97,110,105,116,121,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,67,97,110,32,111,110,108,121,32,98,97,115,101,54,52,32,101,110,99,111,100,101,32,115,116,114,105,110,103,115,32,47,32,97,114,114,97,121,115,32,111,102,32,115,105,110,103,108,101,32,98,121,116,101,115,46,34,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,98,121,116,101,115,44,32,48,44,32,34,34,41,44,10,10,10,32,32,32,32,98,97,115,101,54,52,68,101,99,111,100,101,66,121,116,101,115,40,115,116,114,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,37,32,52,32,33,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,101,114,114,111,114,32,34,78,111,116,32,97,32,98,97,115,101,54,52,32,101,110,99,111,100,101,100,32,115,116,114,105,110,103,32,92,34,37,115,92,34,34,32,37,32,115,116,114,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,115,116,114,44,32,105,44,32,114,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,115,116,114,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,114,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,97,108,108,32,54,32,98,105,116,115,32,111,102,32,105,44,32,50,32,77,83,66,32,111,102,32,105,43,49,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,49,32,61,32,91,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,93,93,32,60,60,32,50,32,124,32,40,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,32,43,32,49,93,93,32,62,62,32,52,41,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,52,32,76,83,66,32,111,102,32,105,43,49,44,32,52,77,83,66,32,111,102,32,105,43,50,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,50,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,114,91,105,32,43,32,50,93,32,61,61,32,34,61,34,32,116,104,101,110,32,91,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,91,40,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,32,43,32,49,93,93,32,38,32,49,53,41,32,60,60,32,52,32,124,32,40,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,32,43,32,50,93,93,32,62,62,32,50,41,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,47,47,32,50,32,76,83,66,32,111,102,32,105,43,50,44,32,97,108,108,32,54,32,98,105,116,115,32,111,102,32,105,43,51,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,51,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,114,91,105,32,43,32,51,93,32,61,61,32,34,61,34,32,116,104,101,110,32,91,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,91,40,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,32,43,32,50,93,93,32,38,32,51,41,32,60,60,32,54,32,124,32,98,97,115,101,54,52,95,105,110,118,91,115,116,114,91,105,32,43,32,51,93,93,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,105,32,43,32,52,44,32,114,32,43,32,110,49,32,43,32,110,50,32,43,32,110,51,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,115,116,114,44,32,48,44,32,91,93,41,44,10,10,32,32,32,32,98,97,115,101,54,52,68,101,99,111,100,101,40,115,116,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,98,121,116,101,115,32,61,32,115,116,100,46,98,97,115,101,54,52,68,101,99,111,100,101,66,121,116,101,115,40,115,116,114,41,59,10,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,34,44,32,115,116,100,46,109,97,112,40,102,117,110,99,116,105,111,110,40,98,41,32,115,116,100,46,99,104,97,114,40,98,41,44,32,98,121,116,101,115,41,41,44,10,10,32,32,32,32,47,47,32,81,117,105,99,107,115,111,114,116,10,32,32,32,32,115,111,114,116,40,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,32,61,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,59,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,91,93,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,112,105,118,111,116,32,61,32,97,114,114,91,48,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,101,115,116,32,61,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,108,32,45,32,49,44,32,102,117,110,99,116,105,111,110,40,105,41,32,97,114,114,91,105,32,43,32,49,93,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,101,102,116,32,61,32,115,116,100,46,102,105,108,116,101,114,40,102,117,110,99,116,105,111,110,40,120,41,32,120,32,60,61,32,112,105,118,111,116,44,32,114,101,115,116,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,114,105,103,104,116,32,61,32,115,116,100,46,102,105,108,116,101,114,40,102,117,110,99,116,105,111,110,40,120,41,32,120,32,62,32,112,105,118,111,116,44,32,114,101,115,116,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,115,111,114,116,40,108,101,102,116,41,32,43,32,91,112,105,118,111,116,93,32,43,32,115,116,100,46,115,111,114,116,40,114,105,103,104,116,41,44,10,10,32,32,32,32,117,110,105,113,40,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,40,97,44,32,98,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,61,61,32,48,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,91,98,93,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,97,91,115,116,100,46,108,101,110,103,116,104,40,97,41,32,45,32,49,93,32,61,61,32,98,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,32,43,32,91,98,93,59,10,32,32,32,32,32,32,32,32,115,116,100,46,102,111,108,100,108,40,102,44,32,97,114,114,44,32,91,93,41,44,10,10,32,32,32,32,115,101,116,40,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,117,110,105,113,40,115,116,100,46,115,111,114,116,40,97,114,114,41,41,44,10,10,32,32,32,32,115,101,116,77,101,109,98,101,114,40,120,44,32,97,114,114,41,58,58,10,32,32,32,32,32,32,32,32,47,47,32,84,79,68,79,40,100,99,117,110,110,105,110,41,58,32,66,105,110,97,114,121,32,99,104,111,112,32,102,111,114,32,79,40,108,111,103,32,110,41,32,99,111,109,112,108,101,120,105,116,121,10,32,32,32,32,32,32,32,32,115,116,100,46,108,101,110,103,116,104,40,115,116,100,46,115,101,116,73,110,116,101,114,40,91,120,93,44,32,97,114,114,41,41,32,62,32,48,44,10,10,32,32,32,32,115,101,116,85,110,105,111,110,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,115,101,116,40,97,32,43,32,98,41,44,10,10,32,32,32,32,115,101,116,73,110,116,101,114,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,44,32,98,44,32,105,44,32,106,44,32,97,99,99,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,124,124,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,99,99,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,97,91,105,93,32,61,61,32,98,91,106,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,44,32,106,32,43,32,49,44,32,97,99,99,32,43,32,91,97,91,105,93,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,97,91,105,93,32,60,32,98,91,106,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,44,32,106,44,32,97,99,99,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,44,32,106,32,43,32,49,44,32,97,99,99,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,48,44,32,48,44,32,91,93,41,32,116,97,105,108,115,116,114,105,99,116,44,10,10,32,32,32,32,115,101,116,68,105,102,102,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,44,32,98,44,32,105,44,32,106,44,32,97,99,99,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,97,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,99,99,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,106,32,62,61,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,44,32,106,44,32,97,99,99,32,43,32,91,97,91,105,93,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,97,91,105,93,32,61,61,32,98,91,106,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,44,32,106,32,43,32,49,44,32,97,99,99,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,97,91,105,93,32,60,32,98,91,106,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,44,32,106,44,32,97,99,99,32,43,32,91,97,91,105,93,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,44,32,106,32,43,32,49,44,32,97,99,99,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,48,44,32,48,44,32,91,93,41,32,116,97,105,108,115,116,114,105,99,116,44,10,10,32,32,32,32,109,101,114,103,101,80,97,116,99,104,40,116,97,114,103,101,116,44,32,112,97,116,99,104,41,58,58,10,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,112,97,116,99,104,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,97,114,103,101,116,95,111,98,106,101,99,116,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,116,97,114,103,101,116,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,32,116,97,114,103,101,116,32,101,108,115,101,32,123,125,59,10,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,97,114,103,101,116,95,102,105,101,108,100,115,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,116,121,112,101,40,116,97,114,103,101,116,95,111,98,106,101,99,116,41,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,116,97,114,103,101,116,95,111,98,106,101,99,116,41,32,101,108,115,101,32,91,93,59,10,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,110,117,108,108,95,102,105,101,108,100,115,32,61,32,91,107,32,102,111,114,32,107,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,112,97,116,99,104,41,32,105,102,32,112,97,116,99,104,91,107,93,32,61,61,32,110,117,108,108,93,59,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,98,111,116,104,95,102,105,101,108,100,115,32,61,32,115,116,100,46,115,101,116,85,110,105,111,110,40,116,97,114,103,101,116,95,102,105,101,108,100,115,44,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,112,97,116,99,104,41,41,59,10,10,32,32,32,32,32,32,32,32,32,32,32,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,91,107,93,58,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,33,115,116,100,46,111,98,106,101,99,116,72,97,115,40,112,97,116,99,104,44,32,107,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,97,114,103,101,116,95,111,98,106,101,99,116,91,107,93,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,33,115,116,100,46,111,98,106,101,99,116,72,97,115,40,116,97,114,103,101,116,95,111,98,106,101,99,116,44,32,107,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,101,114,103,101,80,97,116,99,104,40,110,117,108,108,44,32,112,97,116,99,104,91,107,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,109,101,114,103,101,80,97,116,99,104,40,116,97,114,103,101,116,95,111,98,106,101,99,116,91,107,93,44,32,112,97,116,99,104,91,107,93,41,32,116,97,105,108,115,116,114,105,99,116,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,107,32,105,110,32,115,116,100,46,115,101,116,68,105,102,102,40,98,111,116,104,95,102,105,101,108,100,115,44,32,110,117,108,108,95,102,105,101,108,100,115,41,10,32,32,32,32,32,32,32,32,32,32,32,32,125,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,112,97,116,99,104,44,10,10,32,32,32,32,111,98,106,101,99,116,70,105,101,108,100,115,40,111,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,69,120,40,111,44,32,102,97,108,115,101,41,44,10,10,32,32,32,32,111,98,106,101,99,116,70,105,101,108,100,115,65,108,108,40,111,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,69,120,40,111,44,32,116,114,117,101,41,44,10,10,32,32,32,32,111,98,106,101,99,116,72,97,115,40,111,44,32,102,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,111,98,106,101,99,116,72,97,115,69,120,40,111,44,32,102,44,32,102,97,108,115,101,41,44,10,10,32,32,32,32,111,98,106,101,99,116,72,97,115,65,108,108,40,111,44,32,102,41,58,58,10,32,32,32,32,32,32,32,32,115,116,100,46,111,98,106,101,99,116,72,97,115,69,120,40,111,44,32,102,44,32,116,114,117,101,41,44,10,10,32,32,32,32,101,113,117,97,108,115,40,97,44,32,98,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,97,32,61,32,115,116,100,46,116,121,112,101,40,97,41,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,98,32,61,32,115,116,100,46,116,121,112,101,40,98,41,59,10,32,32,32,32,32,32,32,32,105,102,32,33,115,116,100,46,112,114,105,109,105,116,105,118,101,69,113,117,97,108,115,40,116,97,44,32,116,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,115,116,100,46,112,114,105,109,105,116,105,118,101,69,113,117,97,108,115,40,116,97,44,32,34,97,114,114,97,121,34,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,97,32,61,32,115,116,100,46,108,101,110,103,116,104,40,97,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,33,115,116,100,46,112,114,105,109,105,116,105,118,101,69,113,117,97,108,115,40,108,97,44,32,115,116,100,46,108,101,110,103,116,104,40,98,41,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,44,32,98,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,108,97,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,114,117,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,97,91,105,93,32,33,61,32,98,91,105,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,48,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,115,116,100,46,112,114,105,109,105,116,105,118,101,69,113,117,97,108,115,40,116,97,44,32,34,111,98,106,101,99,116,34,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,102,105,101,108,100,115,32,61,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,97,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,108,102,105,101,108,100,115,32,61,32,115,116,100,46,108,101,110,103,116,104,40,102,105,101,108,100,115,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,102,105,101,108,100,115,32,33,61,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,98,41,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,117,120,40,97,44,32,98,44,32,105,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,105,32,62,61,32,108,102,105,101,108,100,115,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,114,117,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,108,111,99,97,108,32,102,32,61,32,102,105,101,108,100,115,91,105,93,59,32,97,91,102,93,32,33,61,32,98,91,102,93,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,105,32,43,32,49,41,32,116,97,105,108,115,116,114,105,99,116,59,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,97,117,120,40,97,44,32,98,44,32,48,41,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,112,114,105,109,105,116,105,118,101,69,113,117,97,108,115,40,97,44,32,98,41,44,10,10,10,32,32,32,32,114,101,115,111,108,118,101,80,97,116,104,40,102,44,32,114,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,97,114,114,32,61,32,115,116,100,46,115,112,108,105,116,40,102,44,32,34,47,34,41,59,10,32,32,32,32,32,32,32,32,115,116,100,46,106,111,105,110,40,34,47,34,44,32,115,116,100,46,109,97,107,101,65,114,114,97,121,40,115,116,100,46,108,101,110,103,116,104,40,97,114,114,41,32,45,32,49,44,32,102,117,110,99,116,105,111,110,40,105,41,32,97,114,114,91,105,93,41,32,43,32,91,114,93,41,44,10,10,32,32,32,32,112,114,117,110,101,40,97,41,58,58,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,105,115,67,111,110,116,101,110,116,40,98,41,32,61,10,32,32,32,32,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,32,61,32,115,116,100,46,116,121,112,101,40,98,41,59,10,32,32,32,32,32,32,32,32,32,32,32,32,105,102,32,98,32,61,61,32,110,117,108,108,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,102,97,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,116,32,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,62,32,48,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,116,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,100,46,108,101,110,103,116,104,40,98,41,32,62,32,48,10,32,32,32,32,32,32,32,32,32,32,32,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,114,117,101,59,10,32,32,32,32,32,32,32,32,108,111,99,97,108,32,116,32,61,32,115,116,100,46,116,121,112,101,40,97,41,59,10,32,32,32,32,32,32,32,32,105,102,32,116,61,61,32,34,97,114,114,97,121,34,32,116,104,101,110,10,32,32,32,32,32,32,32,32,32,32,32,32,91,32,115,116,100,46,112,114,117,110,101,40,120,41,32,102,111,114,32,120,32,105,110,32,97,32,105,102,32,105,115,67,111,110,116,101,110,116,40,36,46,112,114,117,110,101,40,120,41,41,32,93,10,32,32,32,32,32,32,32,32,101,108,115,101,32,105,102,32,116,32,61,61,32,34,111,98,106,101,99,116,34,32,116,104,101,110,32,123,10,32,32,32,32,32,32,32,32,32,32,32,32,91,120,93,58,32,36,46,112,114,117,110,101,40,97,91,120,93,41,10,32,32,32,32,32,32,32,32,32,32,32,32,102,111,114,32,120,32,105,110,32,115,116,100,46,111,98,106,101,99,116,70,105,101,108,100,115,40,97,41,32,105,102,32,105,115,67,111,110,116,101,110,116,40,115,116,100,46,112,114,117,110,101,40,97,91,120,93,41,41,10,32,32,32,32,32,32,32,32,125,32,101,108,115,101,10,32,32,32,32,32,32,32,32,32,32,32,32,97,44,10,125,10,0
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/string_utils.cpp b/vendor/github.com/strickyak/jsonnet_cgo/string_utils.cpp
deleted file mode 100644
index da5fb6580fb7ec4261f316cbb52620a174e8ba04..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/string_utils.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <iomanip>
-
-#include "string_utils.h"
-#include "static_error.h"
-
-UString jsonnet_string_unparse(const UString &str, bool single)
-{
-    UStringStream ss;
-    ss << (single ? U'\'' : U'\"');
-    ss << jsonnet_string_escape(str, single);
-    ss << (single ? U'\'' : U'\"');
-    return ss.str();
-}
-
-UString jsonnet_string_escape(const UString &str, bool single)
-{
-    UStringStream ss;
-    for (std::size_t i=0 ; i<str.length() ; ++i) {
-        char32_t c = str[i];
-        switch (c) {
-            case U'\"': ss << (single ? U"\"" : U"\\\""); break;
-            case U'\'': ss << (single ? U"\\\'" : U"\'"); break;
-            case U'\\': ss << U"\\\\"; break;
-            case U'\b': ss << U"\\b"; break;
-            case U'\f': ss << U"\\f"; break;
-            case U'\n': ss << U"\\n"; break;
-            case U'\r': ss << U"\\r"; break;
-            case U'\t': ss << U"\\t"; break;
-            case U'\0': ss << U"\\u0000"; break;
-            default: {
-                if (c < 0x20 || (c >= 0x7f && c <= 0x9f)) {
-                    //Unprintable, use \u
-                    std::stringstream ss8;
-                    ss8 << "\\u" << std::hex << std::setfill('0') << std::setw(4)
-                       << (unsigned long)(c);
-                    ss << decode_utf8(ss8.str());
-                } else {
-                    // Printable, write verbatim
-                    ss << c;
-                }
-            }
-        }
-    }
-    return ss.str();
-}
-
-
-UString jsonnet_string_unescape(const LocationRange &loc, const UString &s)
-{
-    UString r;
-    const char32_t *s_ptr = s.c_str();
-    for (const char32_t *c = s_ptr; *c != U'\0' ; ++c) {
-        switch (*c) {
-            case '\\':
-            switch (*(++c)) {
-                case '"':
-                case '\'':
-                r += *c;
-                break;
-
-                case '\\':
-                r += *c;
-                break;
-
-                case '/':
-                r += *c;
-                break;
-
-                case 'b':
-                r += '\b';
-                break;
-
-                case 'f':
-                r += '\f';
-                break;
-
-                case 'n':
-                r += '\n';
-                break;
-
-                case 'r':
-                r += '\r';
-                break;
-
-                case 't':
-                r += '\t';
-                break;
-
-                case 'u': {
-                    ++c;  // Consume the 'u'.
-                    unsigned long codepoint = 0;
-                    // Expect 4 hex digits.
-                    for (unsigned i=0 ; i<4 ; ++i) {
-                        auto x = (unsigned char)(c[i]);
-                        unsigned digit;
-                        if (x == '\0') {
-                            auto msg = "Truncated unicode escape sequence in string literal.";
-                            throw StaticError(loc, msg);
-                        } else if (x >= '0' && x <= '9') {
-                            digit = x - '0';
-                        } else if (x >= 'a' && x <= 'f') {
-                            digit = x - 'a' + 10;
-                        } else if (x >= 'A' && x <= 'F') {
-                            digit = x - 'A' + 10;
-                        } else {
-                            std::stringstream ss;
-                            ss << "Malformed unicode escape character, "
-                               << "should be hex: '" << x << "'";
-                            throw StaticError(loc, ss.str());
-                        }
-                        codepoint *= 16;
-                        codepoint += digit;
-                    }
-
-                    r += codepoint;
-
-                    // Leave us on the last char, ready for the ++c at
-                    // the outer for loop.
-                    c += 3;
-                }
-                break;
-
-                case '\0': {
-                    auto msg = "Truncated escape sequence in string literal.";
-                    throw StaticError(loc, msg);
-                }
-
-                default: {
-                    std::stringstream ss;
-                    std::string utf8;
-                    encode_utf8(*c, utf8);
-                    ss << "Unknown escape sequence in string literal: '" << utf8 << "'";
-                    throw StaticError(loc, ss.str());
-                }
-            }
-            break;
-
-            default:
-            // Just a regular letter.
-            r += *c;
-        }
-    }
-    return r;
-}
-
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/string_utils.h b/vendor/github.com/strickyak/jsonnet_cgo/string_utils.h
deleted file mode 100644
index fd9d7731c1a1a4edf97a8e642d9e3dcde01f5f78..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/string_utils.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_STRING_H
-#define JSONNET_STRING_H
-
-#include "lexer.h"
-
-/** Unparse the string. */
-UString jsonnet_string_unparse(const UString &str, bool single);
-
-/** Escape special characters. */
-UString jsonnet_string_escape(const UString &str, bool single);
-
-/** Resolve escape chracters in the string. */
-UString jsonnet_string_unescape(const LocationRange &loc, const UString &s);
-
-#endif
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/test1.j b/vendor/github.com/strickyak/jsonnet_cgo/test1.j
deleted file mode 100644
index 6b4508aac5b0d347c0c1f45522a93f01e1dc9411..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/test1.j
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  shell: "/bin/sh",
-  awk: "/usr/bin/awk",
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/test2.j b/vendor/github.com/strickyak/jsonnet_cgo/test2.j
deleted file mode 100644
index dd1aec39d11616f302488835472e552e97e45371..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/test2.j
+++ /dev/null
@@ -1,5 +0,0 @@
-local test1 = import "test1.j";
-
-test1 {
-  shell: "/bin/csh",
-}
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/unicode.h b/vendor/github.com/strickyak/jsonnet_cgo/unicode.h
deleted file mode 100644
index f2125d1b3adbfc9d52a347a0db3e7a9e781e4ca4..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/unicode.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_UNICODE_H
-#define JSONNET_UNICODE_H
-
-/** Substituted when a unicode translation format encoding error is encountered. */
-#define JSONNET_CODEPOINT_ERROR 0xfffd
-#define JSONNET_CODEPOINT_MAX 0x110000
-
-/** Convert a unicode codepoint to UTF8.
- *
- * \param x The unicode codepoint.
- * \param s The UTF-8 string to append to.
- * \returns The number of characters appended.
- */
-static inline int encode_utf8(char32_t x, std::string &s)
-{
-    if (x >= JSONNET_CODEPOINT_MAX)
-        x = JSONNET_CODEPOINT_ERROR;
-
-    // 00ZZZzzz 00zzYYYY 00Yyyyxx 00xxxxxx
-    long bytes = ((x & 0x1C0000) << 6) | ((x & 0x03F000) << 4) | ((x & 0x0FC0) << 2) | (x & 0x3F);
-
-    if (x < 0x80) {
-        s.push_back((char)x);
-        return 1;
-    } else if (x < 0x800) { // note that capital 'Y' bits must be 0
-        bytes |= 0xC080;
-        s.push_back((bytes >> 8) & 0xFF);
-        s.push_back((bytes >> 0) & 0xFF);
-        return 2;
-    } else if (x < 0x10000) { // note that 'z' bits must be 0
-        bytes |= 0xE08080;
-        s.push_back((bytes >> 16) & 0xFF);
-        s.push_back((bytes >>  8) & 0xFF);
-        s.push_back((bytes >>  0) & 0xFF);
-        return 3;
-    } else if (x < 0x110000) { // note that capital 'Z' bits must be 0
-        bytes |= 0xF0808080;
-        s.push_back((bytes >> 24) & 0xFF);
-        s.push_back((bytes >> 16) & 0xFF);
-        s.push_back((bytes >>  8) & 0xFF);
-        s.push_back((bytes >>  0) & 0xFF);
-        return 4;
-    } else {
-        std::cerr << "Should never get here." << std::endl;
-        abort();
-    }
-}
-
-/** Convert the UTF8 byte sequence in the given string to a unicode code point.
- *
- * \param str The string. 
- * \param i The index of the string from which to start decoding and returns the index of the last
- *          byte of the encoded codepoint. 
- * \returns The decoded unicode codepoint.
- */
-static inline char32_t decode_utf8(const std::string &str, size_t &i)
-{
-    char c0 = str[i];
-    if ((c0 & 0x80) == 0) { //0xxxxxxx
-        return c0;
-    } else if ((c0 & 0xE0) == 0xC0) { //110yyyxx 10xxxxxx
-        if (i+1 >= str.length()) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c1 = str[++i];
-        if ((c1 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        return ((c0 & 0x1F) << 6ul) | (c1 & 0x3F);
-    } else if ((c0 & 0xF0) == 0xE0) { //1110yyyy 10yyyyxx 10xxxxxx
-        if (i+2 >= str.length()) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c1 = str[++i];
-        if ((c1 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c2 = str[++i];
-        if ((c2 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        return ((c0 & 0xF) << 12ul) | ((c1 & 0x3F) << 6) | (c2 & 0x3F);
-    } else if ((c0 & 0xF8) == 0xF0) { //11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
-        if (i+3 >= str.length()) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c1 = str[++i];
-        if ((c1 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c2 = str[++i];
-        if ((c2 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        char c3 = str[++i];
-        if ((c3 & 0xC0) != 0x80) {
-            return JSONNET_CODEPOINT_ERROR;
-        }
-        return ((c0 & 0x7) << 24ul) | ((c1 & 0x3F) << 12ul) | ((c2 & 0x3F) << 6) | (c3 & 0x3F);
-    } else {
-        return JSONNET_CODEPOINT_ERROR;
-    }
-}
-
-/** A string class capable of holding unicode codepoints. */
-typedef std::basic_string<char32_t> UString;
-
-  
-static inline void encode_utf8(const UString &s, std::string &r)
-{
-    for (char32_t cp : s)
-        encode_utf8(cp, r);
-}
-
-static inline std::string encode_utf8(const UString &s)
-{
-    std::string r;
-    encode_utf8(s, r);
-    return r;
-}
-
-static inline UString decode_utf8(const std::string &s)
-{
-    UString r;
-    for (size_t i = 0; i < s.length(); ++i) 
-        r.push_back(decode_utf8(s, i));
-    return r;
-}
-
-/** A stringstream-like class capable of holding unicode codepoints. 
- * The C++ standard does not support std::basic_stringstream<char32_t.
- */
-class UStringStream {
-    UString buf;
-    public:
-    UStringStream &operator << (const UString &s) { buf.append(s); return *this; }
-    UStringStream &operator << (const char32_t *s) { buf.append(s); return *this; }
-    UStringStream &operator << (char32_t c) { buf.push_back(c); return *this; }
-    template<class T> UStringStream &operator << (T c)
-    {
-        std::stringstream ss;
-        ss << c;
-        for (char c : ss.str())
-            buf.push_back(char32_t(c));
-        return *this;
-    }
-    UString str() { return buf; }
-};
-
-#endif  // JSONNET_UNICODE_H
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/vm.cpp b/vendor/github.com/strickyak/jsonnet_cgo/vm.cpp
deleted file mode 100644
index 58568df167c134d3194931de106294dd31b1f27e..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/vm.cpp
+++ /dev/null
@@ -1,2811 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <cassert>
-#include <cmath>
-
-#include <memory>
-#include <set>
-#include <string>
-
-
-#include "desugarer.h"
-#include "json.h"
-#include "md5.h"
-#include "parser.h"
-#include "state.h"
-#include "static_analysis.h"
-#include "string_utils.h"
-#include "vm.h"
-
-namespace {
-
-/** Turn a path e.g. "/a/b/c" into a dir, e.g. "/a/b/".  If there is no path returns "".
- */
-std::string dir_name(const std::string &path)
-{
-    size_t last_slash = path.rfind('/');
-    if (last_slash != std::string::npos) {
-        return path.substr(0, last_slash+1);
-    }
-    return "";
-}
-
-/** Stack frames.
- *
- * Of these, FRAME_CALL is the most special, as it is the only frame the stack
- * trace (for errors) displays.
- */
-enum FrameKind {
-    FRAME_APPLY_TARGET,  // e in e(...)
-    FRAME_BINARY_LEFT,  // a in a + b
-    FRAME_BINARY_RIGHT,  // b in a + b
-    FRAME_BUILTIN_FILTER,  // When executing std.filter, used to hold intermediate state.
-    FRAME_BUILTIN_FORCE_THUNKS,  // When forcing builtin args, holds intermediate state.
-    FRAME_CALL,  // Used any time we have switched location in user code.
-    FRAME_ERROR,  // e in error e
-    FRAME_IF,  // e in if e then a else b
-    FRAME_IN_SUPER_ELEMENT,  // e in 'e in super'
-    FRAME_INDEX_TARGET,  // e in e[x]
-    FRAME_INDEX_INDEX,  // e in x[e]
-    FRAME_INVARIANTS,  // Caches the thunks that need to be executed one at a time.
-    FRAME_LOCAL,  // Stores thunk bindings as we execute e in local ...; e
-    FRAME_OBJECT,  // Stores intermediate state as we execute es in { [e]: ..., [e]: ... }
-    FRAME_OBJECT_COMP_ARRAY,  // e in {f:a for x in e]
-    FRAME_OBJECT_COMP_ELEMENT,  // Stores intermediate state when building object
-    FRAME_STRING_CONCAT,  // Stores intermediate state while co-ercing objects
-    FRAME_SUPER_INDEX,  // e in super[e]
-    FRAME_UNARY,  // e in -e
-};
-
-/** A frame on the stack.
- *
- * Every time a subterm is evaluated, we first push a new stack frame to
- * store the continuation.
- *
- * The stack frame is a bit like a tagged union, except not as memory
- * efficient.  The set of member variables that are actually used depends on
- * the value of the member varaible kind.
- *
- * If the stack frame is of kind FRAME_CALL, then it counts towards the
- * maximum number of stack frames allowed.  Other stack frames are not
- * counted.  This is because FRAME_CALL exists where there is a branch in
- * the code, e.g. the forcing of a thunk, evaluation of a field, calling a
- * function, etc.
- *
- * The stack is used to mark objects during garbage
- * collection, so HeapObjects not referred to from the stack may be
- * prematurely collected.
- */
-struct Frame {
-
-    /** Tag (tagged union). */
-    FrameKind kind;
-
-    /** The code we were executing before. */
-    const AST *ast;
-
-    /** The location of the code we were executing before.
-     *
-     * location == ast->location when ast != nullptr
-     */
-    LocationRange location;
-
-    /** Reuse this stack frame for the purpose of tail call optimization. */
-    bool tailCall;
-
-    /** Used for a variety of purposes. */
-    Value val;
-
-    /** Used for a variety of purposes. */
-    Value val2;
-
-    /** Used for a variety of purposes. */
-    DesugaredObject::Fields::const_iterator fit;
-
-    /** Used for a variety of purposes. */
-    std::map<const Identifier *, HeapSimpleObject::Field> objectFields;
-
-    /** Used for a variety of purposes. */
-    unsigned elementId;
-
-    /** Used for a variety of purposes. */
-    std::map<const Identifier *, HeapThunk*> elements;
-
-    /** Used for a variety of purposes. */
-    std::vector<HeapThunk*> thunks;
-
-    /** The context is used in error messages to attempt to find a reasonable name for the
-     * object, function, or thunk value being executed.  If it is a thunk, it is filled
-     * with the value when the frame terminates.
-     */
-    HeapEntity *context;
-
-    /** The lexically nearest object we are in, or nullptr.  Note
-     * that this is not the same as context, because we could be inside a function,
-     * inside an object and then context would be the function, but self would still point
-     * to the object.
-     */
-    HeapObject *self;
-
-    /** The "super" level of self.  Sometimes, we look upwards in the
-     * inheritance tree, e.g. via an explicit use of super, or because a given field
-     * has been inherited.  When evaluating a field from one of these super objects,
-     * we need to bind self to the concrete object (so self must point
-     * there) but uses of super should be resolved relative to the object whose
-     * field we are evaluating.  Thus, we keep a second field for that.  This is
-     * usually 0, unless we are evaluating a super object's field.
-     */
-    unsigned offset;
-
-    /** A set of variables introduced at this point. */
-    BindingFrame bindings;
-
-    Frame(const FrameKind &kind, const AST *ast)
-      : kind(kind), ast(ast), location(ast->location), tailCall(false), elementId(0),
-        context(NULL), self(NULL), offset(0)
-    {
-        val.t = Value::NULL_TYPE;
-        val2.t = Value::NULL_TYPE;
-    }
-
-    Frame(const FrameKind &kind, const LocationRange &location)
-      : kind(kind), ast(nullptr), location(location), tailCall(false), elementId(0),
-        context(NULL), self(NULL), offset(0)
-    {
-        val.t = Value::NULL_TYPE;
-        val2.t = Value::NULL_TYPE;
-    }
-
-    /** Mark everything visible from this frame. */
-    void mark(Heap &heap) const
-    {
-        heap.markFrom(val);
-        heap.markFrom(val2);
-        if (context) heap.markFrom(context);
-        if (self) heap.markFrom(self);
-        for (const auto &bind : bindings)
-            heap.markFrom(bind.second);
-        for (const auto &el : elements)
-            heap.markFrom(el.second);
-        for (const auto &th : thunks)
-            heap.markFrom(th);
-    }
-
-    bool isCall(void) const
-    {
-        return kind == FRAME_CALL;
-    }
-
-};
-
-/** The stack holds all the stack frames and manages the stack frame limit. */
-class Stack {
-
-    /** How many call frames are on the stack. */
-    unsigned calls;
-
-    /** How many call frames should be allowed before aborting the program. */
-    unsigned limit;
-
-    /** The stack frames. */
-    std::vector<Frame> stack;
-
-    public:
-
-    Stack(unsigned limit)
-      : calls(0), limit(limit)
-    {
-    }
-
-    ~Stack(void) { }
-
-    unsigned size(void)
-    {
-        return stack.size();
-    }
-
-    /** Search for the closest variable in scope that matches the given name. */
-    HeapThunk *lookUpVar(const Identifier *id)
-    {
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
-            const auto &binds = stack[i].bindings;
-            auto it = binds.find(id);
-            if (it != binds.end()) {
-                return it->second;
-            }
-            if (stack[i].isCall()) break;
-        }
-        return nullptr;
-    }
-
-    /** Mark everything visible from the stack (any frame). */
-    void mark(Heap &heap)
-    {
-        for (const auto &f : stack) {
-            f.mark(heap);
-        }
-    }
-
-    Frame &top(void)
-    {
-        return stack.back();
-    }
-
-    const Frame &top(void) const
-    {
-        return stack.back();
-    }
-
-    void pop(void)
-    {
-        if (top().isCall()) calls--;
-        stack.pop_back();
-    }
-
-    /** Attempt to find a name for a given heap entity.  This may not be possible, but we try
-     * reasonably hard.  We look in the bindings for a variable in the closest scope that
-     * happens to point at the entity in question.  Otherwise, the best we can do is use its
-     * type.
-     */
-    std::string getName(unsigned from_here, const HeapEntity *e)
-    {
-        std::string name;
-        for (int i=from_here-1 ; i>=0; --i) {
-            const auto &f = stack[i];
-            for (const auto &pair : f.bindings) {
-                HeapThunk *thunk = pair.second;
-                if (!thunk->filled) continue;
-                if (!thunk->content.isHeap()) continue;
-                if (e != thunk->content.v.h) continue;
-                name = encode_utf8(pair.first->name);
-            }
-            // Do not go into the next call frame, keep local reasoning.
-            if (f.isCall()) break;
-        }
-
-        if (name == "") name = "anonymous";
-        if (dynamic_cast<const HeapObject*>(e)) {
-            return "object <" + name + ">";
-        } else if (auto *thunk = dynamic_cast<const HeapThunk*>(e)) {
-            if (thunk->name == nullptr) {
-                return "";  // Argument of builtin, or root (since top level functions).
-            } else {
-                return "thunk <" + encode_utf8(thunk->name->name) + ">";
-            }
-        } else {
-            const auto *func = static_cast<const HeapClosure *>(e);
-            if (func->body == nullptr) {
-                return "builtin function <" + func->builtinName + ">";
-            }
-            return "function <" + name + ">";
-        }
-    }
-
-    /** Dump the stack.
-     *
-     * This is useful to help debug the VM in gdb.  It is virtual to stop it
-     * being removed by the compiler.
-     */
-    virtual void dump(void)
-    {
-        for (unsigned i=0 ; i<stack.size() ; ++i) {
-            std::cout << "stack[" << i << "] = " << stack[i].location
-                      << " (" << stack[i].kind << ")"
-                      << std::endl;
-        }
-        std::cout << std::endl;
-    }
-
-    /** Creates the error object for throwing, and also populates it with the stack trace.
-     */
-    RuntimeError makeError(const LocationRange &loc, const std::string &msg)
-    {
-        std::vector<TraceFrame> stack_trace;
-        stack_trace.push_back(TraceFrame(loc));
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
-            const auto &f = stack[i];
-            if (f.isCall()) {
-                if (f.context != nullptr) {
-                    // Give the last line a name.
-                    stack_trace[stack_trace.size()-1].name = getName(i, f.context);
-                }
-                if (f.location.isSet() || f.location.file.length() > 0)
-                    stack_trace.push_back(TraceFrame(f.location));
-            }
-        }
-        return RuntimeError(stack_trace, msg);
-    }
-
-    /** New (non-call) frame. */
-    template <class... Args> void newFrame(Args... args)
-    {
-        stack.emplace_back(args...);
-    }
-
-    /** If there is a tailstrict annotated frame followed by some locals, pop them all. */
-    void tailCallTrimStack (void)
-    {
-        for (int i=stack.size()-1 ; i>=0 ; --i) {
-            switch (stack[i].kind) {
-                case FRAME_CALL: {
-                    if (!stack[i].tailCall || stack[i].thunks.size() > 0) {
-                        return;
-                    }
-                    // Remove all stack frames including this one.
-                    while (stack.size() > unsigned(i)) stack.pop_back();
-                    calls--;
-                    return;
-                } break;
-
-                case FRAME_LOCAL: break;
-
-                default: return;
-            }
-        }
-    }
-
-    /** New call frame. */
-    void newCall(const LocationRange &loc, HeapEntity *context, HeapObject *self,
-                 unsigned offset, const BindingFrame &up_values)
-    {
-        tailCallTrimStack();
-        if (calls >= limit) {
-            throw makeError(loc, "Max stack frames exceeded.");
-        }
-        stack.emplace_back(FRAME_CALL, loc);
-        calls++;
-        top().context = context;
-        top().self = self;
-        top().offset = offset;
-        top().bindings = up_values;
-        top().tailCall = false;
-
-        #ifndef NDEBUG
-        for (const auto &bind : up_values) {
-            if (bind.second == nullptr) {
-                std::cerr << "INTERNAL ERROR: No binding for variable "
-                          << encode_utf8(bind.first->name) << std::endl;
-                std::abort();
-            }
-        }
-        #endif
-    }
-
-    /** Look up the stack to find the self binding. */
-    void getSelfBinding(HeapObject *&self, unsigned &offset)
-    {
-        self = nullptr;
-        offset = 0;
-        for (int i=stack.size() - 1 ; i>=0 ; --i) {
-            if (stack[i].isCall()) {
-                self = stack[i].self;
-                offset = stack[i].offset;
-                return;
-            }
-        }
-    }
-
-    /** Look up the stack to see if we're running assertions for this object. */
-    bool alreadyExecutingInvariants(HeapObject *self)
-    {
-        for (int i=stack.size() - 1 ; i>=0 ; --i) {
-            if (stack[i].kind == FRAME_INVARIANTS) {
-                if (stack[i].self == self) return true;
-            }
-        }
-        return false;
-    }
-};
-
-/** Typedef to save some typing. */
-typedef std::map<std::string, VmExt> ExtMap;
-
-/** Typedef to save some typing. */
-typedef std::map<std::string, std::string> StrMap;
-
-
-class Interpreter;
-
-typedef const AST *(Interpreter::*BuiltinFunc)(const LocationRange &loc,
-                                               const std::vector<Value> &args);
-
-/** Holds the intermediate state during execution and implements the necessary functions to
- * implement the semantics of the language.
- *
- * The garbage collector used is a simple stop-the-world mark and sweep collector.  It runs upon
- * memory allocation if the heap is large enough and has grown enough since the last collection.
- * All reachable entities have their mark field incremented.  Then all entities with the old
- * mark are removed from the heap.
- */
-class Interpreter {
-
-    /** The heap. */
-    Heap heap;
-
-    /** The value last computed. */
-    Value scratch;
-
-    /** The stack. */
-    Stack stack;
-
-    /** Used to create ASTs if needed.
-     *
-     * This is used at import time, and in a few other cases.
-     */
-    Allocator *alloc;
-
-    /** Used to "name" thunks created to cache imports. */
-    const Identifier *idImport;
-
-    /** Used to "name" thunks created on the inside of an array. */
-    const Identifier *idArrayElement;
-
-    /** Used to "name" thunks created to execute invariants. */
-    const Identifier *idInvariant;
-
-    /** Used to "name" thunks created to convert JSON to Jsonnet objects. */
-    const Identifier *idJsonObjVar;
-
-    /** Used to refer to idJsonObjVar. */
-    const AST *jsonObjVar;
-
-    struct ImportCacheValue {
-        std::string foundHere;
-        std::string content;
-        /** Thunk to store cached result of execution.
-         *
-         * Null if this file was only ever successfully imported with importstr.
-         */
-        HeapThunk *thunk;
-    };
-
-    /** Cache for imported Jsonnet files. */
-    std::map<std::pair<std::string, UString>, ImportCacheValue *> cachedImports;
-
-    /** External variables for std.extVar. */
-    ExtMap externalVars;
-
-    /** The callback used for loading imported files. */
-    VmNativeCallbackMap nativeCallbacks;
-
-    /** The callback used for loading imported files. */
-    JsonnetImportCallback *importCallback;
-
-    /** User context pointer for the import callback. */
-    void *importCallbackContext;
-
-    /** Builtin functions by name. */
-    typedef std::map<std::string, BuiltinFunc> BuiltinMap;
-    BuiltinMap builtins;
-
-    RuntimeError makeError(const LocationRange &loc, const std::string &msg)
-    {
-        return stack.makeError(loc, msg);
-    }
-
-    /** Create an object on the heap, maybe collect garbage.
-     * \param T Something under HeapEntity
-     * \returns The new object
-     */
-    template <class T, class... Args> T* makeHeap(Args&&... args)
-    {
-        T *r = heap.makeEntity<T, Args...>(std::forward<Args>(args)...);
-        if (heap.checkHeap()) {  // Do a GC cycle?
-            // Avoid the object we just made being collected.
-            heap.markFrom(r);
-
-            // Mark from the stack.
-            stack.mark(heap);
-
-            // Mark from the scratch register
-            heap.markFrom(scratch);
-
-            // Mark from cached imports
-            for (const auto &pair : cachedImports) {
-                HeapThunk *thunk = pair.second->thunk;
-                if (thunk != nullptr)
-                    heap.markFrom(thunk);
-            }
-
-            // Delete unreachable objects.
-            heap.sweep();
-        }
-        return r;
-    }
-
-    Value makeBoolean(bool v)
-    {
-        Value r;
-        r.t = Value::BOOLEAN;
-        r.v.b = v;
-        return r;
-    }
-
-    Value makeDouble(double v)
-    {
-        Value r;
-        r.t = Value::DOUBLE;
-        r.v.d = v;
-        return r;
-    }
-
-    Value makeDoubleCheck(const LocationRange &loc, double v)
-    {
-        if (std::isnan(v)) {
-            throw makeError(loc, "Not a number");
-        }
-        if (std::isinf(v)) {
-            throw makeError(loc, "Overflow");
-        }
-        return makeDouble(v);
-    }
-
-    Value makeNull(void)
-    {
-        Value r;
-        r.t = Value::NULL_TYPE;
-        return r;
-    }
-
-    Value makeArray(const std::vector<HeapThunk*> &v)
-    {
-        Value r;
-        r.t = Value::ARRAY;
-        r.v.h = makeHeap<HeapArray>(v);
-        return r;
-    }
-
-    Value makeClosure(const BindingFrame &env,
-                       HeapObject *self,
-                       unsigned offset,
-                       const HeapClosure::Params &params,
-                       AST *body)
-    {
-        Value r;
-        r.t = Value::FUNCTION;
-        r.v.h = makeHeap<HeapClosure>(env, self, offset, params, body, "");
-        return r;
-    }
-
-    Value makeNativeBuiltin(const std::string &name, const std::vector<std::string> &params)
-    {
-        HeapClosure::Params hc_params;
-        for (const auto &p : params) {
-            hc_params.emplace_back(alloc->makeIdentifier(decode_utf8(p)), nullptr);
-        }
-        return makeBuiltin(name, hc_params);
-    }
-
-    Value makeBuiltin(const std::string &name, const HeapClosure::Params &params)
-    {
-        AST *body = nullptr;
-        Value r;
-        r.t = Value::FUNCTION;
-        r.v.h = makeHeap<HeapClosure>(BindingFrame(), nullptr, 0, params, body, name);
-        return r;
-    }
-
-    template <class T, class... Args> Value makeObject(Args... args)
-    {
-        Value r;
-        r.t = Value::OBJECT;
-        r.v.h = makeHeap<T>(args...);
-        return r;
-    }
-
-    Value makeString(const UString &v)
-    {
-        Value r;
-        r.t = Value::STRING;
-        r.v.h = makeHeap<HeapString>(v);
-        return r;
-    }
-
-    /** Auxiliary function of objectIndex.
-     *
-     * Traverse the object's tree from right to left, looking for an object
-     * with the given field.  Call with offset initially set to 0.
-     *
-     * \param f The field we're looking for.
-     * \param start_from Step over this many leaves first.
-     * \param counter Return the level of "super" that contained the field.
-     * \returns The first object with the field, or nullptr if it could not be found.
-     */
-    HeapLeafObject *findObject(const Identifier *f, HeapObject *curr,
-                               unsigned start_from, unsigned &counter)
-    {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(curr)) {
-            auto *r = findObject(f, ext->right, start_from, counter);
-            if (r) return r;
-            auto *l = findObject(f, ext->left, start_from, counter);
-            if (l) return l;
-        } else {
-            if (counter >= start_from) {
-                if (auto *simp = dynamic_cast<HeapSimpleObject*>(curr)) {
-                    auto it = simp->fields.find(f);
-                    if (it != simp->fields.end()) {
-                        return simp;
-                    }
-                } else if (auto *comp = dynamic_cast<HeapComprehensionObject*>(curr)) {
-                    auto it = comp->compValues.find(f);
-                    if (it != comp->compValues.end()) {
-                        return comp;
-                    }
-                }
-            }
-            counter++;
-        }
-        return nullptr;
-    }
-
-    typedef std::map<const Identifier*, ObjectField::Hide> IdHideMap;
-
-    /** Auxiliary function.
-     */
-    IdHideMap objectFieldsAux(const HeapObject *obj_)
-    {
-        IdHideMap r;
-        if (auto *obj = dynamic_cast<const HeapSimpleObject*>(obj_)) {
-            for (const auto &f : obj->fields) {
-                r[f.first] = f.second.hide;
-            }
-
-        } else if (auto *obj = dynamic_cast<const HeapExtendedObject*>(obj_)) {
-            r = objectFieldsAux(obj->right);
-            for (const auto &pair : objectFieldsAux(obj->left)) {
-                auto it = r.find(pair.first);
-                if (it == r.end()) {
-                    // First time it is seen
-                    r[pair.first] = pair.second;
-                } else if (it->second == ObjectField::INHERIT) {
-                    // Seen before, but with inherited visibility so use new visibility
-                    r[pair.first] = pair.second;
-                }
-            }
-
-        } else if (auto *obj = dynamic_cast<const HeapComprehensionObject*>(obj_)) {
-            for (const auto &f : obj->compValues)
-                r[f.first] = ObjectField::VISIBLE;
-        }
-        return r;
-    }
-
-    /** Auxiliary function.
-     */
-    std::set<const Identifier*> objectFields(const HeapObject *obj_, bool manifesting)
-    {
-        std::set<const Identifier*> r;
-        for (const auto &pair : objectFieldsAux(obj_)) {
-            if (!manifesting || pair.second != ObjectField::HIDDEN) r.insert(pair.first);
-        }
-        return r;
-    }
-
-    /** Import another Jsonnet file.
-     *
-     * If the file has already been imported, then use that version.  This maintains
-     * referential transparency in the case of writes to disk during execution.  The
-     * cache holds a thunk in order to cache the resulting value of execution.
-     *
-     * \param loc Location of the import statement.
-     * \param file Path to the filename.
-     */
-    HeapThunk *import(const LocationRange &loc, const LiteralString *file)
-    {
-        ImportCacheValue *input = importString(loc, file);
-        if (input->thunk == nullptr) {
-            Tokens tokens = jsonnet_lex(input->foundHere, input->content.c_str());
-            AST *expr = jsonnet_parse(alloc, tokens);
-            jsonnet_desugar(alloc, expr, nullptr);
-            jsonnet_static_analysis(expr);
-            // If no errors then populate cache.
-            auto *thunk = makeHeap<HeapThunk>(idImport, nullptr, 0, expr);
-            input->thunk = thunk;
-        }
-        return input->thunk;
-    }
-
-    /** Import a file as a string.
-     *
-     * If the file has already been imported, then use that version.  This maintains
-     * referential transparency in the case of writes to disk during execution.
-     *
-     * \param loc Location of the import statement.
-     * \param file Path to the filename.
-     * \param found_here If non-null, used to store the actual path of the file
-     */
-    ImportCacheValue *importString(const LocationRange &loc, const LiteralString *file)
-    {
-        std::string dir = dir_name(loc.file);
-
-        const UString &path = file->value;
-
-        std::pair<std::string, UString> key(dir, path);
-        ImportCacheValue *cached_value = cachedImports[key];
-        if (cached_value != nullptr)
-            return cached_value;
-
-        int success = 0;
-        char *found_here_cptr;
-        char *content =
-            importCallback(importCallbackContext, dir.c_str(), encode_utf8(path).c_str(),
-                           &found_here_cptr, &success);
-
-        std::string input(content);
-        ::free(content);
-
-        if (!success) {
-            std::string msg = "Couldn't open import \"" + encode_utf8(path) + "\": ";
-            msg += input;
-            throw makeError(loc, msg);
-        }
-
-        auto *input_ptr = new ImportCacheValue();
-        input_ptr->foundHere = found_here_cptr;
-        input_ptr->content = input;
-        input_ptr->thunk = nullptr;  // May be filled in later by import().
-        ::free(found_here_cptr);
-        cachedImports[key] = input_ptr;
-        return input_ptr;
-    }
-
-    /** Capture the required variables from the environment. */
-    BindingFrame capture(const std::vector<const Identifier*> &free_vars)
-    {
-        BindingFrame env;
-        for (auto fv : free_vars) {
-            auto *th = stack.lookUpVar(fv);
-            env[fv] = th;
-        }
-        return env;
-    }
-
-    /** Count the number of leaves in the tree.
-     *
-     * \param obj The root of the tree.
-     * \returns The number of leaves.
-     */
-    unsigned countLeaves(HeapObject *obj)
-    {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(obj)) {
-            return countLeaves(ext->left) + countLeaves(ext->right);
-        } else {
-            // Must be a HeapLeafObject.
-            return 1;
-        }
-    }
-
-    public:
-
-    /** Create a new interpreter.
-     *
-     * \param loc The location range of the file to be executed.
-     */
-    Interpreter(
-        Allocator *alloc,
-        const ExtMap &ext_vars,
-        unsigned max_stack,
-        double gc_min_objects,
-        double gc_growth_trigger,
-        const VmNativeCallbackMap &native_callbacks,
-        JsonnetImportCallback *import_callback,
-        void *import_callback_context)
-
-      : heap(gc_min_objects, gc_growth_trigger),
-        stack(max_stack),
-        alloc(alloc),
-        idImport(alloc->makeIdentifier(U"import")),
-        idArrayElement(alloc->makeIdentifier(U"array_element")),
-        idInvariant(alloc->makeIdentifier(U"object_assert")),
-        idJsonObjVar(alloc->makeIdentifier(U"_")),
-        jsonObjVar(alloc->make<Var>(LocationRange(), Fodder{}, idJsonObjVar)),
-        externalVars(ext_vars),
-        nativeCallbacks(native_callbacks),
-        importCallback(import_callback),
-        importCallbackContext(import_callback_context)
-    {
-        scratch = makeNull();
-        builtins["makeArray"] = &Interpreter::builtinMakeArray;
-        builtins["pow"] = &Interpreter::builtinPow;
-        builtins["floor"] = &Interpreter::builtinFloor;
-        builtins["ceil"] = &Interpreter::builtinCeil;
-        builtins["sqrt"] = &Interpreter::builtinSqrt;
-        builtins["sin"] = &Interpreter::builtinSin;
-        builtins["cos"] = &Interpreter::builtinCos;
-        builtins["tan"] = &Interpreter::builtinTan;
-        builtins["asin"] = &Interpreter::builtinAsin;
-        builtins["acos"] = &Interpreter::builtinAcos;
-        builtins["atan"] = &Interpreter::builtinAtan;
-        builtins["type"] = &Interpreter::builtinType;
-        builtins["filter"] = &Interpreter::builtinFilter;
-        builtins["objectHasEx"] = &Interpreter::builtinObjectHasEx;
-        builtins["length"] = &Interpreter::builtinLength;
-        builtins["objectFieldsEx"] = &Interpreter::builtinObjectFieldsEx;
-        builtins["codepoint"] = &Interpreter::builtinCodepoint;
-        builtins["char"] = &Interpreter::builtinChar;
-        builtins["log"] = &Interpreter::builtinLog;
-        builtins["exp"] = &Interpreter::builtinExp;
-        builtins["mantissa"] = &Interpreter::builtinMantissa;
-        builtins["exponent"] = &Interpreter::builtinExponent;
-        builtins["modulo"] = &Interpreter::builtinModulo;
-        builtins["extVar"] = &Interpreter::builtinExtVar;
-        builtins["primitiveEquals"] = &Interpreter::builtinPrimitiveEquals;
-        builtins["native"] = &Interpreter::builtinNative;
-        builtins["md5"] = &Interpreter::builtinMd5;
-    }
-
-    /** Clean up the heap, stack, stash, and builtin function ASTs. */
-    ~Interpreter()
-    {
-        for (const auto &pair : cachedImports) {
-            delete pair.second;
-        }
-    }
-
-    const Value &getScratchRegister(void)
-    {
-        return scratch;
-    }
-
-    void setScratchRegister(const Value &v)
-    {
-        scratch = v;
-    }
-
-
-    /** Raise an error if the arguments aren't the expected types. */
-    void validateBuiltinArgs(const LocationRange &loc,
-                             const std::string &name,
-                             const std::vector<Value> &args,
-                             const std::vector<Value::Type> params)
-    {
-        if (args.size() == params.size()) {
-            for (unsigned i=0 ; i<args.size() ; ++i) {
-                if (args[i].t != params[i]) goto bad;
-            }
-            return;
-        }
-        bad:;
-        std::stringstream ss;
-        ss << "Builtin function " + name + " expected (";
-        const char *prefix = "";
-        for (auto p : params) {
-            ss << prefix << type_str(p);
-            prefix = ", ";
-        }
-        ss << ") but got (";
-        prefix = "";
-        for (auto a : args) {
-            ss << prefix << type_str(a);
-            prefix = ", ";
-        }
-        ss << ")";
-        throw makeError(loc, ss.str());
-    }
-
-    const AST *builtinMakeArray(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        Frame &f = stack.top();
-        validateBuiltinArgs(loc, "makeArray", args,
-                            {Value::DOUBLE, Value::FUNCTION});
-        long sz = long(args[0].v.d);
-        if (sz < 0) {
-            std::stringstream ss;
-            ss << "makeArray requires size >= 0, got " << sz;
-            throw makeError(loc, ss.str());
-        }
-        auto *func = static_cast<const HeapClosure*>(args[1].v.h);
-        std::vector<HeapThunk*> elements;
-        if (func->params.size() != 1) {
-            std::stringstream ss;
-            ss << "makeArray function must take 1 param, got: " << func->params.size();
-            throw makeError(loc, ss.str());
-        }
-        elements.resize(sz);
-        for (long i=0 ; i<sz ; ++i) {
-            auto *th = makeHeap<HeapThunk>(idArrayElement, func->self, func->offset, func->body);
-            // The next line stops the new thunks from being GCed.
-            f.thunks.push_back(th);
-            th->upValues = func->upValues;
-
-            auto *el = makeHeap<HeapThunk>(func->params[0].id, nullptr, 0, nullptr);
-            el->fill(makeDouble(i));  // i guaranteed not to be inf/NaN
-            th->upValues[func->params[0].id] = el;
-            elements[i] = th;
-        }
-        scratch = makeArray(elements);
-        return nullptr;
-    }
-
-    const AST *builtinPow(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "pow", args, {Value::DOUBLE, Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::pow(args[0].v.d, args[1].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinFloor(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "floor", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::floor(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinCeil(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "ceil", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::ceil(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinSqrt(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "sqrt", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::sqrt(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinSin(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "sin", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::sin(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinCos(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "cos", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::cos(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinTan(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "tan", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::tan(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinAsin(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "asin", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::asin(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinAcos(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "acos", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::acos(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinAtan(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "atan", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::atan(args[0].v.d));
-        return nullptr;
-    }
-
-    const AST *builtinType(const LocationRange &, const std::vector<Value> &args)
-    {
-        switch (args[0].t) {
-            case Value::NULL_TYPE:
-            scratch = makeString(U"null");
-            return nullptr;
-
-            case Value::BOOLEAN:
-            scratch = makeString(U"boolean");
-            return nullptr;
-
-            case Value::DOUBLE:
-            scratch = makeString(U"number");
-            return nullptr;
-
-            case Value::ARRAY:
-            scratch = makeString(U"array");
-            return nullptr;
-
-            case Value::FUNCTION:
-            scratch = makeString(U"function");
-            return nullptr;
-
-            case Value::OBJECT:
-            scratch = makeString(U"object");
-            return nullptr;
-
-            case Value::STRING:
-            scratch = makeString(U"string");
-            return nullptr;
-        }
-        return nullptr;  // Quiet, compiler.
-    }
-
-    const AST *builtinFilter(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        Frame &f = stack.top();
-        validateBuiltinArgs(loc, "filter", args, {Value::FUNCTION, Value::ARRAY});
-        auto *func = static_cast<HeapClosure*>(args[0].v.h);
-        auto *arr = static_cast<HeapArray*>(args[1].v.h);
-        if (func->params.size() != 1) {
-            throw makeError(loc, "filter function takes 1 parameter.");
-        }
-        if (arr->elements.size() == 0) {
-            scratch = makeArray({});
-        } else {
-            f.kind = FRAME_BUILTIN_FILTER;
-            f.val = args[0];
-            f.val2 = args[1];
-            f.thunks.clear();
-            f.elementId = 0;
-
-            auto *thunk = arr->elements[f.elementId];
-            BindingFrame bindings = func->upValues;
-            bindings[func->params[0].id] = thunk;
-            stack.newCall(loc, func, func->self, func->offset, bindings);
-            return func->body;
-        }
-        return nullptr;
-    }
-
-    const AST *builtinObjectHasEx(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "objectHasEx", args,
-                            {Value::OBJECT, Value::STRING,
-                             Value::BOOLEAN});
-        const auto *obj = static_cast<const HeapObject*>(args[0].v.h);
-        const auto *str = static_cast<const HeapString*>(args[1].v.h);
-        bool include_hidden = args[2].v.b;
-        bool found = false;
-        for (const auto &field : objectFields(obj, !include_hidden)) {
-            if (field->name == str->value) {
-                found = true;
-                break;
-            }
-        }
-        scratch = makeBoolean(found);
-        return nullptr;
-    } 
-
-    const AST *builtinLength(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        if (args.size() != 1) {
-            throw makeError(loc, "length takes 1 parameter.");
-        }
-        HeapEntity *e = args[0].v.h;
-        switch (args[0].t) {
-            case Value::OBJECT: {
-                auto fields = objectFields(static_cast<HeapObject*>(e), true);
-                scratch = makeDouble(fields.size());
-            } break;
-
-            case Value::ARRAY:
-            scratch = makeDouble(static_cast<HeapArray*>(e)->elements.size());
-            break;
-
-            case Value::STRING:
-            scratch = makeDouble(static_cast<HeapString*>(e)->value.length());
-            break;
-
-            case Value::FUNCTION:
-            scratch = makeDouble(static_cast<HeapClosure*>(e)->params.size());
-            break;
-
-            default:
-            throw makeError(loc,
-                            "length operates on strings, objects, "
-                            "and arrays, got " + type_str(args[0]));
-        }
-        return nullptr;
-    } 
-
-    const AST *builtinObjectFieldsEx(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "objectFieldsEx", args,
-                            {Value::OBJECT, Value::BOOLEAN});
-        const auto *obj = static_cast<HeapObject*>(args[0].v.h);
-        bool include_hidden = args[1].v.b;
-        // Stash in a set first to sort them.
-        std::set<UString> fields;
-        for (const auto &field : objectFields(obj, !include_hidden)) {
-            fields.insert(field->name);
-        }
-        scratch = makeArray({});
-        auto &elements = static_cast<HeapArray*>(scratch.v.h)->elements;
-        for (const auto &field : fields) {
-            auto *th = makeHeap<HeapThunk>(idArrayElement, nullptr, 0, nullptr);
-            elements.push_back(th);
-            th->fill(makeString(field));
-        }
-        return nullptr;
-    } 
-
-    const AST *builtinCodepoint(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "codepoint", args, {Value::STRING});
-        const UString &str =
-            static_cast<HeapString*>(args[0].v.h)->value;
-        if (str.length() != 1) {
-            std::stringstream ss;
-            ss << "codepoint takes a string of length 1, got length "
-               << str.length();
-            throw makeError(loc, ss.str());
-        }
-        char32_t c = static_cast<HeapString*>(args[0].v.h)->value[0];
-        scratch = makeDouble((unsigned long)(c));
-        return nullptr;
-    } 
-
-    const AST *builtinChar(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "char", args, {Value::DOUBLE});
-        long l = long(args[0].v.d);
-        if (l < 0) {
-            std::stringstream ss;
-            ss << "Codepoints must be >= 0, got " << l;
-            throw makeError(loc, ss.str());
-        }
-        if (l >= JSONNET_CODEPOINT_MAX) {
-            std::stringstream ss;
-            ss << "Invalid unicode codepoint, got " << l;
-            throw makeError(loc, ss.str());
-        }
-        char32_t c = l;
-        scratch = makeString(UString(&c, 1));
-        return nullptr;
-    } 
-
-    const AST *builtinLog(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "log", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::log(args[0].v.d));
-        return nullptr;
-    } 
-
-    const AST *builtinExp(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "exp", args, {Value::DOUBLE});
-        scratch = makeDoubleCheck(loc, std::exp(args[0].v.d));
-        return nullptr;
-    } 
-
-    const AST *builtinMantissa(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "mantissa", args, {Value::DOUBLE});
-        int exp;
-        double m = std::frexp(args[0].v.d, &exp);
-        scratch = makeDoubleCheck(loc, m);
-        return nullptr;
-    } 
-
-    const AST *builtinExponent(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "exponent", args, {Value::DOUBLE});
-        int exp;
-        std::frexp(args[0].v.d, &exp);
-        scratch = makeDoubleCheck(loc, exp);
-        return nullptr;
-    } 
-
-    const AST *builtinModulo(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "modulo", args, {Value::DOUBLE, Value::DOUBLE});
-        double a = args[0].v.d;
-        double b = args[1].v.d;
-        if (b == 0)
-            throw makeError(loc, "Division by zero.");
-        scratch = makeDoubleCheck(loc, std::fmod(a, b));
-        return nullptr;
-    } 
-
-    const AST *builtinExtVar(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "extVar", args, {Value::STRING});
-        const UString &var =
-            static_cast<HeapString*>(args[0].v.h)->value;
-        std::string var8 = encode_utf8(var);
-        auto it = externalVars.find(var8);
-        if (it == externalVars.end()) {
-            std::string msg = "Undefined external variable: " + var8;
-            throw makeError(loc, msg);
-        }
-        const VmExt &ext = it->second;
-        if (ext.isCode) {
-            std::string filename = "<extvar:" + var8 + ">";
-            Tokens tokens = jsonnet_lex(filename, ext.data.c_str());
-            AST *expr = jsonnet_parse(alloc, tokens);
-            jsonnet_desugar(alloc, expr, nullptr);
-            jsonnet_static_analysis(expr);
-            stack.pop();
-            return expr;
-        } else {
-            scratch = makeString(decode_utf8(ext.data));
-            return nullptr;
-        }
-    } 
-
-    const AST *builtinPrimitiveEquals(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        if (args.size() != 2) {
-            std::stringstream ss;
-            ss << "primitiveEquals takes 2 parameters, got " << args.size();
-            throw makeError(loc, ss.str());
-        }
-        if (args[0].t != args[1].t) {
-            scratch = makeBoolean(false);
-            return nullptr;
-        }
-        bool r;
-        switch (args[0].t) {
-            case Value::BOOLEAN:
-            r = args[0].v.b == args[1].v.b;
-            break;
-
-            case Value::DOUBLE:
-            r = args[0].v.d == args[1].v.d;
-            break;
-
-            case Value::STRING:
-            r = static_cast<HeapString*>(args[0].v.h)->value
-              == static_cast<HeapString*>(args[1].v.h)->value;
-            break;
-
-            case Value::NULL_TYPE:
-            r = true;
-            break;
-
-            case Value::FUNCTION:
-            throw makeError(loc, "Cannot test equality of functions");
-            break;
-
-            default:
-            throw makeError(loc,
-                            "primitiveEquals operates on primitive "
-                            "types, got " + type_str(args[0]));
-        }
-        scratch = makeBoolean(r);
-        return nullptr;
-    } 
-
-    const AST *builtinNative(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "native", args, {Value::STRING});
-
-        std::string builtin_name = encode_utf8(static_cast<HeapString*>(args[0].v.h)->value);
-
-        VmNativeCallbackMap::const_iterator nit = nativeCallbacks.find(builtin_name);
-        if (nit == nativeCallbacks.end()) {
-            throw makeError(loc, "Unrecognized native function name: " + builtin_name);
-        }
-
-        const VmNativeCallback &cb = nit->second;
-        scratch = makeNativeBuiltin(builtin_name, cb.params);
-        return nullptr;
-    } 
-
-    const AST *builtinMd5(const LocationRange &loc, const std::vector<Value> &args)
-    {
-        validateBuiltinArgs(loc, "md5", args, {Value::STRING});
-
-        std::string value = encode_utf8(static_cast<HeapString*>(args[0].v.h)->value);
-
-        scratch = makeString(decode_utf8(md5(value)));
-        return nullptr;
-    }
-
-    void jsonToHeap(const std::unique_ptr<JsonnetJsonValue> &v, bool &filled, Value &attach)
-    {
-        // In order to not anger the garbage collector, assign to attach immediately after
-        // making the heap object.
-        switch (v->kind) {
-            case JsonnetJsonValue::STRING:
-            attach = makeString(decode_utf8(v->string));
-            filled = true;
-            break;
-
-            case JsonnetJsonValue::BOOL:
-            attach = makeBoolean(v->number != 0.0);
-            filled = true;
-            break;
-
-            case JsonnetJsonValue::NUMBER:
-            attach = makeDouble(v->number);
-            filled = true;
-            break;
-
-            case JsonnetJsonValue::NULL_KIND:
-            attach = makeNull();
-            filled = true;
-            break;
-
-            case JsonnetJsonValue::ARRAY: {
-                attach = makeArray(std::vector<HeapThunk*>{});
-                filled = true;
-                auto *arr = static_cast<HeapArray*>(attach.v.h);
-                for (size_t i = 0; i < v->elements.size() ; ++i) {
-                    arr->elements.push_back(
-                        makeHeap<HeapThunk>(idArrayElement, nullptr, 0, nullptr));
-                    jsonToHeap(v->elements[i], arr->elements[i]->filled, arr->elements[i]->content);
-                }
-            } break;
-
-            case JsonnetJsonValue::OBJECT: {
-                attach = makeObject<HeapComprehensionObject>(
-                    BindingFrame{}, jsonObjVar, idJsonObjVar, BindingFrame{});
-                filled = true;
-                auto *obj = static_cast<HeapComprehensionObject*>(attach.v.h);
-                for (const auto &pair : v->fields) {
-                    auto *thunk = makeHeap<HeapThunk>(idJsonObjVar, nullptr, 0, nullptr);
-                    obj->compValues[alloc->makeIdentifier(decode_utf8(pair.first))] = thunk;
-                    jsonToHeap(pair.second, thunk->filled, thunk->content);
-                }
-            } break;
-        }
-    }
-
-
-    UString toString(const LocationRange &loc)
-    {
-        return manifestJson(loc, false, U"");
-    }
-
-
-
-    /** Recursively collect an object's invariants.
-     *
-     * \param curr
-     * \param self
-     * \param offset
-     * \param thunks
-     */
-    void objectInvariants(HeapObject *curr, HeapObject *self,
-                          unsigned &counter, std::vector<HeapThunk*> &thunks)
-    {
-        if (auto *ext = dynamic_cast<HeapExtendedObject*>(curr)) {
-            objectInvariants(ext->right, self, counter, thunks);
-            objectInvariants(ext->left, self, counter, thunks);
-        } else {
-            if (auto *simp = dynamic_cast<HeapSimpleObject*>(curr)) {
-                for (AST *assert : simp->asserts) {
-                    auto *el_th = makeHeap<HeapThunk>(idInvariant, self, counter, assert);
-                    el_th->upValues = simp->upValues;
-                    thunks.push_back(el_th);
-                }
-            }
-            counter++;
-        }
-    }
-
-    /** Index an object's field.
-     *
-     * \param loc Location where the e.f occured.
-     * \param obj The target
-     * \param f The field
-     */
-    const AST *objectIndex(const LocationRange &loc, HeapObject *obj,
-                           const Identifier *f, unsigned offset)
-    {
-        unsigned found_at = 0;
-        HeapObject *self = obj;
-        HeapLeafObject *found = findObject(f, obj, offset, found_at);
-        if (found == nullptr) {
-            throw makeError(loc, "Field does not exist: " + encode_utf8(f->name));
-        }
-        if (auto *simp = dynamic_cast<HeapSimpleObject*>(found)) {
-            auto it = simp->fields.find(f);
-            const AST *body = it->second.body;
-
-            stack.newCall(loc, simp, self, found_at, simp->upValues);
-            return body;
-        } else {
-            // If a HeapLeafObject is not HeapSimpleObject, it must be HeapComprehensionObject.
-            auto *comp = static_cast<HeapComprehensionObject*>(found);
-            auto it = comp->compValues.find(f);
-            auto *th = it->second;
-            BindingFrame binds = comp->upValues;
-            binds[comp->id] = th;
-            stack.newCall(loc, comp, self, found_at, binds);
-            return comp->value;
-        }
-    }
-
-    void runInvariants(const LocationRange &loc, HeapObject *self)
-    {
-        if (stack.alreadyExecutingInvariants(self)) return;
-
-        unsigned counter = 0;
-        unsigned initial_stack_size = stack.size();
-        stack.newFrame(FRAME_INVARIANTS, loc);
-        std::vector<HeapThunk*> &thunks = stack.top().thunks;
-        objectInvariants(self, self, counter, thunks);
-        if (thunks.size() == 0) {
-            stack.pop();
-            return;
-        }
-        HeapThunk *thunk = thunks[0];
-        stack.top().elementId = 1;
-        stack.top().self = self;
-        stack.newCall(loc, thunk, thunk->self, thunk->offset, thunk->upValues);
-        evaluate(thunk->body, initial_stack_size);
-    }
-
-    /** Evaluate the given AST to a value.
-     *
-     * Rather than call itself recursively, this function maintains a separate stack of
-     * partially-evaluated constructs.  First, the AST is handled depending on its type.  If
-     * this cannot be completed without evaluating another AST (e.g. a sub expression) then a
-     * frame is pushed onto the stack containing the partial state, and the code jumps back to
-     * the beginning of this function.  Once there are no more ASTs to evaluate, the code
-     * executes the second part of the function to unwind the stack.  If the stack cannot be
-     * completely unwound without evaluating an AST then it jumps back to the beginning of the
-     * function again.  The process terminates when the AST has been processed and the stack is
-     * the same size it was at the beginning of the call to evaluate.
-     */
-    void evaluate(const AST *ast_, unsigned initial_stack_size)
-    {
-        recurse:
-
-        switch (ast_->type) {
-            case AST_APPLY: {
-                const auto &ast = *static_cast<const Apply*>(ast_);
-                stack.newFrame(FRAME_APPLY_TARGET, ast_);
-                ast_ = ast.target;
-                goto recurse;
-            } break;
-
-            case AST_ARRAY: {
-                const auto &ast = *static_cast<const Array*>(ast_);
-                HeapObject *self;
-                unsigned offset;
-                stack.getSelfBinding(self, offset);
-                scratch = makeArray({});
-                auto &elements = static_cast<HeapArray*>(scratch.v.h)->elements;
-                for (const auto &el : ast.elements) {
-                    auto *el_th = makeHeap<HeapThunk>(idArrayElement, self, offset, el.expr);
-                    el_th->upValues =  capture(el.expr->freeVariables);
-                    elements.push_back(el_th);
-                }
-            } break;
-
-            case AST_BINARY: {
-                const auto &ast = *static_cast<const Binary*>(ast_);
-                stack.newFrame(FRAME_BINARY_LEFT, ast_);
-                ast_ = ast.left;
-                goto recurse;
-            } break;
-
-            case AST_BUILTIN_FUNCTION: {
-                const auto &ast = *static_cast<const BuiltinFunction*>(ast_);
-                HeapClosure::Params params;
-                params.reserve(ast.params.size());
-                for (const auto &p : ast.params) {
-                    // None of the builtins have default args.
-                    params.emplace_back(p, nullptr);
-                }
-                scratch = makeBuiltin(ast.name, params);
-            } break;
-
-            case AST_CONDITIONAL: {
-                const auto &ast = *static_cast<const Conditional*>(ast_);
-                stack.newFrame(FRAME_IF, ast_);
-                ast_ = ast.cond;
-                goto recurse;
-            } break;
-
-            case AST_ERROR: {
-                const auto &ast = *static_cast<const Error*>(ast_);
-                stack.newFrame(FRAME_ERROR, ast_);
-                ast_ = ast.expr;
-                goto recurse;
-            } break;
-
-            case AST_FUNCTION: {
-                const auto &ast = *static_cast<const Function*>(ast_);
-                auto env = capture(ast.freeVariables);
-                HeapObject *self;
-                unsigned offset;
-                stack.getSelfBinding(self, offset);
-                HeapClosure::Params params;
-                params.reserve(ast.params.size());
-                for (const auto &p : ast.params) {
-                    params.emplace_back(p.id, p.expr);
-                }
-                scratch = makeClosure(env, self, offset, params, ast.body);
-            } break;
-
-            case AST_IMPORT: {
-                const auto &ast = *static_cast<const Import*>(ast_);
-                HeapThunk *thunk = import(ast.location, ast.file);
-                if (thunk->filled) {
-                    scratch = thunk->content;
-                } else {
-                    stack.newCall(ast.location, thunk, thunk->self, thunk->offset, thunk->upValues);
-                    ast_ = thunk->body;
-                    goto recurse;
-                }
-            } break;
-
-            case AST_IMPORTSTR: {
-                const auto &ast = *static_cast<const Importstr*>(ast_);
-                const ImportCacheValue *value = importString(ast.location, ast.file);
-                scratch = makeString(decode_utf8(value->content));
-            } break;
-
-            case AST_IN_SUPER: {
-                const auto &ast = *static_cast<const InSuper*>(ast_);
-                stack.newFrame(FRAME_IN_SUPER_ELEMENT, ast_);
-                ast_ = ast.element;
-                goto recurse;
-            } break;
-
-            case AST_INDEX: {
-                const auto &ast = *static_cast<const Index*>(ast_);
-                stack.newFrame(FRAME_INDEX_TARGET, ast_);
-                ast_ = ast.target;
-                goto recurse;
-            } break;
-
-            case AST_LOCAL: {
-                const auto &ast = *static_cast<const Local*>(ast_);
-                stack.newFrame(FRAME_LOCAL, ast_);
-                Frame &f = stack.top();
-                // First build all the thunks and bind them.
-                HeapObject *self;
-                unsigned offset;
-                stack.getSelfBinding(self, offset);
-                for (const auto &bind : ast.binds) {
-                    // Note that these 2 lines must remain separate to avoid the GC running
-                    // when bindings has a nullptr for key bind.first.
-                    auto *th = makeHeap<HeapThunk>(bind.var, self, offset, bind.body);
-                    f.bindings[bind.var] = th;
-                }
-                // Now capture the environment (including the new thunks, to make cycles).
-                for (const auto &bind : ast.binds) {
-                    auto *thunk = f.bindings[bind.var];
-                    thunk->upValues = capture(bind.body->freeVariables);
-                }
-                ast_ = ast.body;
-                goto recurse;
-            } break;
-
-            case AST_LITERAL_BOOLEAN: {
-                const auto &ast = *static_cast<const LiteralBoolean*>(ast_);
-                scratch = makeBoolean(ast.value);
-            } break;
-
-            case AST_LITERAL_NUMBER: {
-                const auto &ast = *static_cast<const LiteralNumber*>(ast_);
-                scratch = makeDoubleCheck(ast_->location, ast.value);
-            } break;
-
-            case AST_LITERAL_STRING: {
-                const auto &ast = *static_cast<const LiteralString*>(ast_);
-                scratch = makeString(ast.value);
-            } break;
-
-            case AST_LITERAL_NULL: {
-                scratch = makeNull();
-            } break;
-
-            case AST_DESUGARED_OBJECT: {
-                const auto &ast = *static_cast<const DesugaredObject*>(ast_);
-                if (ast.fields.empty()) {
-                    auto env = capture(ast.freeVariables);
-                    std::map<const Identifier *, HeapSimpleObject::Field> fields;
-                    scratch = makeObject<HeapSimpleObject>(env, fields, ast.asserts);
-                } else {
-                    auto env = capture(ast.freeVariables);
-                    stack.newFrame(FRAME_OBJECT, ast_);
-                    auto fit = ast.fields.begin();
-                    stack.top().fit = fit;
-                    ast_ = fit->name;
-                    goto recurse;
-                }
-            } break;
-
-            case AST_OBJECT_COMPREHENSION_SIMPLE: {
-                const auto &ast = *static_cast<const ObjectComprehensionSimple*>(ast_);
-                stack.newFrame(FRAME_OBJECT_COMP_ARRAY, ast_);
-                ast_ = ast.array;
-                goto recurse;
-            } break;
-
-            case AST_SELF: {
-                scratch.t = Value::OBJECT;
-                HeapObject *self;
-                unsigned offset;
-                stack.getSelfBinding(self, offset);
-                scratch.v.h = self;
-            } break;
-
-            case AST_SUPER_INDEX: {
-                const auto &ast = *static_cast<const SuperIndex*>(ast_);
-                stack.newFrame(FRAME_SUPER_INDEX, ast_);
-                ast_ = ast.index;
-                goto recurse;
-            } break;
-
-            case AST_UNARY: {
-                const auto &ast = *static_cast<const Unary*>(ast_);
-                stack.newFrame(FRAME_UNARY, ast_);
-                ast_ = ast.expr;
-                goto recurse;
-            } break;
-
-            case AST_VAR: {
-                const auto &ast = *static_cast<const Var*>(ast_);
-                auto *thunk = stack.lookUpVar(ast.id);
-                if (thunk == nullptr) {
-                    std::cerr << "INTERNAL ERROR: Could not bind variable: "
-                              << encode_utf8(ast.id->name) << std::endl;
-                    std::abort();
-                }
-                if (thunk->filled) {
-                    scratch = thunk->content;
-                } else {
-                    stack.newCall(ast.location, thunk, thunk->self, thunk->offset, thunk->upValues);
-                    ast_ = thunk->body;
-                    goto recurse;
-                }
-            } break;
-
-            default:
-            std::cerr << "INTERNAL ERROR: Unknown AST: " << ast_->type << std::endl;
-            std::abort();
-        }
-
-        // To evaluate another AST, set ast to it, then goto recurse.
-        // To pop, exit the switch or goto popframe
-        // To change the frame and re-enter the switch, goto replaceframe
-        while (stack.size() > initial_stack_size) {
-            Frame &f = stack.top();
-            switch (f.kind) {
-                case FRAME_APPLY_TARGET: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
-                    if (scratch.t != Value::FUNCTION) {
-                        throw makeError(ast.location,
-                                        "Only functions can be called, got "
-                                        + type_str(scratch));
-                    }
-                    auto *func = static_cast<HeapClosure*>(scratch.v.h);
-
-                    std::set<const Identifier *> params_needed;
-                    for (const auto &param : func->params) {
-                        params_needed.insert(param.id);
-                    }
-
-                    // Create thunks for arguments.
-                    std::vector<HeapThunk*> positional_args;
-                    BindingFrame args;
-                    bool got_named = false;
-                    for (unsigned i=0 ; i<ast.args.size() ; ++i) {
-                        const auto &arg = ast.args[i];
-
-                        const Identifier *name;
-                        if (arg.id != nullptr) {
-                            got_named = true;
-                            name = arg.id;
-                        } else {
-                            if (got_named) {
-                                std::stringstream ss;
-                                ss << "Internal error: got positional param after named at index "
-                                   << i;
-                                throw makeError(ast.location, ss.str());
-                            }
-                            if (i >= func->params.size()) {
-                                std::stringstream ss;
-                                ss << "Too many args, function has " << func->params.size()
-                                   << " parameter(s)";
-                                throw makeError(ast.location, ss.str());
-                            }
-                            name = func->params[i].id;
-                        }
-                        // Special case for builtin functions -- leave identifier blank for
-                        // them in the thunk.  This removes the thunk frame from the stacktrace.
-                        const Identifier *name_ = func->body == nullptr ? nullptr : name;
-                        HeapObject *self;
-                        unsigned offset;
-                        stack.getSelfBinding(self, offset);
-                        auto *thunk = makeHeap<HeapThunk>(name_, self, offset, arg.expr);
-                        thunk->upValues = capture(arg.expr->freeVariables);
-                        // While making the thunks, keep them in a frame to avoid premature garbage
-                        // collection.
-                        f.thunks.push_back(thunk);
-                        if (args.find(name) != args.end()) {
-                            std::stringstream ss;
-                            ss << "Binding parameter a second time: " << encode_utf8(name->name);
-                            throw makeError(ast.location, ss.str());
-                        }
-                        args[name] = thunk;
-                        if (params_needed.find(name) == params_needed.end()) {
-                            std::stringstream ss;
-                            ss << "Function has no parameter " << encode_utf8(name->name);
-                            throw makeError(ast.location, ss.str());
-                        }
-                    }
-
-                    // For any func params for which there was no arg, create a thunk for those and
-                    // bind the default argument.  Allow default thunks to see other params.  If no
-                    // default argument than raise an error.
-
-                    // Raise errors for unbound params, create thunks (but don't fill in upvalues).
-                    // This is a subset of f.thunks, so will not get garbage collected.
-                    std::vector<HeapThunk*> def_arg_thunks;
-                    for (const auto &param : func->params) {
-                        if (args.find(param.id) != args.end()) continue;
-                        if (param.def == nullptr) {
-                            std::stringstream ss;
-                            ss << "Function parameter " << encode_utf8(param.id->name) <<
-                                  " not bound in call.";
-                            throw makeError(ast.location, ss.str());
-                        }
-
-                        // Special case for builtin functions -- leave identifier blank for
-                        // them in the thunk.  This removes the thunk frame from the stacktrace.
-                        const Identifier *name_ = func->body == nullptr ? nullptr : param.id;
-                        auto *thunk = makeHeap<HeapThunk>(name_, func->self, func->offset,
-                                                          param.def);
-                        f.thunks.push_back(thunk);
-                        def_arg_thunks.push_back(thunk);
-                        args[param.id] = thunk;
-                    }
-
-                    BindingFrame up_values = func->upValues;
-                    up_values.insert(args.begin(), args.end());
-
-                    // Fill in upvalues
-                    for (HeapThunk *thunk : def_arg_thunks) {
-                        thunk->upValues = up_values;
-                    }
-
-                    // Cache these, because pop will invalidate them.
-                    std::vector<HeapThunk*> thunks_copy = f.thunks;
-
-                    stack.pop();
-
-                    if (func->body == nullptr) {
-                        // Built-in function.
-                        // Give nullptr for self because noone looking at this frame will
-                        // attempt to bind to self (it's native code).
-                        stack.newFrame(FRAME_BUILTIN_FORCE_THUNKS, f.ast);
-                        stack.top().thunks = thunks_copy;
-                        stack.top().val = scratch;
-                        goto replaceframe;
-                    } else {
-                        // User defined function.
-                        stack.newCall(ast.location, func, func->self, func->offset, up_values);
-                        if (ast.tailstrict) {
-                            stack.top().tailCall = true;
-                            if (thunks_copy.size() == 0) {
-                                // No need to force thunks, proceed straight to body.
-                                ast_ = func->body;
-                                goto recurse;
-                            } else {
-                                // The check for args.size() > 0
-                                stack.top().thunks = thunks_copy;
-                                stack.top().val = scratch;
-                                goto replaceframe;
-                            }
-                        } else {
-                            ast_ = func->body;
-                            goto recurse;
-                        }
-                    }
-                } break;
-
-                case FRAME_BINARY_LEFT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
-                    const Value &lhs = scratch;
-                    if (lhs.t == Value::BOOLEAN) {
-                        // Handle short-cut semantics
-                        switch (ast.op) {
-                            case BOP_AND: {
-                                if (!lhs.v.b) {
-                                    scratch = makeBoolean(false);
-                                    goto popframe;
-                                }
-                            } break;
-
-                            case BOP_OR: {
-                                if (lhs.v.b) {
-                                    scratch = makeBoolean(true);
-                                    goto popframe;
-                                }
-                            } break;
-
-                            default:;
-                        }
-                    }
-                    stack.top().kind = FRAME_BINARY_RIGHT;
-                    stack.top().val = lhs;
-                    ast_ = ast.right;
-                    goto recurse;
-                } break;
-
-                case FRAME_BINARY_RIGHT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
-                    const Value &lhs = stack.top().val;
-                    const Value &rhs = scratch;
-
-                    // Handle cases where the LHS and RHS are not the same type.
-                    if (lhs.t == Value::STRING || rhs.t == Value::STRING) {
-                        if (ast.op == BOP_PLUS) {
-                            // Handle co-ercions for string processing.
-                            stack.top().kind = FRAME_STRING_CONCAT;
-                            stack.top().val2 = rhs;
-                            goto replaceframe;
-                        }
-                    }
-                    switch (ast.op) {
-                        // Equality can be used when the types don't match.
-                        case BOP_MANIFEST_EQUAL:
-                        std::cerr << "INTERNAL ERROR: Equals not desugared" << std::endl;
-                        abort();
-
-                        // Equality can be used when the types don't match.
-                        case BOP_MANIFEST_UNEQUAL:
-                        std::cerr << "INTERNAL ERROR: Notequals not desugared" << std::endl;
-                        abort();
-
-                        // e in e
-                        case BOP_IN: {
-                            if (lhs.t != Value::STRING) {
-                                throw makeError(ast.location,
-                                                "The left hand side of the 'in' operator should be "
-                                                "a string,  got " + type_str(lhs));
-                            }
-                            auto *field = static_cast<HeapString*>(lhs.v.h);
-                            switch (rhs.t) {
-                                case Value::OBJECT: {
-                                    auto *obj = static_cast<HeapObject*>(rhs.v.h);
-                                    auto *fid = alloc->makeIdentifier(field->value);
-                                    unsigned unused_found_at = 0;
-                                    bool in = findObject(fid, obj, 0, unused_found_at);
-                                    scratch = makeBoolean(in);
-                                } break;
-  
-                                default:
-                                throw makeError(ast.location,
-                                                "The right hand side of the 'in' operator should be"
-                                                " an object, got " + type_str(rhs));
-                            }
-                            goto popframe;
-                        }
-
-                        default:;
-                    }
-                    // Everything else requires matching types.
-                    if (lhs.t != rhs.t) {
-                        throw makeError(ast.location,
-                                        "Binary operator " + bop_string(ast.op) + " requires "
-                                        "matching types, got " + type_str(lhs) + " and " +
-                                        type_str(rhs) + ".");
-                    }
-                    switch (lhs.t) {
-                        case Value::ARRAY:
-                        if (ast.op == BOP_PLUS) {
-                            auto *arr_l = static_cast<HeapArray*>(lhs.v.h);
-                            auto *arr_r = static_cast<HeapArray*>(rhs.v.h);
-                            std::vector<HeapThunk*> elements;
-                            for (auto *el : arr_l->elements)
-                                elements.push_back(el);
-                            for (auto *el : arr_r->elements)
-                                elements.push_back(el);
-                            scratch = makeArray(elements);
-                        } else {
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on arrays.");
-                        }
-                        break;
-
-                        case Value::BOOLEAN:
-                        switch (ast.op) {
-                            case BOP_AND:
-                            scratch = makeBoolean(lhs.v.b && rhs.v.b);
-                            break;
-
-                            case BOP_OR:
-                            scratch = makeBoolean(lhs.v.b || rhs.v.b);
-                            break;
-
-                            default:
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on booleans.");
-                        }
-                        break;
-
-                        case Value::DOUBLE:
-                        switch (ast.op) {
-                            case BOP_PLUS:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d + rhs.v.d);
-                            break;
-
-                            case BOP_MINUS:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d - rhs.v.d);
-                            break;
-
-                            case BOP_MULT:
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d * rhs.v.d);
-                            break;
-
-                            case BOP_DIV:
-                            if (rhs.v.d == 0)
-                                throw makeError(ast.location, "Division by zero.");
-                            scratch = makeDoubleCheck(ast.location, lhs.v.d / rhs.v.d);
-                            break;
-
-                            // No need to check doubles made from longs
-
-                            case BOP_SHIFT_L: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l << long_r);
-                            } break;
-
-                            case BOP_SHIFT_R: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l >> long_r);
-                            } break;
-
-                            case BOP_BITWISE_AND: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l & long_r);
-                            } break;
-
-                            case BOP_BITWISE_XOR: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l ^ long_r);
-                            } break;
-
-                            case BOP_BITWISE_OR: {
-                                long long_l = lhs.v.d;
-                                long long_r = rhs.v.d;
-                                scratch = makeDouble(long_l | long_r);
-                            } break;
-
-                            case BOP_LESS_EQ:
-                            scratch = makeBoolean(lhs.v.d <= rhs.v.d);
-                            break;
-
-                            case BOP_GREATER_EQ:
-                            scratch = makeBoolean(lhs.v.d >= rhs.v.d);
-                            break;
-
-                            case BOP_LESS:
-                            scratch = makeBoolean(lhs.v.d < rhs.v.d);
-                            break;
-
-                            case BOP_GREATER:
-                            scratch = makeBoolean(lhs.v.d > rhs.v.d);
-                            break;
-
-                            default:
-                            throw makeError(ast.location,
-                                            "Binary operator " + bop_string(ast.op)
-                                            + " does not operate on numbers.");
-                        }
-                        break;
-
-                        case Value::FUNCTION:
-                        throw makeError(ast.location, "Binary operator " + bop_string(ast.op) +
-                                                      " does not operate on functions.");
-
-                        case Value::NULL_TYPE:
-                        throw makeError(ast.location, "Binary operator " + bop_string(ast.op) +
-                                                      " does not operate on null.");
-
-                        case Value::OBJECT: {
-                            if (ast.op != BOP_PLUS) {
-                                throw makeError(ast.location,
-                                                "Binary operator " + bop_string(ast.op) +
-                                                " does not operate on objects.");
-                            }
-                            auto *lhs_obj = static_cast<HeapObject*>(lhs.v.h);
-                            auto *rhs_obj = static_cast<HeapObject*>(rhs.v.h);
-                            scratch = makeObject<HeapExtendedObject>(lhs_obj, rhs_obj);
-                        }
-                        break;
-
-                        case Value::STRING: {
-                            const UString &lhs_str =
-                                static_cast<HeapString*>(lhs.v.h)->value;
-                            const UString &rhs_str =
-                                static_cast<HeapString*>(rhs.v.h)->value;
-                            switch (ast.op) {
-                                case BOP_PLUS:
-                                scratch = makeString(lhs_str + rhs_str);
-                                break;
-
-                                case BOP_LESS_EQ:
-                                scratch = makeBoolean(lhs_str <= rhs_str);
-                                break;
-
-                                case BOP_GREATER_EQ:
-                                scratch = makeBoolean(lhs_str >= rhs_str);
-                                break;
-
-                                case BOP_LESS:
-                                scratch = makeBoolean(lhs_str < rhs_str);
-                                break;
-
-                                case BOP_GREATER:
-                                scratch = makeBoolean(lhs_str > rhs_str);
-                                break;
-
-                                default:
-                                throw makeError(ast.location,
-                                                "Binary operator " + bop_string(ast.op)
-                                                + " does not operate on strings.");
-                            }
-                        }
-                        break;
-                    }
-                } break;
-
-                case FRAME_BUILTIN_FILTER: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
-                    auto *func = static_cast<HeapClosure*>(f.val.v.h);
-                    auto *arr = static_cast<HeapArray*>(f.val2.v.h);
-                    if (scratch.t != Value::BOOLEAN) {
-                        throw makeError(ast.location,
-                                        "filter function must return boolean, got: "
-                                        + type_str(scratch));
-                    }
-                    if (scratch.v.b) f.thunks.push_back(arr->elements[f.elementId]);
-                    f.elementId++;
-                    // Iterate through arr, calling the function on each.
-                    if (f.elementId == arr->elements.size()) {
-                        scratch = makeArray(f.thunks);
-                    } else {
-                        auto *thunk = arr->elements[f.elementId];
-                        BindingFrame bindings = func->upValues;
-                        bindings[func->params[0].id] = thunk;
-                        stack.newCall(ast.location, func, func->self, func->offset, bindings);
-                        ast_ = func->body;
-                        goto recurse;
-                    }
-                } break;
-
-                case FRAME_BUILTIN_FORCE_THUNKS: {
-                    const auto &ast = *static_cast<const Apply*>(f.ast);
-                    auto *func = static_cast<HeapClosure*>(f.val.v.h);
-                    if (f.elementId == f.thunks.size()) {
-                        // All thunks forced, now the builtin implementations.
-                        const LocationRange &loc = ast.location;
-                        const std::string &builtin_name = func->builtinName;
-                        std::vector<Value> args;
-                        for (auto *th : f.thunks) {
-                            args.push_back(th->content);
-                        }
-                        BuiltinMap::const_iterator bit = builtins.find(builtin_name);
-                        if (bit != builtins.end()) {
-                            const AST *new_ast = (this->*bit->second)(loc, args);
-                            if (new_ast != nullptr) {
-                                ast_ = new_ast;
-                                goto recurse;
-                            }
-                            break;
-                        }
-                        VmNativeCallbackMap::const_iterator nit =
-                            nativeCallbacks.find(builtin_name);
-                        // TODO(dcunnin): Support arrays.
-                        // TODO(dcunnin): Support objects.
-                        std::vector<JsonnetJsonValue> args2;
-                        for (const Value &arg : args) {
-                            switch (arg.t) {
-                                case Value::STRING:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::STRING,
-                                    encode_utf8(static_cast<HeapString*>(arg.v.h)->value),
-                                    0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
-
-                                case Value::BOOLEAN:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::BOOL,
-                                    "",
-                                    arg.v.b ? 1.0 : 0.0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
-
-                                case Value::DOUBLE:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::NUMBER,
-                                    "",
-                                    arg.v.d,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
-
-                                case Value::NULL_TYPE:
-                                args2.push_back(JsonnetJsonValue{
-                                    JsonnetJsonValue::NULL_KIND,
-                                    "",
-                                    0,
-                                    std::vector<std::unique_ptr<JsonnetJsonValue>>{},
-                                    std::map<std::string, std::unique_ptr<JsonnetJsonValue>>{},
-                                });
-                                break;
-
-                                default:
-                                throw makeError(ast.location,
-                                                "Native extensions can only take primitives.");
-                            }
-
-                        }
-                        std::vector<const JsonnetJsonValue*> args3;
-                        for (size_t i = 0; i < args2.size() ; ++i) {
-                            args3.push_back(&args2[i]);
-                        }
-                        if (nit == nativeCallbacks.end()) {
-                            throw makeError(ast.location,
-                                            "Unrecognized builtin name: " + builtin_name);
-                        }
-                        const VmNativeCallback &cb = nit->second;
-
-                        int succ;
-                        std::unique_ptr<JsonnetJsonValue> r(cb.cb(cb.ctx, &args3[0], &succ));
-
-                        if (succ) {
-                            bool unused;
-                            jsonToHeap(r, unused, scratch);
-                        } else {
-                            if (r->kind != JsonnetJsonValue::STRING) {
-                                throw makeError(
-                                    ast.location,
-                                    "Native extension returned an error that was not a string.");
-                            }
-                            std::string rs = r->string;
-                            throw makeError(ast.location, rs);
-                        }
-
-                    } else {
-                        // Not all arguments forced yet.
-                        HeapThunk *th = f.thunks[f.elementId++];
-                        if (!th->filled) {
-                            stack.newCall(ast.location, th, th->self, th->offset, th->upValues);
-                            ast_ = th->body;
-                            goto recurse;
-                        }
-                    }
-                } break;
-
-                case FRAME_CALL: {
-                    if (auto *thunk = dynamic_cast<HeapThunk*>(f.context)) {
-                        // If we called a thunk, cache result.
-                        thunk->fill(scratch);
-                    } else if (auto *closure = dynamic_cast<HeapClosure*>(f.context)) {
-                        if (f.elementId < f.thunks.size()) {
-                            // If tailstrict, force thunks
-                            HeapThunk *th = f.thunks[f.elementId++];
-                            if (!th->filled) {
-                                stack.newCall(f.location, th,
-                                              th->self, th->offset, th->upValues);
-                                ast_ = th->body;
-                                goto recurse;
-                            }
-                        } else if (f.thunks.size() == 0) {
-                            // Body has now been executed
-                        } else {
-                            // Execute the body
-                            f.thunks.clear();
-                            f.elementId = 0;
-                            ast_ = closure->body;
-                            goto recurse;
-                        }
-                    }
-                    // Result of call is in scratch, just pop.
-                } break;
-
-                case FRAME_ERROR: {
-                    const auto &ast = *static_cast<const Error*>(f.ast);
-                    UString msg;
-                    if (scratch.t == Value::STRING) {
-                        msg = static_cast<HeapString*>(scratch.v.h)->value;
-                    } else {
-                        msg = toString(ast.location);
-                    }
-                    throw makeError(ast.location, encode_utf8(msg));
-                } break;
-
-                case FRAME_IF: {
-                    const auto &ast = *static_cast<const Conditional*>(f.ast);
-                    if (scratch.t != Value::BOOLEAN) {
-                        throw makeError(ast.location, "Condition must be boolean, got " +
-                                                      type_str(scratch) + ".");
-                    }
-                    ast_ = scratch.v.b ? ast.branchTrue : ast.branchFalse;
-                    stack.pop();
-                    goto recurse;
-                } break;
-
-                case FRAME_SUPER_INDEX: {
-                    const auto &ast = *static_cast<const SuperIndex*>(f.ast);
-                    HeapObject *self;
-                    unsigned offset;
-                    stack.getSelfBinding(self, offset);
-                    offset++;
-                    if (offset >= countLeaves(self)) {
-                        throw makeError(ast.location,
-                                        "Attempt to use super when there is no super class.");
-                    }
-                    if (scratch.t != Value::STRING) {
-                        throw makeError(ast.location,
-                                        "Super index must be string, got "
-                                        + type_str(scratch) + ".");
-                    }
-
-                    const UString &index_name =
-                        static_cast<HeapString*>(scratch.v.h)->value;
-                    auto *fid = alloc->makeIdentifier(index_name);
-                    stack.pop();
-                    ast_ = objectIndex(ast.location, self, fid, offset);
-                    goto recurse;
-                } break;
-
-                case FRAME_IN_SUPER_ELEMENT: {
-                    const auto &ast = *static_cast<const InSuper*>(f.ast);
-                    HeapObject *self;
-                    unsigned offset;
-                    stack.getSelfBinding(self, offset);
-                    offset++;
-                    if (scratch.t != Value::STRING) {
-                        throw makeError(ast.location,
-                                        "Left hand side of e in super must be string, got "
-                                        + type_str(scratch) + ".");
-                    }
-                    if (offset >= countLeaves(self)) {
-                        // There is no super object.
-                        scratch = makeBoolean(false);
-                    } else {
-                        const UString &element_name =
-                            static_cast<HeapString*>(scratch.v.h)->value;
-                        auto *fid = alloc->makeIdentifier(element_name);
-                        unsigned unused_found_at = 0;
-                        bool in = findObject(fid, self, offset, unused_found_at);
-                        scratch = makeBoolean(in);
-                    }
-                } break;
-
-                case FRAME_INDEX_INDEX: {
-                    const auto &ast = *static_cast<const Index*>(f.ast);
-                    const Value &target = f.val;
-                    if (target.t == Value::ARRAY) {
-                        const auto *array = static_cast<HeapArray*>(target.v.h);
-                        if (scratch.t != Value::DOUBLE) {
-                            throw makeError(ast.location, "Array index must be number, got "
-                                                          + type_str(scratch) + ".");
-                        }
-                        long i = long(scratch.v.d);
-                        long sz = array->elements.size();
-                        if (i < 0 || i >= sz) {
-                            std::stringstream ss;
-                            ss << "Array bounds error: " << i
-                               << " not within [0, " << sz << ")";
-                            throw makeError(ast.location, ss.str());
-                        }
-                        auto *thunk = array->elements[i];
-                        if (thunk->filled) {
-                            scratch = thunk->content;
-                        } else {
-                            stack.pop();
-                            stack.newCall(ast.location, thunk,
-                                          thunk->self, thunk->offset, thunk->upValues);
-                            ast_ = thunk->body;
-                            goto recurse;
-                        }
-                    } else if (target.t == Value::OBJECT) {
-                        auto *obj = static_cast<HeapObject*>(target.v.h);
-                        assert(obj != nullptr);
-                        if (scratch.t != Value::STRING) {
-                            throw makeError(ast.location,
-                                            "Object index must be string, got "
-                                            + type_str(scratch) + ".");
-                        }
-                        const UString &index_name =
-                            static_cast<HeapString*>(scratch.v.h)->value;
-                        auto *fid = alloc->makeIdentifier(index_name);
-                        stack.pop();
-                        ast_ = objectIndex(ast.location, obj, fid, 0);
-                        goto recurse;
-                    } else if (target.t == Value::STRING) {
-                        auto *obj = static_cast<HeapString*>(target.v.h);
-                        assert(obj != nullptr);
-                        if (scratch.t != Value::DOUBLE) {
-                            throw makeError(ast.location,
-                                            "UString index must be a number, got "
-                                            + type_str(scratch) + ".");
-                        }
-                        long sz = obj->value.length();
-                        long i = (long)scratch.v.d;
-                        if (i < 0 || i >= sz) {
-                            std::stringstream ss;
-                            ss << "UString bounds error: " << i
-                               << " not within [0, " << sz << ")";
-                            throw makeError(ast.location, ss.str());
-                        }
-                        char32_t ch[] = {obj->value[i], U'\0'};
-                        scratch = makeString(ch);
-                    } else {
-                        std::cerr << "INTERNAL ERROR: Not object / array / string." << std::endl;
-                        abort();
-                    }
-                } break;
-
-                case FRAME_INDEX_TARGET: {
-                    const auto &ast = *static_cast<const Index*>(f.ast);
-                    if (scratch.t != Value::ARRAY
-                        && scratch.t != Value::OBJECT
-                        && scratch.t != Value::STRING) {
-                        throw makeError(ast.location,
-                                        "Can only index objects, strings, and arrays, got "
-                                        + type_str(scratch) + ".");
-                    }
-                    f.val = scratch;
-                    f.kind = FRAME_INDEX_INDEX;
-                    if (scratch.t == Value::OBJECT) {
-                        auto *self = static_cast<HeapObject*>(scratch.v.h);
-                        if (!stack.alreadyExecutingInvariants(self)) {
-                            stack.newFrame(FRAME_INVARIANTS, ast.location);
-                            Frame &f2 = stack.top();
-                            f2.self = self;
-                            unsigned counter = 0;
-                            objectInvariants(self, self, counter, f2.thunks);
-                            if (f2.thunks.size() > 0) {
-                                auto *thunk = f2.thunks[0];
-                                f2.elementId = 1;
-                                stack.newCall(ast.location, thunk,
-                                              thunk->self, thunk->offset, thunk->upValues);
-                                ast_ = thunk->body;
-                                goto recurse;
-                            }
-                        }
-                    }
-                    ast_ = ast.index;
-                    goto recurse;
-                } break;
-
-                case FRAME_INVARIANTS: {
-                    if (f.elementId >= f.thunks.size()) {
-                        if (stack.size() == initial_stack_size + 1) {
-                            // Just pop, evaluate was invoked by runInvariants.
-                            break;
-                        }
-                        stack.pop();
-                        Frame &f2 = stack.top();
-                        const auto &ast = *static_cast<const Index*>(f2.ast);
-                        ast_ = ast.index;
-                        goto recurse;
-                    }
-                    auto *thunk = f.thunks[f.elementId++];
-                    stack.newCall(f.location, thunk,
-                                  thunk->self, thunk->offset, thunk->upValues);
-                    ast_ = thunk->body;
-                    goto recurse;
-                } break;
-
-                case FRAME_LOCAL: {
-                    // Result of execution is in scratch already.
-                } break;
-
-                case FRAME_OBJECT: {
-                    const auto &ast = *static_cast<const DesugaredObject*>(f.ast);
-                    if (scratch.t != Value::NULL_TYPE) {
-                        if (scratch.t != Value::STRING) {
-                            throw makeError(ast.location, "Field name was not a string.");
-                        }
-                        const auto &fname = static_cast<const HeapString*>(scratch.v.h)->value;
-                        const Identifier *fid = alloc->makeIdentifier(fname);
-                        if (f.objectFields.find(fid) != f.objectFields.end()) {
-                            std::string msg = "Duplicate field name: \""
-                                              + encode_utf8(fname) + "\"";
-                            throw makeError(ast.location, msg);
-                        }
-                        f.objectFields[fid].hide = f.fit->hide;
-                        f.objectFields[fid].body = f.fit->body;
-                    }
-                    f.fit++;
-                    if (f.fit != ast.fields.end()) {
-                        ast_ = f.fit->name;
-                        goto recurse;
-                    } else {
-                        auto env = capture(ast.freeVariables);
-                        scratch = makeObject<HeapSimpleObject>(env, f.objectFields, ast.asserts);
-                    }
-                } break;
-
-                case FRAME_OBJECT_COMP_ARRAY: {
-                    const auto &ast = *static_cast<const ObjectComprehensionSimple*>(f.ast);
-                    const Value &arr_v = scratch;
-                    if (scratch.t != Value::ARRAY) {
-                        throw makeError(ast.location,
-                                        "Object comprehension needs array, got "
-                                        + type_str(arr_v));
-                    }
-                    const auto *arr = static_cast<const HeapArray*>(arr_v.v.h);
-                    if (arr->elements.size() == 0) {
-                        // Degenerate case.  Just create the object now.
-                        scratch = makeObject<HeapComprehensionObject>(BindingFrame{}, ast.value,
-                                                                      ast.id, BindingFrame{});
-                    } else {
-                        f.kind = FRAME_OBJECT_COMP_ELEMENT;
-                        f.val = scratch;
-                        f.bindings[ast.id] = arr->elements[0];
-                        f.elementId = 0;
-                        ast_ = ast.field;
-                        goto recurse;
-                    }
-                } break;
-
-                case FRAME_OBJECT_COMP_ELEMENT: {
-                    const auto &ast = *static_cast<const ObjectComprehensionSimple*>(f.ast);
-                    const auto *arr = static_cast<const HeapArray*>(f.val.v.h);
-                    if (scratch.t != Value::STRING) {
-                        std::stringstream ss;
-                        ss << "field must be string, got: " << type_str(scratch);
-                        throw makeError(ast.location, ss.str());
-                    }
-                    const auto &fname = static_cast<const HeapString*>(scratch.v.h)->value;
-                    const Identifier *fid = alloc->makeIdentifier(fname);
-                    if (f.elements.find(fid) != f.elements.end()) {
-                        throw makeError(ast.location,
-                                        "Duplicate field name: \"" + encode_utf8(fname) + "\"");
-                    }
-                    f.elements[fid] = arr->elements[f.elementId];
-                    f.elementId++;
-
-                    if (f.elementId == arr->elements.size()) {
-                        auto env = capture(ast.freeVariables);
-                        scratch = makeObject<HeapComprehensionObject>(env, ast.value,
-                                                                      ast.id, f.elements);
-                    } else {
-                        f.bindings[ast.id] = arr->elements[f.elementId];
-                        ast_ = ast.field;
-                        goto recurse;
-                    }
-                } break;
-
-                case FRAME_STRING_CONCAT: {
-                    const auto &ast = *static_cast<const Binary*>(f.ast);
-                    const Value &lhs = stack.top().val;
-                    const Value &rhs = stack.top().val2;
-                    UString output;
-                    if (lhs.t == Value::STRING) {
-                        output.append(static_cast<const HeapString*>(lhs.v.h)->value);
-                    } else {
-                        scratch = lhs;
-                        output.append(toString(ast.left->location));
-                    }
-                    if (rhs.t == Value::STRING) {
-                        output.append(static_cast<const HeapString*>(rhs.v.h)->value);
-                    } else {
-                        scratch = rhs;
-                        output.append(toString(ast.right->location));
-                    }
-                    scratch = makeString(output);
-                } break;
-
-                case FRAME_UNARY: {
-                    const auto &ast = *static_cast<const Unary*>(f.ast);
-                    switch (scratch.t) {
-
-                        case Value::BOOLEAN:
-                        if (ast.op == UOP_NOT) {
-                            scratch = makeBoolean(!scratch.v.b);
-                        } else {
-                            throw makeError(ast.location,
-                                            "Unary operator " + uop_string(ast.op)
-                                            + " does not operate on booleans.");
-                        }
-                        break;
-
-                        case Value::DOUBLE:
-                        switch (ast.op) {
-                            case UOP_PLUS:
-                            break;
-
-                            case UOP_MINUS:
-                            scratch = makeDouble(-scratch.v.d);
-                            break;
-
-                            case UOP_BITWISE_NOT:
-                            scratch = makeDouble(~(long)(scratch.v.d));
-                            break;
-
-                            default:
-                            throw makeError(ast.location,
-                                            "Unary operator " + uop_string(ast.op)
-                                            + " does not operate on numbers.");
-                        }
-                        break;
-
-                        default:
-                            throw makeError(ast.location,
-                                            "Unary operator " + uop_string(ast.op) +
-                                            " does not operate on type " + type_str(scratch));
-                    }
-                } break;
-
-                default:
-                std::cerr << "INTERNAL ERROR: Unknown FrameKind:  " << f.kind << std::endl;
-                std::abort();
-            }
-
-            popframe:;
-
-            stack.pop();
-
-            replaceframe:;
-        }
-    }
-
-    /** Manifest the scratch value by evaluating any remaining fields, and then convert to JSON.
-     *
-     * This can trigger a garbage collection cycle.  Be sure to stash any objects that aren't
-     * reachable via the stack or heap.
-     *
-     * \param multiline If true, will print objects and arrays in an indented fashion.
-     */
-    UString manifestJson(const LocationRange &loc, bool multiline, const UString &indent)
-    {
-        // Printing fields means evaluating and binding them, which can trigger
-        // garbage collection.
-
-        UStringStream ss;
-        switch (scratch.t) {
-            case Value::ARRAY: {
-                HeapArray *arr = static_cast<HeapArray*>(scratch.v.h);
-                if (arr->elements.size() == 0) {
-                    ss << U"[ ]";
-                } else {
-                    const char32_t *prefix = multiline ? U"[\n" : U"[";
-                    UString indent2 = multiline ? indent + U"   " : indent;
-                    for (auto *thunk : arr->elements) {
-                        LocationRange tloc = thunk->body == nullptr
-                                           ? loc
-                                           : thunk->body->location;
-                        if (thunk->filled) {
-                            stack.newCall(loc, thunk, nullptr, 0, BindingFrame{});
-                            // Keep arr alive when scratch is overwritten
-                            stack.top().val = scratch;
-                            scratch = thunk->content;
-                        } else {
-                            stack.newCall(loc, thunk, thunk->self, thunk->offset, thunk->upValues);
-                            // Keep arr alive when scratch is overwritten
-                            stack.top().val = scratch;
-                            evaluate(thunk->body, stack.size());
-                        }
-                        auto element = manifestJson(tloc, multiline, indent2);
-                        // Restore scratch
-                        scratch = stack.top().val;
-                        stack.pop();
-                        ss << prefix << indent2 << element;
-                        prefix = multiline ? U",\n" : U", ";
-                    }
-                    ss << (multiline ? U"\n" : U"") << indent << U"]";
-                }
-            }
-            break;
-
-            case Value::BOOLEAN:
-            ss << (scratch.v.b ? U"true" : U"false");
-            break;
-
-            case Value::DOUBLE:
-            ss << decode_utf8(jsonnet_unparse_number(scratch.v.d));
-            break;
-
-            case Value::FUNCTION:
-            throw makeError(loc, "Couldn't manifest function in JSON output.");
-
-            case Value::NULL_TYPE:
-            ss << U"null";
-            break;
-
-            case Value::OBJECT: {
-                auto *obj = static_cast<HeapObject*>(scratch.v.h);
-                runInvariants(loc, obj);
-                // Using std::map has the useful side-effect of ordering the fields
-                // alphabetically.
-                std::map<UString, const Identifier*> fields;
-                for (const auto &f : objectFields(obj, true)) {
-                    fields[f->name] = f;
-                }
-                if (fields.size() == 0) {
-                    ss << U"{ }";
-                } else {
-                    UString indent2 = multiline ? indent + U"   " : indent;
-                    const char32_t *prefix = multiline ? U"{\n" : U"{";
-                    for (const auto &f : fields) {
-                        // pushes FRAME_CALL
-                        const AST *body = objectIndex(loc, obj, f.second, 0);
-                        stack.top().val = scratch;
-                        evaluate(body, stack.size());
-                        auto vstr = manifestJson(body->location, multiline, indent2);
-                        // Reset scratch so that the object we're manifesting doesn't
-                        // get GC'd.
-                        scratch = stack.top().val;
-                        stack.pop();
-                        ss << prefix << indent2 << jsonnet_string_unparse(f.first, false)
-                           << U": " << vstr;
-                        prefix = multiline ? U",\n" : U", ";
-                    }
-                    ss << (multiline ? U"\n" : U"") << indent << U"}";
-                }
-            }
-            break;
-
-            case Value::STRING: {
-                const UString &str = static_cast<HeapString*>(scratch.v.h)->value;
-                ss << jsonnet_string_unparse(str, false);
-            }
-            break;
-        }
-        return ss.str();
-    }
-
-    UString manifestString(const LocationRange &loc)
-    {
-        if (scratch.t != Value::STRING) {
-            std::stringstream ss;
-            ss << "Expected string result, got: " << type_str(scratch.t);
-            throw makeError(loc, ss.str());
-        }
-        return static_cast<HeapString*>(scratch.v.h)->value;
-    }
-
-    StrMap manifestMulti(bool string)
-    {
-        StrMap r;
-        LocationRange loc("During manifestation");
-        if (scratch.t != Value::OBJECT) {
-            std::stringstream ss;
-            ss << "Multi mode: Top-level object was a " << type_str(scratch.t) << ", "
-               << "should be an object whose keys are filenames and values hold "
-               << "the JSON for that file.";
-            throw makeError(loc, ss.str());
-        }
-        auto *obj = static_cast<HeapObject*>(scratch.v.h);
-        runInvariants(loc, obj);
-        std::map<UString, const Identifier*> fields;
-        for (const auto &f : objectFields(obj, true)) {
-            fields[f->name] = f;
-        }
-        for (const auto &f : fields) {
-            // pushes FRAME_CALL
-            const AST *body = objectIndex(loc, obj, f.second, 0);
-            stack.top().val = scratch;
-            evaluate(body, stack.size());
-            auto vstr = string ? manifestString(body->location)
-                               : manifestJson(body->location, true, U"");
-            // Reset scratch so that the object we're manifesting doesn't
-            // get GC'd.
-            scratch = stack.top().val;
-            stack.pop();
-            r[encode_utf8(f.first)] = encode_utf8(vstr);
-        }
-        return r;
-    }
-
-    std::vector<std::string> manifestStream(void)
-    {
-        std::vector<std::string> r;
-        LocationRange loc("During manifestation");
-        if (scratch.t != Value::ARRAY) {
-            std::stringstream ss;
-            ss << "Stream mode: Top-level object was a " << type_str(scratch.t) << ", "
-               << "should be an array whose elements hold "
-               << "the JSON for each document in the stream.";
-            throw makeError(loc, ss.str());
-        }
-        auto *arr = static_cast<HeapArray*>(scratch.v.h);
-        for (auto *thunk : arr->elements) {
-            LocationRange tloc = thunk->body == nullptr
-                               ? loc
-                               : thunk->body->location;
-            if (thunk->filled) {
-                stack.newCall(loc, thunk, nullptr, 0, BindingFrame{});
-                // Keep arr alive when scratch is overwritten
-                stack.top().val = scratch;
-                scratch = thunk->content;
-            } else {
-                stack.newCall(loc, thunk, thunk->self, thunk->offset, thunk->upValues);
-                // Keep arr alive when scratch is overwritten
-                stack.top().val = scratch;
-                evaluate(thunk->body, stack.size());
-            }
-            UString element = manifestJson(tloc, true, U"");
-            scratch = stack.top().val;
-            stack.pop();
-            r.push_back(encode_utf8(element));
-        }
-        return r;
-    }
-
-};
-
-}  // namespace
-
-std::string jsonnet_vm_execute(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx,
-    bool string_output)
-{
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
-    vm.evaluate(ast, 0);
-    if (string_output) {
-        return encode_utf8(vm.manifestString(LocationRange("During manifestation")));
-    } else {
-        return encode_utf8(vm.manifestJson(LocationRange("During manifestation"), true, U""));
-    }
-}
-
-StrMap jsonnet_vm_execute_multi(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx,
-    bool string_output)
-{
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
-    vm.evaluate(ast, 0);
-    return vm.manifestMulti(string_output);
-}
-
-std::vector<std::string> jsonnet_vm_execute_stream(
-    Allocator *alloc,
-    const AST *ast,
-    const ExtMap &ext_vars,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *ctx)
-{
-    Interpreter vm(alloc, ext_vars, max_stack, gc_min_objects, gc_growth_trigger,
-                   natives, import_callback, ctx);
-    vm.evaluate(ast, 0);
-    return vm.manifestStream();
-}
-
-
diff --git a/vendor/github.com/strickyak/jsonnet_cgo/vm.h b/vendor/github.com/strickyak/jsonnet_cgo/vm.h
deleted file mode 100644
index 2f6f7bd7587aa1e128deffea68fe1eebc7c0faaf..0000000000000000000000000000000000000000
--- a/vendor/github.com/strickyak/jsonnet_cgo/vm.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#ifndef JSONNET_VM_H
-#define JSONNET_VM_H
-
-#include <libjsonnet.h>
-
-#include "ast.h"
-
-/** A single line of a stack trace from a runtime error.
- */
-struct TraceFrame {
-    LocationRange location;
-    std::string name;
-    TraceFrame(const LocationRange &location, const std::string &name="")
-      : location(location), name(name)
-    { }
-};
-
-/** Exception that is thrown by the interpreter when it reaches an error construct, or divide by
- * zero, array bounds error, dynamic type error, etc.
- */
-struct RuntimeError {
-    std::vector<TraceFrame> stackTrace;
-    std::string msg;
-    RuntimeError(const std::vector<TraceFrame> stack_trace, const std::string &msg)
-      : stackTrace(stack_trace), msg(msg)
-    { }
-};
-
-/** Holds native callback and context. */
-struct VmNativeCallback {
-    JsonnetNativeCallback *cb;
-    void *ctx;
-    std::vector<std::string> params;
-};
-
-typedef std::map<std::string, VmNativeCallback> VmNativeCallbackMap;
-
-/** Stores external values / code. */
-struct VmExt {
-    std::string data;
-    bool isCode;
-    VmExt() : isCode(false) { }
-    VmExt(const std::string &data, bool is_code)
-      : data(data), isCode(is_code)
-    { }
-};
-
-
-/** Execute the program and return the value as a JSON string.
- *
- * \param alloc The allocator used to create the ast.
- * \param ast The program to execute.
- * \param ext The external vars / code.
- * \param max_stack Recursion beyond this level gives an error.
- * \param gc_min_objects The garbage collector does not run when the heap is this small.
- * \param gc_growth_trigger Growth since last garbage collection cycle to trigger a new cycle.
- * \param import_callback A callback to handle imports
- * \param import_callback_ctx Context param for the import callback.
- * \param output_string Whether to expect a string and output it without JSON encoding
- * \throws RuntimeError reports runtime errors in the program.
- * \returns The JSON result in string form.
- */
-std::string jsonnet_vm_execute(
-    Allocator *alloc, const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx,
-    bool string_output);
-
-/** Execute the program and return the value as a number of named JSON files.
- *
- * This assumes the given program yields an object whose keys are filenames.
- *
- * \param alloc The allocator used to create the ast.
- * \param ast The program to execute.
- * \param ext The external vars / code.
- * \param tla The top-level arguments (strings or code).
- * \param max_stack Recursion beyond this level gives an error.
- * \param gc_min_objects The garbage collector does not run when the heap is this small.
- * \param gc_growth_trigger Growth since last garbage collection cycle to trigger a new cycle.
- * \param import_callback A callback to handle imports
- * \param import_callback_ctx Context param for the import callback.
- * \param output_string Whether to expect a string and output it without JSON encoding
- * \throws RuntimeError reports runtime errors in the program.
- * \returns A mapping from filename to the JSON strings for that file.
- */
-std::map<std::string, std::string> jsonnet_vm_execute_multi(
-    Allocator *alloc,
-    const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx,
-    bool string_output);
-
-/** Execute the program and return the value as a stream of JSON files.
- *
- * This assumes the given program yields an array whose elements are individual
- * JSON files.
- *
- * \param alloc The allocator used to create the ast.
- * \param ast The program to execute.
- * \param ext The external vars / code.
- * \param tla The top-level arguments (strings or code).
- * \param max_stack Recursion beyond this level gives an error.
- * \param gc_min_objects The garbage collector does not run when the heap is this small.
- * \param gc_growth_trigger Growth since last garbage collection cycle to trigger a new cycle.
- * \param import_callback A callback to handle imports
- * \param import_callback_ctx Context param for the import callback.
- * \param output_string Whether to expect a string and output it without JSON encoding
- * \throws RuntimeError reports runtime errors in the program.
- * \returns A mapping from filename to the JSON strings for that file.
- */
-std::vector<std::string> jsonnet_vm_execute_stream(
-    Allocator *alloc,
-    const AST *ast,
-    const std::map<std::string, VmExt> &ext,
-    unsigned max_stack,
-    double gc_min_objects,
-    double gc_growth_trigger,
-    const VmNativeCallbackMap &natives,
-    JsonnetImportCallback *import_callback,
-    void *import_callback_ctx);
-
-#endif
diff --git a/vendor/github.com/golang/protobuf/LICENSE b/vendor/golang.org/x/tools/LICENSE
similarity index 78%
rename from vendor/github.com/golang/protobuf/LICENSE
rename to vendor/golang.org/x/tools/LICENSE
index 1b1b1921efa6dded19f74b196f76a96bf39c83dc..6a66aea5eafe0ca6a688840c47219556c552488e 100644
--- a/vendor/github.com/golang/protobuf/LICENSE
+++ b/vendor/golang.org/x/tools/LICENSE
@@ -1,19 +1,16 @@
-Go support for Protocol Buffers - Google's data interchange format
-
-Copyright 2010 The Go Authors.  All rights reserved.
-https://github.com/golang/protobuf
+Copyright (c) 2009 The Go Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 
-    * Redistributions of source code must retain the above copyright
+   * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
+   * Redistributions in binary form must reproduce the above
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
-    * Neither the name of Google Inc. nor the names of its
+   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 
@@ -28,4 +25,3 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
diff --git a/vendor/golang.org/x/tools/PATENTS b/vendor/golang.org/x/tools/PATENTS
new file mode 100644
index 0000000000000000000000000000000000000000..733099041f84fa1e58611ab2e11af51c1f26d1d2
--- /dev/null
+++ b/vendor/golang.org/x/tools/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go b/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b7052b892ca07ba23a1eddd35645d50992dc42c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
@@ -0,0 +1,627 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package astutil
+
+// This file defines utilities for working with source positions.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"sort"
+)
+
+// PathEnclosingInterval returns the node that encloses the source
+// interval [start, end), and all its ancestors up to the AST root.
+//
+// The definition of "enclosing" used by this function considers
+// additional whitespace abutting a node to be enclosed by it.
+// In this example:
+//
+//              z := x + y // add them
+//                   <-A->
+//                  <----B----->
+//
+// the ast.BinaryExpr(+) node is considered to enclose interval B
+// even though its [Pos()..End()) is actually only interval A.
+// This behaviour makes user interfaces more tolerant of imperfect
+// input.
+//
+// This function treats tokens as nodes, though they are not included
+// in the result. e.g. PathEnclosingInterval("+") returns the
+// enclosing ast.BinaryExpr("x + y").
+//
+// If start==end, the 1-char interval following start is used instead.
+//
+// The 'exact' result is true if the interval contains only path[0]
+// and perhaps some adjacent whitespace.  It is false if the interval
+// overlaps multiple children of path[0], or if it contains only
+// interior whitespace of path[0].
+// In this example:
+//
+//              z := x + y // add them
+//                <--C-->     <---E-->
+//                  ^
+//                  D
+//
+// intervals C, D and E are inexact.  C is contained by the
+// z-assignment statement, because it spans three of its children (:=,
+// x, +).  So too is the 1-char interval D, because it contains only
+// interior whitespace of the assignment.  E is considered interior
+// whitespace of the BlockStmt containing the assignment.
+//
+// Precondition: [start, end) both lie within the same file as root.
+// TODO(adonovan): return (nil, false) in this case and remove precond.
+// Requires FileSet; see loader.tokenFileContainsPos.
+//
+// Postcondition: path is never nil; it always contains at least 'root'.
+//
+func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool) {
+	// fmt.Printf("EnclosingInterval %d %d\n", start, end) // debugging
+
+	// Precondition: node.[Pos..End) and adjoining whitespace contain [start, end).
+	var visit func(node ast.Node) bool
+	visit = func(node ast.Node) bool {
+		path = append(path, node)
+
+		nodePos := node.Pos()
+		nodeEnd := node.End()
+
+		// fmt.Printf("visit(%T, %d, %d)\n", node, nodePos, nodeEnd) // debugging
+
+		// Intersect [start, end) with interval of node.
+		if start < nodePos {
+			start = nodePos
+		}
+		if end > nodeEnd {
+			end = nodeEnd
+		}
+
+		// Find sole child that contains [start, end).
+		children := childrenOf(node)
+		l := len(children)
+		for i, child := range children {
+			// [childPos, childEnd) is unaugmented interval of child.
+			childPos := child.Pos()
+			childEnd := child.End()
+
+			// [augPos, augEnd) is whitespace-augmented interval of child.
+			augPos := childPos
+			augEnd := childEnd
+			if i > 0 {
+				augPos = children[i-1].End() // start of preceding whitespace
+			}
+			if i < l-1 {
+				nextChildPos := children[i+1].Pos()
+				// Does [start, end) lie between child and next child?
+				if start >= augEnd && end <= nextChildPos {
+					return false // inexact match
+				}
+				augEnd = nextChildPos // end of following whitespace
+			}
+
+			// fmt.Printf("\tchild %d: [%d..%d)\tcontains interval [%d..%d)?\n",
+			// 	i, augPos, augEnd, start, end) // debugging
+
+			// Does augmented child strictly contain [start, end)?
+			if augPos <= start && end <= augEnd {
+				_, isToken := child.(tokenNode)
+				return isToken || visit(child)
+			}
+
+			// Does [start, end) overlap multiple children?
+			// i.e. left-augmented child contains start
+			// but LR-augmented child does not contain end.
+			if start < childEnd && end > augEnd {
+				break
+			}
+		}
+
+		// No single child contained [start, end),
+		// so node is the result.  Is it exact?
+
+		// (It's tempting to put this condition before the
+		// child loop, but it gives the wrong result in the
+		// case where a node (e.g. ExprStmt) and its sole
+		// child have equal intervals.)
+		if start == nodePos && end == nodeEnd {
+			return true // exact match
+		}
+
+		return false // inexact: overlaps multiple children
+	}
+
+	if start > end {
+		start, end = end, start
+	}
+
+	if start < root.End() && end > root.Pos() {
+		if start == end {
+			end = start + 1 // empty interval => interval of size 1
+		}
+		exact = visit(root)
+
+		// Reverse the path:
+		for i, l := 0, len(path); i < l/2; i++ {
+			path[i], path[l-1-i] = path[l-1-i], path[i]
+		}
+	} else {
+		// Selection lies within whitespace preceding the
+		// first (or following the last) declaration in the file.
+		// The result nonetheless always includes the ast.File.
+		path = append(path, root)
+	}
+
+	return
+}
+
+// tokenNode is a dummy implementation of ast.Node for a single token.
+// They are used transiently by PathEnclosingInterval but never escape
+// this package.
+//
+type tokenNode struct {
+	pos token.Pos
+	end token.Pos
+}
+
+func (n tokenNode) Pos() token.Pos {
+	return n.pos
+}
+
+func (n tokenNode) End() token.Pos {
+	return n.end
+}
+
+func tok(pos token.Pos, len int) ast.Node {
+	return tokenNode{pos, pos + token.Pos(len)}
+}
+
+// childrenOf returns the direct non-nil children of ast.Node n.
+// It may include fake ast.Node implementations for bare tokens.
+// it is not safe to call (e.g.) ast.Walk on such nodes.
+//
+func childrenOf(n ast.Node) []ast.Node {
+	var children []ast.Node
+
+	// First add nodes for all true subtrees.
+	ast.Inspect(n, func(node ast.Node) bool {
+		if node == n { // push n
+			return true // recur
+		}
+		if node != nil { // push child
+			children = append(children, node)
+		}
+		return false // no recursion
+	})
+
+	// Then add fake Nodes for bare tokens.
+	switch n := n.(type) {
+	case *ast.ArrayType:
+		children = append(children,
+			tok(n.Lbrack, len("[")),
+			tok(n.Elt.End(), len("]")))
+
+	case *ast.AssignStmt:
+		children = append(children,
+			tok(n.TokPos, len(n.Tok.String())))
+
+	case *ast.BasicLit:
+		children = append(children,
+			tok(n.ValuePos, len(n.Value)))
+
+	case *ast.BinaryExpr:
+		children = append(children, tok(n.OpPos, len(n.Op.String())))
+
+	case *ast.BlockStmt:
+		children = append(children,
+			tok(n.Lbrace, len("{")),
+			tok(n.Rbrace, len("}")))
+
+	case *ast.BranchStmt:
+		children = append(children,
+			tok(n.TokPos, len(n.Tok.String())))
+
+	case *ast.CallExpr:
+		children = append(children,
+			tok(n.Lparen, len("(")),
+			tok(n.Rparen, len(")")))
+		if n.Ellipsis != 0 {
+			children = append(children, tok(n.Ellipsis, len("...")))
+		}
+
+	case *ast.CaseClause:
+		if n.List == nil {
+			children = append(children,
+				tok(n.Case, len("default")))
+		} else {
+			children = append(children,
+				tok(n.Case, len("case")))
+		}
+		children = append(children, tok(n.Colon, len(":")))
+
+	case *ast.ChanType:
+		switch n.Dir {
+		case ast.RECV:
+			children = append(children, tok(n.Begin, len("<-chan")))
+		case ast.SEND:
+			children = append(children, tok(n.Begin, len("chan<-")))
+		case ast.RECV | ast.SEND:
+			children = append(children, tok(n.Begin, len("chan")))
+		}
+
+	case *ast.CommClause:
+		if n.Comm == nil {
+			children = append(children,
+				tok(n.Case, len("default")))
+		} else {
+			children = append(children,
+				tok(n.Case, len("case")))
+		}
+		children = append(children, tok(n.Colon, len(":")))
+
+	case *ast.Comment:
+		// nop
+
+	case *ast.CommentGroup:
+		// nop
+
+	case *ast.CompositeLit:
+		children = append(children,
+			tok(n.Lbrace, len("{")),
+			tok(n.Rbrace, len("{")))
+
+	case *ast.DeclStmt:
+		// nop
+
+	case *ast.DeferStmt:
+		children = append(children,
+			tok(n.Defer, len("defer")))
+
+	case *ast.Ellipsis:
+		children = append(children,
+			tok(n.Ellipsis, len("...")))
+
+	case *ast.EmptyStmt:
+		// nop
+
+	case *ast.ExprStmt:
+		// nop
+
+	case *ast.Field:
+		// TODO(adonovan): Field.{Doc,Comment,Tag}?
+
+	case *ast.FieldList:
+		children = append(children,
+			tok(n.Opening, len("(")),
+			tok(n.Closing, len(")")))
+
+	case *ast.File:
+		// TODO test: Doc
+		children = append(children,
+			tok(n.Package, len("package")))
+
+	case *ast.ForStmt:
+		children = append(children,
+			tok(n.For, len("for")))
+
+	case *ast.FuncDecl:
+		// TODO(adonovan): FuncDecl.Comment?
+
+		// Uniquely, FuncDecl breaks the invariant that
+		// preorder traversal yields tokens in lexical order:
+		// in fact, FuncDecl.Recv precedes FuncDecl.Type.Func.
+		//
+		// As a workaround, we inline the case for FuncType
+		// here and order things correctly.
+		//
+		children = nil // discard ast.Walk(FuncDecl) info subtrees
+		children = append(children, tok(n.Type.Func, len("func")))
+		if n.Recv != nil {
+			children = append(children, n.Recv)
+		}
+		children = append(children, n.Name)
+		if n.Type.Params != nil {
+			children = append(children, n.Type.Params)
+		}
+		if n.Type.Results != nil {
+			children = append(children, n.Type.Results)
+		}
+		if n.Body != nil {
+			children = append(children, n.Body)
+		}
+
+	case *ast.FuncLit:
+		// nop
+
+	case *ast.FuncType:
+		if n.Func != 0 {
+			children = append(children,
+				tok(n.Func, len("func")))
+		}
+
+	case *ast.GenDecl:
+		children = append(children,
+			tok(n.TokPos, len(n.Tok.String())))
+		if n.Lparen != 0 {
+			children = append(children,
+				tok(n.Lparen, len("(")),
+				tok(n.Rparen, len(")")))
+		}
+
+	case *ast.GoStmt:
+		children = append(children,
+			tok(n.Go, len("go")))
+
+	case *ast.Ident:
+		children = append(children,
+			tok(n.NamePos, len(n.Name)))
+
+	case *ast.IfStmt:
+		children = append(children,
+			tok(n.If, len("if")))
+
+	case *ast.ImportSpec:
+		// TODO(adonovan): ImportSpec.{Doc,EndPos}?
+
+	case *ast.IncDecStmt:
+		children = append(children,
+			tok(n.TokPos, len(n.Tok.String())))
+
+	case *ast.IndexExpr:
+		children = append(children,
+			tok(n.Lbrack, len("{")),
+			tok(n.Rbrack, len("}")))
+
+	case *ast.InterfaceType:
+		children = append(children,
+			tok(n.Interface, len("interface")))
+
+	case *ast.KeyValueExpr:
+		children = append(children,
+			tok(n.Colon, len(":")))
+
+	case *ast.LabeledStmt:
+		children = append(children,
+			tok(n.Colon, len(":")))
+
+	case *ast.MapType:
+		children = append(children,
+			tok(n.Map, len("map")))
+
+	case *ast.ParenExpr:
+		children = append(children,
+			tok(n.Lparen, len("(")),
+			tok(n.Rparen, len(")")))
+
+	case *ast.RangeStmt:
+		children = append(children,
+			tok(n.For, len("for")),
+			tok(n.TokPos, len(n.Tok.String())))
+
+	case *ast.ReturnStmt:
+		children = append(children,
+			tok(n.Return, len("return")))
+
+	case *ast.SelectStmt:
+		children = append(children,
+			tok(n.Select, len("select")))
+
+	case *ast.SelectorExpr:
+		// nop
+
+	case *ast.SendStmt:
+		children = append(children,
+			tok(n.Arrow, len("<-")))
+
+	case *ast.SliceExpr:
+		children = append(children,
+			tok(n.Lbrack, len("[")),
+			tok(n.Rbrack, len("]")))
+
+	case *ast.StarExpr:
+		children = append(children, tok(n.Star, len("*")))
+
+	case *ast.StructType:
+		children = append(children, tok(n.Struct, len("struct")))
+
+	case *ast.SwitchStmt:
+		children = append(children, tok(n.Switch, len("switch")))
+
+	case *ast.TypeAssertExpr:
+		children = append(children,
+			tok(n.Lparen-1, len(".")),
+			tok(n.Lparen, len("(")),
+			tok(n.Rparen, len(")")))
+
+	case *ast.TypeSpec:
+		// TODO(adonovan): TypeSpec.{Doc,Comment}?
+
+	case *ast.TypeSwitchStmt:
+		children = append(children, tok(n.Switch, len("switch")))
+
+	case *ast.UnaryExpr:
+		children = append(children, tok(n.OpPos, len(n.Op.String())))
+
+	case *ast.ValueSpec:
+		// TODO(adonovan): ValueSpec.{Doc,Comment}?
+
+	case *ast.BadDecl, *ast.BadExpr, *ast.BadStmt:
+		// nop
+	}
+
+	// TODO(adonovan): opt: merge the logic of ast.Inspect() into
+	// the switch above so we can make interleaved callbacks for
+	// both Nodes and Tokens in the right order and avoid the need
+	// to sort.
+	sort.Sort(byPos(children))
+
+	return children
+}
+
+type byPos []ast.Node
+
+func (sl byPos) Len() int {
+	return len(sl)
+}
+func (sl byPos) Less(i, j int) bool {
+	return sl[i].Pos() < sl[j].Pos()
+}
+func (sl byPos) Swap(i, j int) {
+	sl[i], sl[j] = sl[j], sl[i]
+}
+
+// NodeDescription returns a description of the concrete type of n suitable
+// for a user interface.
+//
+// TODO(adonovan): in some cases (e.g. Field, FieldList, Ident,
+// StarExpr) we could be much more specific given the path to the AST
+// root.  Perhaps we should do that.
+//
+func NodeDescription(n ast.Node) string {
+	switch n := n.(type) {
+	case *ast.ArrayType:
+		return "array type"
+	case *ast.AssignStmt:
+		return "assignment"
+	case *ast.BadDecl:
+		return "bad declaration"
+	case *ast.BadExpr:
+		return "bad expression"
+	case *ast.BadStmt:
+		return "bad statement"
+	case *ast.BasicLit:
+		return "basic literal"
+	case *ast.BinaryExpr:
+		return fmt.Sprintf("binary %s operation", n.Op)
+	case *ast.BlockStmt:
+		return "block"
+	case *ast.BranchStmt:
+		switch n.Tok {
+		case token.BREAK:
+			return "break statement"
+		case token.CONTINUE:
+			return "continue statement"
+		case token.GOTO:
+			return "goto statement"
+		case token.FALLTHROUGH:
+			return "fall-through statement"
+		}
+	case *ast.CallExpr:
+		if len(n.Args) == 1 && !n.Ellipsis.IsValid() {
+			return "function call (or conversion)"
+		}
+		return "function call"
+	case *ast.CaseClause:
+		return "case clause"
+	case *ast.ChanType:
+		return "channel type"
+	case *ast.CommClause:
+		return "communication clause"
+	case *ast.Comment:
+		return "comment"
+	case *ast.CommentGroup:
+		return "comment group"
+	case *ast.CompositeLit:
+		return "composite literal"
+	case *ast.DeclStmt:
+		return NodeDescription(n.Decl) + " statement"
+	case *ast.DeferStmt:
+		return "defer statement"
+	case *ast.Ellipsis:
+		return "ellipsis"
+	case *ast.EmptyStmt:
+		return "empty statement"
+	case *ast.ExprStmt:
+		return "expression statement"
+	case *ast.Field:
+		// Can be any of these:
+		// struct {x, y int}  -- struct field(s)
+		// struct {T}         -- anon struct field
+		// interface {I}      -- interface embedding
+		// interface {f()}    -- interface method
+		// func (A) func(B) C -- receiver, param(s), result(s)
+		return "field/method/parameter"
+	case *ast.FieldList:
+		return "field/method/parameter list"
+	case *ast.File:
+		return "source file"
+	case *ast.ForStmt:
+		return "for loop"
+	case *ast.FuncDecl:
+		return "function declaration"
+	case *ast.FuncLit:
+		return "function literal"
+	case *ast.FuncType:
+		return "function type"
+	case *ast.GenDecl:
+		switch n.Tok {
+		case token.IMPORT:
+			return "import declaration"
+		case token.CONST:
+			return "constant declaration"
+		case token.TYPE:
+			return "type declaration"
+		case token.VAR:
+			return "variable declaration"
+		}
+	case *ast.GoStmt:
+		return "go statement"
+	case *ast.Ident:
+		return "identifier"
+	case *ast.IfStmt:
+		return "if statement"
+	case *ast.ImportSpec:
+		return "import specification"
+	case *ast.IncDecStmt:
+		if n.Tok == token.INC {
+			return "increment statement"
+		}
+		return "decrement statement"
+	case *ast.IndexExpr:
+		return "index expression"
+	case *ast.InterfaceType:
+		return "interface type"
+	case *ast.KeyValueExpr:
+		return "key/value association"
+	case *ast.LabeledStmt:
+		return "statement label"
+	case *ast.MapType:
+		return "map type"
+	case *ast.Package:
+		return "package"
+	case *ast.ParenExpr:
+		return "parenthesized " + NodeDescription(n.X)
+	case *ast.RangeStmt:
+		return "range loop"
+	case *ast.ReturnStmt:
+		return "return statement"
+	case *ast.SelectStmt:
+		return "select statement"
+	case *ast.SelectorExpr:
+		return "selector"
+	case *ast.SendStmt:
+		return "channel send"
+	case *ast.SliceExpr:
+		return "slice expression"
+	case *ast.StarExpr:
+		return "*-operation" // load/store expr or pointer type
+	case *ast.StructType:
+		return "struct type"
+	case *ast.SwitchStmt:
+		return "switch statement"
+	case *ast.TypeAssertExpr:
+		return "type assertion"
+	case *ast.TypeSpec:
+		return "type specification"
+	case *ast.TypeSwitchStmt:
+		return "type switch"
+	case *ast.UnaryExpr:
+		return fmt.Sprintf("unary %s operation", n.Op)
+	case *ast.ValueSpec:
+		return "value specification"
+
+	}
+	panic(fmt.Sprintf("unexpected node type: %T", n))
+}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/imports.go b/vendor/golang.org/x/tools/go/ast/astutil/imports.go
new file mode 100644
index 0000000000000000000000000000000000000000..83f196cd5e5990cdc7301821458e347bd1b267ec
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/imports.go
@@ -0,0 +1,470 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package astutil contains common utilities for working with the Go AST.
+package astutil // import "golang.org/x/tools/go/ast/astutil"
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strconv"
+	"strings"
+)
+
+// AddImport adds the import path to the file f, if absent.
+func AddImport(fset *token.FileSet, f *ast.File, ipath string) (added bool) {
+	return AddNamedImport(fset, f, "", ipath)
+}
+
+// AddNamedImport adds the import path to the file f, if absent.
+// If name is not empty, it is used to rename the import.
+//
+// For example, calling
+//	AddNamedImport(fset, f, "pathpkg", "path")
+// adds
+//	import pathpkg "path"
+func AddNamedImport(fset *token.FileSet, f *ast.File, name, ipath string) (added bool) {
+	if imports(f, ipath) {
+		return false
+	}
+
+	newImport := &ast.ImportSpec{
+		Path: &ast.BasicLit{
+			Kind:  token.STRING,
+			Value: strconv.Quote(ipath),
+		},
+	}
+	if name != "" {
+		newImport.Name = &ast.Ident{Name: name}
+	}
+
+	// Find an import decl to add to.
+	// The goal is to find an existing import
+	// whose import path has the longest shared
+	// prefix with ipath.
+	var (
+		bestMatch  = -1         // length of longest shared prefix
+		lastImport = -1         // index in f.Decls of the file's final import decl
+		impDecl    *ast.GenDecl // import decl containing the best match
+		impIndex   = -1         // spec index in impDecl containing the best match
+
+		isThirdPartyPath = isThirdParty(ipath)
+	)
+	for i, decl := range f.Decls {
+		gen, ok := decl.(*ast.GenDecl)
+		if ok && gen.Tok == token.IMPORT {
+			lastImport = i
+			// Do not add to import "C", to avoid disrupting the
+			// association with its doc comment, breaking cgo.
+			if declImports(gen, "C") {
+				continue
+			}
+
+			// Match an empty import decl if that's all that is available.
+			if len(gen.Specs) == 0 && bestMatch == -1 {
+				impDecl = gen
+			}
+
+			// Compute longest shared prefix with imports in this group and find best
+			// matched import spec.
+			// 1. Always prefer import spec with longest shared prefix.
+			// 2. While match length is 0,
+			// - for stdlib package: prefer first import spec.
+			// - for third party package: prefer first third party import spec.
+			// We cannot use last import spec as best match for third party package
+			// because grouped imports are usually placed last by goimports -local
+			// flag.
+			// See issue #19190.
+			seenAnyThirdParty := false
+			for j, spec := range gen.Specs {
+				impspec := spec.(*ast.ImportSpec)
+				p := importPath(impspec)
+				n := matchLen(p, ipath)
+				if n > bestMatch || (bestMatch == 0 && !seenAnyThirdParty && isThirdPartyPath) {
+					bestMatch = n
+					impDecl = gen
+					impIndex = j
+				}
+				seenAnyThirdParty = seenAnyThirdParty || isThirdParty(p)
+			}
+		}
+	}
+
+	// If no import decl found, add one after the last import.
+	if impDecl == nil {
+		impDecl = &ast.GenDecl{
+			Tok: token.IMPORT,
+		}
+		if lastImport >= 0 {
+			impDecl.TokPos = f.Decls[lastImport].End()
+		} else {
+			// There are no existing imports.
+			// Our new import goes after the package declaration and after
+			// the comment, if any, that starts on the same line as the
+			// package declaration.
+			impDecl.TokPos = f.Package
+
+			file := fset.File(f.Package)
+			pkgLine := file.Line(f.Package)
+			for _, c := range f.Comments {
+				if file.Line(c.Pos()) > pkgLine {
+					break
+				}
+				impDecl.TokPos = c.End()
+			}
+		}
+		f.Decls = append(f.Decls, nil)
+		copy(f.Decls[lastImport+2:], f.Decls[lastImport+1:])
+		f.Decls[lastImport+1] = impDecl
+	}
+
+	// Insert new import at insertAt.
+	insertAt := 0
+	if impIndex >= 0 {
+		// insert after the found import
+		insertAt = impIndex + 1
+	}
+	impDecl.Specs = append(impDecl.Specs, nil)
+	copy(impDecl.Specs[insertAt+1:], impDecl.Specs[insertAt:])
+	impDecl.Specs[insertAt] = newImport
+	pos := impDecl.Pos()
+	if insertAt > 0 {
+		// If there is a comment after an existing import, preserve the comment
+		// position by adding the new import after the comment.
+		if spec, ok := impDecl.Specs[insertAt-1].(*ast.ImportSpec); ok && spec.Comment != nil {
+			pos = spec.Comment.End()
+		} else {
+			// Assign same position as the previous import,
+			// so that the sorter sees it as being in the same block.
+			pos = impDecl.Specs[insertAt-1].Pos()
+		}
+	}
+	if newImport.Name != nil {
+		newImport.Name.NamePos = pos
+	}
+	newImport.Path.ValuePos = pos
+	newImport.EndPos = pos
+
+	// Clean up parens. impDecl contains at least one spec.
+	if len(impDecl.Specs) == 1 {
+		// Remove unneeded parens.
+		impDecl.Lparen = token.NoPos
+	} else if !impDecl.Lparen.IsValid() {
+		// impDecl needs parens added.
+		impDecl.Lparen = impDecl.Specs[0].Pos()
+	}
+
+	f.Imports = append(f.Imports, newImport)
+
+	if len(f.Decls) <= 1 {
+		return true
+	}
+
+	// Merge all the import declarations into the first one.
+	var first *ast.GenDecl
+	for i := 0; i < len(f.Decls); i++ {
+		decl := f.Decls[i]
+		gen, ok := decl.(*ast.GenDecl)
+		if !ok || gen.Tok != token.IMPORT || declImports(gen, "C") {
+			continue
+		}
+		if first == nil {
+			first = gen
+			continue // Don't touch the first one.
+		}
+		// We now know there is more than one package in this import
+		// declaration. Ensure that it ends up parenthesized.
+		first.Lparen = first.Pos()
+		// Move the imports of the other import declaration to the first one.
+		for _, spec := range gen.Specs {
+			spec.(*ast.ImportSpec).Path.ValuePos = first.Pos()
+			first.Specs = append(first.Specs, spec)
+		}
+		f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
+		i--
+	}
+
+	return true
+}
+
+func isThirdParty(importPath string) bool {
+	// Third party package import path usually contains "." (".com", ".org", ...)
+	// This logic is taken from golang.org/x/tools/imports package.
+	return strings.Contains(importPath, ".")
+}
+
+// DeleteImport deletes the import path from the file f, if present.
+func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool) {
+	return DeleteNamedImport(fset, f, "", path)
+}
+
+// DeleteNamedImport deletes the import with the given name and path from the file f, if present.
+func DeleteNamedImport(fset *token.FileSet, f *ast.File, name, path string) (deleted bool) {
+	var delspecs []*ast.ImportSpec
+	var delcomments []*ast.CommentGroup
+
+	// Find the import nodes that import path, if any.
+	for i := 0; i < len(f.Decls); i++ {
+		decl := f.Decls[i]
+		gen, ok := decl.(*ast.GenDecl)
+		if !ok || gen.Tok != token.IMPORT {
+			continue
+		}
+		for j := 0; j < len(gen.Specs); j++ {
+			spec := gen.Specs[j]
+			impspec := spec.(*ast.ImportSpec)
+			if impspec.Name == nil && name != "" {
+				continue
+			}
+			if impspec.Name != nil && impspec.Name.Name != name {
+				continue
+			}
+			if importPath(impspec) != path {
+				continue
+			}
+
+			// We found an import spec that imports path.
+			// Delete it.
+			delspecs = append(delspecs, impspec)
+			deleted = true
+			copy(gen.Specs[j:], gen.Specs[j+1:])
+			gen.Specs = gen.Specs[:len(gen.Specs)-1]
+
+			// If this was the last import spec in this decl,
+			// delete the decl, too.
+			if len(gen.Specs) == 0 {
+				copy(f.Decls[i:], f.Decls[i+1:])
+				f.Decls = f.Decls[:len(f.Decls)-1]
+				i--
+				break
+			} else if len(gen.Specs) == 1 {
+				if impspec.Doc != nil {
+					delcomments = append(delcomments, impspec.Doc)
+				}
+				if impspec.Comment != nil {
+					delcomments = append(delcomments, impspec.Comment)
+				}
+				for _, cg := range f.Comments {
+					// Found comment on the same line as the import spec.
+					if cg.End() < impspec.Pos() && fset.Position(cg.End()).Line == fset.Position(impspec.Pos()).Line {
+						delcomments = append(delcomments, cg)
+						break
+					}
+				}
+
+				spec := gen.Specs[0].(*ast.ImportSpec)
+
+				// Move the documentation right after the import decl.
+				if spec.Doc != nil {
+					for fset.Position(gen.TokPos).Line+1 < fset.Position(spec.Doc.Pos()).Line {
+						fset.File(gen.TokPos).MergeLine(fset.Position(gen.TokPos).Line)
+					}
+				}
+				for _, cg := range f.Comments {
+					if cg.End() < spec.Pos() && fset.Position(cg.End()).Line == fset.Position(spec.Pos()).Line {
+						for fset.Position(gen.TokPos).Line+1 < fset.Position(spec.Pos()).Line {
+							fset.File(gen.TokPos).MergeLine(fset.Position(gen.TokPos).Line)
+						}
+						break
+					}
+				}
+			}
+			if j > 0 {
+				lastImpspec := gen.Specs[j-1].(*ast.ImportSpec)
+				lastLine := fset.Position(lastImpspec.Path.ValuePos).Line
+				line := fset.Position(impspec.Path.ValuePos).Line
+
+				// We deleted an entry but now there may be
+				// a blank line-sized hole where the import was.
+				if line-lastLine > 1 {
+					// There was a blank line immediately preceding the deleted import,
+					// so there's no need to close the hole.
+					// Do nothing.
+				} else if line != fset.File(gen.Rparen).LineCount() {
+					// There was no blank line. Close the hole.
+					fset.File(gen.Rparen).MergeLine(line)
+				}
+			}
+			j--
+		}
+	}
+
+	// Delete imports from f.Imports.
+	for i := 0; i < len(f.Imports); i++ {
+		imp := f.Imports[i]
+		for j, del := range delspecs {
+			if imp == del {
+				copy(f.Imports[i:], f.Imports[i+1:])
+				f.Imports = f.Imports[:len(f.Imports)-1]
+				copy(delspecs[j:], delspecs[j+1:])
+				delspecs = delspecs[:len(delspecs)-1]
+				i--
+				break
+			}
+		}
+	}
+
+	// Delete comments from f.Comments.
+	for i := 0; i < len(f.Comments); i++ {
+		cg := f.Comments[i]
+		for j, del := range delcomments {
+			if cg == del {
+				copy(f.Comments[i:], f.Comments[i+1:])
+				f.Comments = f.Comments[:len(f.Comments)-1]
+				copy(delcomments[j:], delcomments[j+1:])
+				delcomments = delcomments[:len(delcomments)-1]
+				i--
+				break
+			}
+		}
+	}
+
+	if len(delspecs) > 0 {
+		panic(fmt.Sprintf("deleted specs from Decls but not Imports: %v", delspecs))
+	}
+
+	return
+}
+
+// RewriteImport rewrites any import of path oldPath to path newPath.
+func RewriteImport(fset *token.FileSet, f *ast.File, oldPath, newPath string) (rewrote bool) {
+	for _, imp := range f.Imports {
+		if importPath(imp) == oldPath {
+			rewrote = true
+			// record old End, because the default is to compute
+			// it using the length of imp.Path.Value.
+			imp.EndPos = imp.End()
+			imp.Path.Value = strconv.Quote(newPath)
+		}
+	}
+	return
+}
+
+// UsesImport reports whether a given import is used.
+func UsesImport(f *ast.File, path string) (used bool) {
+	spec := importSpec(f, path)
+	if spec == nil {
+		return
+	}
+
+	name := spec.Name.String()
+	switch name {
+	case "<nil>":
+		// If the package name is not explicitly specified,
+		// make an educated guess. This is not guaranteed to be correct.
+		lastSlash := strings.LastIndex(path, "/")
+		if lastSlash == -1 {
+			name = path
+		} else {
+			name = path[lastSlash+1:]
+		}
+	case "_", ".":
+		// Not sure if this import is used - err on the side of caution.
+		return true
+	}
+
+	ast.Walk(visitFn(func(n ast.Node) {
+		sel, ok := n.(*ast.SelectorExpr)
+		if ok && isTopName(sel.X, name) {
+			used = true
+		}
+	}), f)
+
+	return
+}
+
+type visitFn func(node ast.Node)
+
+func (fn visitFn) Visit(node ast.Node) ast.Visitor {
+	fn(node)
+	return fn
+}
+
+// imports returns true if f imports path.
+func imports(f *ast.File, path string) bool {
+	return importSpec(f, path) != nil
+}
+
+// importSpec returns the import spec if f imports path,
+// or nil otherwise.
+func importSpec(f *ast.File, path string) *ast.ImportSpec {
+	for _, s := range f.Imports {
+		if importPath(s) == path {
+			return s
+		}
+	}
+	return nil
+}
+
+// importPath returns the unquoted import path of s,
+// or "" if the path is not properly quoted.
+func importPath(s *ast.ImportSpec) string {
+	t, err := strconv.Unquote(s.Path.Value)
+	if err == nil {
+		return t
+	}
+	return ""
+}
+
+// declImports reports whether gen contains an import of path.
+func declImports(gen *ast.GenDecl, path string) bool {
+	if gen.Tok != token.IMPORT {
+		return false
+	}
+	for _, spec := range gen.Specs {
+		impspec := spec.(*ast.ImportSpec)
+		if importPath(impspec) == path {
+			return true
+		}
+	}
+	return false
+}
+
+// matchLen returns the length of the longest path segment prefix shared by x and y.
+func matchLen(x, y string) int {
+	n := 0
+	for i := 0; i < len(x) && i < len(y) && x[i] == y[i]; i++ {
+		if x[i] == '/' {
+			n++
+		}
+	}
+	return n
+}
+
+// isTopName returns true if n is a top-level unresolved identifier with the given name.
+func isTopName(n ast.Expr, name string) bool {
+	id, ok := n.(*ast.Ident)
+	return ok && id.Name == name && id.Obj == nil
+}
+
+// Imports returns the file imports grouped by paragraph.
+func Imports(fset *token.FileSet, f *ast.File) [][]*ast.ImportSpec {
+	var groups [][]*ast.ImportSpec
+
+	for _, decl := range f.Decls {
+		genDecl, ok := decl.(*ast.GenDecl)
+		if !ok || genDecl.Tok != token.IMPORT {
+			break
+		}
+
+		group := []*ast.ImportSpec{}
+
+		var lastLine int
+		for _, spec := range genDecl.Specs {
+			importSpec := spec.(*ast.ImportSpec)
+			pos := importSpec.Path.ValuePos
+			line := fset.Position(pos).Line
+			if lastLine > 0 && pos > 0 && line-lastLine > 1 {
+				groups = append(groups, group)
+				group = []*ast.ImportSpec{}
+			}
+			group = append(group, importSpec)
+			lastLine = line
+		}
+		groups = append(groups, group)
+	}
+
+	return groups
+}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/util.go b/vendor/golang.org/x/tools/go/ast/astutil/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..7630629824af1e839b5954b72a5d5021191d69ae
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/astutil/util.go
@@ -0,0 +1,14 @@
+package astutil
+
+import "go/ast"
+
+// Unparen returns e with any enclosing parentheses stripped.
+func Unparen(e ast.Expr) ast.Expr {
+	for {
+		p, ok := e.(*ast.ParenExpr)
+		if !ok {
+			return e
+		}
+		e = p.X
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bexport.go b/vendor/golang.org/x/tools/go/gcimporter15/bexport.go
new file mode 100644
index 0000000000000000000000000000000000000000..cbf8bc00d6167ed00396b6e0b41eb84550852184
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bexport.go
@@ -0,0 +1,828 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Binary package export.
+// This file was derived from $GOROOT/src/cmd/compile/internal/gc/bexport.go;
+// see that file for specification of the format.
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"log"
+	"math"
+	"math/big"
+	"sort"
+	"strings"
+)
+
+// If debugFormat is set, each integer and string value is preceded by a marker
+// and position information in the encoding. This mechanism permits an importer
+// to recognize immediately when it is out of sync. The importer recognizes this
+// mode automatically (i.e., it can import export data produced with debugging
+// support even if debugFormat is not set at the time of import). This mode will
+// lead to massively larger export data (by a factor of 2 to 3) and should only
+// be enabled during development and debugging.
+//
+// NOTE: This flag is the first flag to enable if importing dies because of
+// (suspected) format errors, and whenever a change is made to the format.
+const debugFormat = false // default: false
+
+// If trace is set, debugging output is printed to std out.
+const trace = false // default: false
+
+// Current export format version. Increase with each format change.
+// 4: type name objects support type aliases, uses aliasTag
+// 3: Go1.8 encoding (same as version 2, aliasTag defined but never used)
+// 2: removed unused bool in ODCL export (compiler only)
+// 1: header format change (more regular), export package for _ struct fields
+// 0: Go1.7 encoding
+const exportVersion = 4
+
+// trackAllTypes enables cycle tracking for all types, not just named
+// types. The existing compiler invariants assume that unnamed types
+// that are not completely set up are not used, or else there are spurious
+// errors.
+// If disabled, only named types are tracked, possibly leading to slightly
+// less efficient encoding in rare cases. It also prevents the export of
+// some corner-case type declarations (but those are not handled correctly
+// with with the textual export format either).
+// TODO(gri) enable and remove once issues caused by it are fixed
+const trackAllTypes = false
+
+type exporter struct {
+	fset *token.FileSet
+	out  bytes.Buffer
+
+	// object -> index maps, indexed in order of serialization
+	strIndex map[string]int
+	pkgIndex map[*types.Package]int
+	typIndex map[types.Type]int
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+
+	// debugging support
+	written int // bytes written
+	indent  int // for trace
+}
+
+// BExportData returns binary export data for pkg.
+// If no file set is provided, position info will be missing.
+func BExportData(fset *token.FileSet, pkg *types.Package) []byte {
+	p := exporter{
+		fset:          fset,
+		strIndex:      map[string]int{"": 0}, // empty string is mapped to 0
+		pkgIndex:      make(map[*types.Package]int),
+		typIndex:      make(map[types.Type]int),
+		posInfoFormat: true, // TODO(gri) might become a flag, eventually
+	}
+
+	// write version info
+	// The version string must start with "version %d" where %d is the version
+	// number. Additional debugging information may follow after a blank; that
+	// text is ignored by the importer.
+	p.rawStringln(fmt.Sprintf("version %d", exportVersion))
+	var debug string
+	if debugFormat {
+		debug = "debug"
+	}
+	p.rawStringln(debug) // cannot use p.bool since it's affected by debugFormat; also want to see this clearly
+	p.bool(trackAllTypes)
+	p.bool(p.posInfoFormat)
+
+	// --- generic export data ---
+
+	// populate type map with predeclared "known" types
+	for index, typ := range predeclared {
+		p.typIndex[typ] = index
+	}
+	if len(p.typIndex) != len(predeclared) {
+		log.Fatalf("gcimporter: duplicate entries in type map?")
+	}
+
+	// write package data
+	p.pkg(pkg, true)
+	if trace {
+		p.tracef("\n")
+	}
+
+	// write objects
+	objcount := 0
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		if !ast.IsExported(name) {
+			continue
+		}
+		if trace {
+			p.tracef("\n")
+		}
+		p.obj(scope.Lookup(name))
+		objcount++
+	}
+
+	// indicate end of list
+	if trace {
+		p.tracef("\n")
+	}
+	p.tag(endTag)
+
+	// for self-verification only (redundant)
+	p.int(objcount)
+
+	if trace {
+		p.tracef("\n")
+	}
+
+	// --- end of export data ---
+
+	return p.out.Bytes()
+}
+
+func (p *exporter) pkg(pkg *types.Package, emptypath bool) {
+	if pkg == nil {
+		log.Fatalf("gcimporter: unexpected nil pkg")
+	}
+
+	// if we saw the package before, write its index (>= 0)
+	if i, ok := p.pkgIndex[pkg]; ok {
+		p.index('P', i)
+		return
+	}
+
+	// otherwise, remember the package, write the package tag (< 0) and package data
+	if trace {
+		p.tracef("P%d = { ", len(p.pkgIndex))
+		defer p.tracef("} ")
+	}
+	p.pkgIndex[pkg] = len(p.pkgIndex)
+
+	p.tag(packageTag)
+	p.string(pkg.Name())
+	if emptypath {
+		p.string("")
+	} else {
+		p.string(pkg.Path())
+	}
+}
+
+func (p *exporter) obj(obj types.Object) {
+	switch obj := obj.(type) {
+	case *types.Const:
+		p.tag(constTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+		p.value(obj.Val())
+
+	case *types.TypeName:
+		if isAlias(obj) {
+			p.tag(aliasTag)
+			p.pos(obj)
+			p.qualifiedName(obj)
+		} else {
+			p.tag(typeTag)
+		}
+		p.typ(obj.Type())
+
+	case *types.Var:
+		p.tag(varTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+
+	case *types.Func:
+		p.tag(funcTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		sig := obj.Type().(*types.Signature)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+
+	default:
+		log.Fatalf("gcimporter: unexpected object %v (%T)", obj, obj)
+	}
+}
+
+func (p *exporter) pos(obj types.Object) {
+	if !p.posInfoFormat {
+		return
+	}
+
+	file, line := p.fileLine(obj)
+	if file == p.prevFile {
+		// common case: write line delta
+		// delta == 0 means different file or no line change
+		delta := line - p.prevLine
+		p.int(delta)
+		if delta == 0 {
+			p.int(-1) // -1 means no file change
+		}
+	} else {
+		// different file
+		p.int(0)
+		// Encode filename as length of common prefix with previous
+		// filename, followed by (possibly empty) suffix. Filenames
+		// frequently share path prefixes, so this can save a lot
+		// of space and make export data size less dependent on file
+		// path length. The suffix is unlikely to be empty because
+		// file names tend to end in ".go".
+		n := commonPrefixLen(p.prevFile, file)
+		p.int(n)           // n >= 0
+		p.string(file[n:]) // write suffix only
+		p.prevFile = file
+		p.int(line)
+	}
+	p.prevLine = line
+}
+
+func (p *exporter) fileLine(obj types.Object) (file string, line int) {
+	if p.fset != nil {
+		pos := p.fset.Position(obj.Pos())
+		file = pos.Filename
+		line = pos.Line
+	}
+	return
+}
+
+func commonPrefixLen(a, b string) int {
+	if len(a) > len(b) {
+		a, b = b, a
+	}
+	// len(a) <= len(b)
+	i := 0
+	for i < len(a) && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+
+func (p *exporter) qualifiedName(obj types.Object) {
+	p.string(obj.Name())
+	p.pkg(obj.Pkg(), false)
+}
+
+func (p *exporter) typ(t types.Type) {
+	if t == nil {
+		log.Fatalf("gcimporter: nil type")
+	}
+
+	// Possible optimization: Anonymous pointer types *T where
+	// T is a named type are common. We could canonicalize all
+	// such types *T to a single type PT = *T. This would lead
+	// to at most one *T entry in typIndex, and all future *T's
+	// would be encoded as the respective index directly. Would
+	// save 1 byte (pointerTag) per *T and reduce the typIndex
+	// size (at the cost of a canonicalization map). We can do
+	// this later, without encoding format change.
+
+	// if we saw the type before, write its index (>= 0)
+	if i, ok := p.typIndex[t]; ok {
+		p.index('T', i)
+		return
+	}
+
+	// otherwise, remember the type, write the type tag (< 0) and type data
+	if trackAllTypes {
+		if trace {
+			p.tracef("T%d = {>\n", len(p.typIndex))
+			defer p.tracef("<\n} ")
+		}
+		p.typIndex[t] = len(p.typIndex)
+	}
+
+	switch t := t.(type) {
+	case *types.Named:
+		if !trackAllTypes {
+			// if we don't track all types, track named types now
+			p.typIndex[t] = len(p.typIndex)
+		}
+
+		p.tag(namedTag)
+		p.pos(t.Obj())
+		p.qualifiedName(t.Obj())
+		p.typ(t.Underlying())
+		if !types.IsInterface(t) {
+			p.assocMethods(t)
+		}
+
+	case *types.Array:
+		p.tag(arrayTag)
+		p.int64(t.Len())
+		p.typ(t.Elem())
+
+	case *types.Slice:
+		p.tag(sliceTag)
+		p.typ(t.Elem())
+
+	case *dddSlice:
+		p.tag(dddTag)
+		p.typ(t.elem)
+
+	case *types.Struct:
+		p.tag(structTag)
+		p.fieldList(t)
+
+	case *types.Pointer:
+		p.tag(pointerTag)
+		p.typ(t.Elem())
+
+	case *types.Signature:
+		p.tag(signatureTag)
+		p.paramList(t.Params(), t.Variadic())
+		p.paramList(t.Results(), false)
+
+	case *types.Interface:
+		p.tag(interfaceTag)
+		p.iface(t)
+
+	case *types.Map:
+		p.tag(mapTag)
+		p.typ(t.Key())
+		p.typ(t.Elem())
+
+	case *types.Chan:
+		p.tag(chanTag)
+		p.int(int(3 - t.Dir())) // hack
+		p.typ(t.Elem())
+
+	default:
+		log.Fatalf("gcimporter: unexpected type %T: %s", t, t)
+	}
+}
+
+func (p *exporter) assocMethods(named *types.Named) {
+	// Sort methods (for determinism).
+	var methods []*types.Func
+	for i := 0; i < named.NumMethods(); i++ {
+		methods = append(methods, named.Method(i))
+	}
+	sort.Sort(methodsByName(methods))
+
+	p.int(len(methods))
+
+	if trace && methods != nil {
+		p.tracef("associated methods {>\n")
+	}
+
+	for i, m := range methods {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+
+		p.pos(m)
+		name := m.Name()
+		p.string(name)
+		if !exported(name) {
+			p.pkg(m.Pkg(), false)
+		}
+
+		sig := m.Type().(*types.Signature)
+		p.paramList(types.NewTuple(sig.Recv()), false)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+		p.int(0) // dummy value for go:nointerface pragma - ignored by importer
+	}
+
+	if trace && methods != nil {
+		p.tracef("<\n} ")
+	}
+}
+
+type methodsByName []*types.Func
+
+func (x methodsByName) Len() int           { return len(x) }
+func (x methodsByName) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x methodsByName) Less(i, j int) bool { return x[i].Name() < x[j].Name() }
+
+func (p *exporter) fieldList(t *types.Struct) {
+	if trace && t.NumFields() > 0 {
+		p.tracef("fields {>\n")
+		defer p.tracef("<\n} ")
+	}
+
+	p.int(t.NumFields())
+	for i := 0; i < t.NumFields(); i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.field(t.Field(i))
+		p.string(t.Tag(i))
+	}
+}
+
+func (p *exporter) field(f *types.Var) {
+	if !f.IsField() {
+		log.Fatalf("gcimporter: field expected")
+	}
+
+	p.pos(f)
+	p.fieldName(f)
+	p.typ(f.Type())
+}
+
+func (p *exporter) iface(t *types.Interface) {
+	// TODO(gri): enable importer to load embedded interfaces,
+	// then emit Embeddeds and ExplicitMethods separately here.
+	p.int(0)
+
+	n := t.NumMethods()
+	if trace && n > 0 {
+		p.tracef("methods {>\n")
+		defer p.tracef("<\n} ")
+	}
+	p.int(n)
+	for i := 0; i < n; i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.method(t.Method(i))
+	}
+}
+
+func (p *exporter) method(m *types.Func) {
+	sig := m.Type().(*types.Signature)
+	if sig.Recv() == nil {
+		log.Fatalf("gcimporter: method expected")
+	}
+
+	p.pos(m)
+	p.string(m.Name())
+	if m.Name() != "_" && !ast.IsExported(m.Name()) {
+		p.pkg(m.Pkg(), false)
+	}
+
+	// interface method; no need to encode receiver.
+	p.paramList(sig.Params(), sig.Variadic())
+	p.paramList(sig.Results(), false)
+}
+
+func (p *exporter) fieldName(f *types.Var) {
+	name := f.Name()
+
+	if f.Anonymous() {
+		// anonymous field - we distinguish between 3 cases:
+		// 1) field name matches base type name and is exported
+		// 2) field name matches base type name and is not exported
+		// 3) field name doesn't match base type name (alias name)
+		bname := basetypeName(f.Type())
+		if name == bname {
+			if ast.IsExported(name) {
+				name = "" // 1) we don't need to know the field name or package
+			} else {
+				name = "?" // 2) use unexported name "?" to force package export
+			}
+		} else {
+			// 3) indicate alias and export name as is
+			// (this requires an extra "@" but this is a rare case)
+			p.string("@")
+		}
+	}
+
+	p.string(name)
+	if name != "" && !ast.IsExported(name) {
+		p.pkg(f.Pkg(), false)
+	}
+}
+
+func basetypeName(typ types.Type) string {
+	switch typ := deref(typ).(type) {
+	case *types.Basic:
+		return typ.Name()
+	case *types.Named:
+		return typ.Obj().Name()
+	default:
+		return "" // unnamed type
+	}
+}
+
+func (p *exporter) paramList(params *types.Tuple, variadic bool) {
+	// use negative length to indicate unnamed parameters
+	// (look at the first parameter only since either all
+	// names are present or all are absent)
+	n := params.Len()
+	if n > 0 && params.At(0).Name() == "" {
+		n = -n
+	}
+	p.int(n)
+	for i := 0; i < params.Len(); i++ {
+		q := params.At(i)
+		t := q.Type()
+		if variadic && i == params.Len()-1 {
+			t = &dddSlice{t.(*types.Slice).Elem()}
+		}
+		p.typ(t)
+		if n > 0 {
+			name := q.Name()
+			p.string(name)
+			if name != "_" {
+				p.pkg(q.Pkg(), false)
+			}
+		}
+		p.string("") // no compiler-specific info
+	}
+}
+
+func (p *exporter) value(x constant.Value) {
+	if trace {
+		p.tracef("= ")
+	}
+
+	switch x.Kind() {
+	case constant.Bool:
+		tag := falseTag
+		if constant.BoolVal(x) {
+			tag = trueTag
+		}
+		p.tag(tag)
+
+	case constant.Int:
+		if v, exact := constant.Int64Val(x); exact {
+			// common case: x fits into an int64 - use compact encoding
+			p.tag(int64Tag)
+			p.int64(v)
+			return
+		}
+		// uncommon case: large x - use float encoding
+		// (powers of 2 will be encoded efficiently with exponent)
+		p.tag(floatTag)
+		p.float(constant.ToFloat(x))
+
+	case constant.Float:
+		p.tag(floatTag)
+		p.float(x)
+
+	case constant.Complex:
+		p.tag(complexTag)
+		p.float(constant.Real(x))
+		p.float(constant.Imag(x))
+
+	case constant.String:
+		p.tag(stringTag)
+		p.string(constant.StringVal(x))
+
+	case constant.Unknown:
+		// package contains type errors
+		p.tag(unknownTag)
+
+	default:
+		log.Fatalf("gcimporter: unexpected value %v (%T)", x, x)
+	}
+}
+
+func (p *exporter) float(x constant.Value) {
+	if x.Kind() != constant.Float {
+		log.Fatalf("gcimporter: unexpected constant %v, want float", x)
+	}
+	// extract sign (there is no -0)
+	sign := constant.Sign(x)
+	if sign == 0 {
+		// x == 0
+		p.int(0)
+		return
+	}
+	// x != 0
+
+	var f big.Float
+	if v, exact := constant.Float64Val(x); exact {
+		// float64
+		f.SetFloat64(v)
+	} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
+		// TODO(gri): add big.Rat accessor to constant.Value.
+		r := valueToRat(num)
+		f.SetRat(r.Quo(r, valueToRat(denom)))
+	} else {
+		// Value too large to represent as a fraction => inaccessible.
+		// TODO(gri): add big.Float accessor to constant.Value.
+		f.SetFloat64(math.MaxFloat64) // FIXME
+	}
+
+	// extract exponent such that 0.5 <= m < 1.0
+	var m big.Float
+	exp := f.MantExp(&m)
+
+	// extract mantissa as *big.Int
+	// - set exponent large enough so mant satisfies mant.IsInt()
+	// - get *big.Int from mant
+	m.SetMantExp(&m, int(m.MinPrec()))
+	mant, acc := m.Int(nil)
+	if acc != big.Exact {
+		log.Fatalf("gcimporter: internal error")
+	}
+
+	p.int(sign)
+	p.int(exp)
+	p.string(string(mant.Bytes()))
+}
+
+func valueToRat(x constant.Value) *big.Rat {
+	// Convert little-endian to big-endian.
+	// I can't believe this is necessary.
+	bytes := constant.Bytes(x)
+	for i := 0; i < len(bytes)/2; i++ {
+		bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i]
+	}
+	return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes))
+}
+
+func (p *exporter) bool(b bool) bool {
+	if trace {
+		p.tracef("[")
+		defer p.tracef("= %v] ", b)
+	}
+
+	x := 0
+	if b {
+		x = 1
+	}
+	p.int(x)
+	return b
+}
+
+// ----------------------------------------------------------------------------
+// Low-level encoders
+
+func (p *exporter) index(marker byte, index int) {
+	if index < 0 {
+		log.Fatalf("gcimporter: invalid index < 0")
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%c%d ", marker, index)
+	}
+	p.rawInt64(int64(index))
+}
+
+func (p *exporter) tag(tag int) {
+	if tag >= 0 {
+		log.Fatalf("gcimporter: invalid tag >= 0")
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%s ", tagString[-tag])
+	}
+	p.rawInt64(int64(tag))
+}
+
+func (p *exporter) int(x int) {
+	p.int64(int64(x))
+}
+
+func (p *exporter) int64(x int64) {
+	if debugFormat {
+		p.marker('i')
+	}
+	if trace {
+		p.tracef("%d ", x)
+	}
+	p.rawInt64(x)
+}
+
+func (p *exporter) string(s string) {
+	if debugFormat {
+		p.marker('s')
+	}
+	if trace {
+		p.tracef("%q ", s)
+	}
+	// if we saw the string before, write its index (>= 0)
+	// (the empty string is mapped to 0)
+	if i, ok := p.strIndex[s]; ok {
+		p.rawInt64(int64(i))
+		return
+	}
+	// otherwise, remember string and write its negative length and bytes
+	p.strIndex[s] = len(p.strIndex)
+	p.rawInt64(-int64(len(s)))
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+}
+
+// marker emits a marker byte and position information which makes
+// it easy for a reader to detect if it is "out of sync". Used for
+// debugFormat format only.
+func (p *exporter) marker(m byte) {
+	p.rawByte(m)
+	// Enable this for help tracking down the location
+	// of an incorrect marker when running in debugFormat.
+	if false && trace {
+		p.tracef("#%d ", p.written)
+	}
+	p.rawInt64(int64(p.written))
+}
+
+// rawInt64 should only be used by low-level encoders.
+func (p *exporter) rawInt64(x int64) {
+	var tmp [binary.MaxVarintLen64]byte
+	n := binary.PutVarint(tmp[:], x)
+	for i := 0; i < n; i++ {
+		p.rawByte(tmp[i])
+	}
+}
+
+// rawStringln should only be used to emit the initial version string.
+func (p *exporter) rawStringln(s string) {
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+	p.rawByte('\n')
+}
+
+// rawByte is the bottleneck interface to write to p.out.
+// rawByte escapes b as follows (any encoding does that
+// hides '$'):
+//
+//	'$'  => '|' 'S'
+//	'|'  => '|' '|'
+//
+// Necessary so other tools can find the end of the
+// export data by searching for "$$".
+// rawByte should only be used by low-level encoders.
+func (p *exporter) rawByte(b byte) {
+	switch b {
+	case '$':
+		// write '$' as '|' 'S'
+		b = 'S'
+		fallthrough
+	case '|':
+		// write '|' as '|' '|'
+		p.out.WriteByte('|')
+		p.written++
+	}
+	p.out.WriteByte(b)
+	p.written++
+}
+
+// tracef is like fmt.Printf but it rewrites the format string
+// to take care of indentation.
+func (p *exporter) tracef(format string, args ...interface{}) {
+	if strings.ContainsAny(format, "<>\n") {
+		var buf bytes.Buffer
+		for i := 0; i < len(format); i++ {
+			// no need to deal with runes
+			ch := format[i]
+			switch ch {
+			case '>':
+				p.indent++
+				continue
+			case '<':
+				p.indent--
+				continue
+			}
+			buf.WriteByte(ch)
+			if ch == '\n' {
+				for j := p.indent; j > 0; j-- {
+					buf.WriteString(".  ")
+				}
+			}
+		}
+		format = buf.String()
+	}
+	fmt.Printf(format, args...)
+}
+
+// Debugging support.
+// (tagString is only used when tracing is enabled)
+var tagString = [...]string{
+	// Packages
+	-packageTag: "package",
+
+	// Types
+	-namedTag:     "named type",
+	-arrayTag:     "array",
+	-sliceTag:     "slice",
+	-dddTag:       "ddd",
+	-structTag:    "struct",
+	-pointerTag:   "pointer",
+	-signatureTag: "signature",
+	-interfaceTag: "interface",
+	-mapTag:       "map",
+	-chanTag:      "chan",
+
+	// Values
+	-falseTag:    "false",
+	-trueTag:     "true",
+	-int64Tag:    "int64",
+	-floatTag:    "float",
+	-fractionTag: "fraction",
+	-complexTag:  "complex",
+	-stringTag:   "string",
+	-unknownTag:  "unknown",
+
+	// Type aliases
+	-aliasTag: "alias",
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/bimport.go b/vendor/golang.org/x/tools/go/gcimporter15/bimport.go
new file mode 100644
index 0000000000000000000000000000000000000000..1936a7f6c976ce4ecfdd9acf37b6eed3aa0ad51f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/bimport.go
@@ -0,0 +1,993 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/bimport.go.
+
+package gcimporter
+
+import (
+	"encoding/binary"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+)
+
+type importer struct {
+	imports    map[string]*types.Package
+	data       []byte
+	importpath string
+	buf        []byte // for reading strings
+	version    int    // export format version
+
+	// object lists
+	strList       []string           // in order of appearance
+	pathList      []string           // in order of appearance
+	pkgList       []*types.Package   // in order of appearance
+	typList       []types.Type       // in order of appearance
+	interfaceList []*types.Interface // for delayed completion only
+	trackAllTypes bool
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+	fset          *token.FileSet
+	files         map[string]*token.File
+
+	// debugging support
+	debugFormat bool
+	read        int // bytes read
+}
+
+// BImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func BImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+	// catch panics and return them as errors
+	defer func() {
+		if e := recover(); e != nil {
+			// The package (filename) causing the problem is added to this
+			// error by a wrapper in the caller (Import in gcimporter.go).
+			// Return a (possibly nil or incomplete) package unchanged (see #16088).
+			err = fmt.Errorf("cannot import, possibly version skew (%v) - reinstall package", e)
+		}
+	}()
+
+	p := importer{
+		imports:    imports,
+		data:       data,
+		importpath: path,
+		version:    -1,           // unknown version
+		strList:    []string{""}, // empty string is mapped to 0
+		pathList:   []string{""}, // empty string is mapped to 0
+		fset:       fset,
+		files:      make(map[string]*token.File),
+	}
+
+	// read version info
+	var versionstr string
+	if b := p.rawByte(); b == 'c' || b == 'd' {
+		// Go1.7 encoding; first byte encodes low-level
+		// encoding format (compact vs debug).
+		// For backward-compatibility only (avoid problems with
+		// old installed packages). Newly compiled packages use
+		// the extensible format string.
+		// TODO(gri) Remove this support eventually; after Go1.8.
+		if b == 'd' {
+			p.debugFormat = true
+		}
+		p.trackAllTypes = p.rawByte() == 'a'
+		p.posInfoFormat = p.int() != 0
+		versionstr = p.string()
+		if versionstr == "v1" {
+			p.version = 0
+		}
+	} else {
+		// Go1.8 extensible encoding
+		// read version string and extract version number (ignore anything after the version number)
+		versionstr = p.rawStringln(b)
+		if s := strings.SplitN(versionstr, " ", 3); len(s) >= 2 && s[0] == "version" {
+			if v, err := strconv.Atoi(s[1]); err == nil && v > 0 {
+				p.version = v
+			}
+		}
+	}
+
+	// read version specific flags - extend as necessary
+	switch p.version {
+	// case 6:
+	// 	...
+	//	fallthrough
+	case 5, 4, 3, 2, 1:
+		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
+		p.trackAllTypes = p.int() != 0
+		p.posInfoFormat = p.int() != 0
+	case 0:
+		// Go1.7 encoding format - nothing to do here
+	default:
+		errorf("unknown export format version %d (%q)", p.version, versionstr)
+	}
+
+	// --- generic export data ---
+
+	// populate typList with predeclared "known" types
+	p.typList = append(p.typList, predeclared...)
+
+	// read package data
+	pkg = p.pkg()
+
+	// read objects of phase 1 only (see cmd/compiler/internal/gc/bexport.go)
+	objcount := 0
+	for {
+		tag := p.tagOrIndex()
+		if tag == endTag {
+			break
+		}
+		p.obj(tag)
+		objcount++
+	}
+
+	// self-verification
+	if count := p.int(); count != objcount {
+		errorf("got %d objects; want %d", objcount, count)
+	}
+
+	// ignore compiler-specific import data
+
+	// complete interfaces
+	// TODO(gri) re-investigate if we still need to do this in a delayed fashion
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types.Package)(nil), p.pkgList[1:]...)
+	sort.Sort(byPath(list))
+	pkg.SetImports(list)
+
+	// package was imported completely and without errors
+	pkg.MarkComplete()
+
+	return p.read, pkg, nil
+}
+
+func errorf(format string, args ...interface{}) {
+	panic(fmt.Sprintf(format, args...))
+}
+
+func (p *importer) pkg() *types.Package {
+	// if the package was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.pkgList[i]
+	}
+
+	// otherwise, i is the package tag (< 0)
+	if i != packageTag {
+		errorf("unexpected package tag %d version %d", i, p.version)
+	}
+
+	// read package data
+	name := p.string()
+	var path string
+	if p.version >= 5 {
+		path = p.path()
+	} else {
+		path = p.string()
+	}
+
+	// we should never see an empty package name
+	if name == "" {
+		errorf("empty package name in import")
+	}
+
+	// an empty path denotes the package we are currently importing;
+	// it must be the first package we see
+	if (path == "") != (len(p.pkgList) == 0) {
+		errorf("package path %q for pkg index %d", path, len(p.pkgList))
+	}
+
+	// if the package was imported before, use that one; otherwise create a new one
+	if path == "" {
+		path = p.importpath
+	}
+	pkg := p.imports[path]
+	if pkg == nil {
+		pkg = types.NewPackage(path, name)
+		p.imports[path] = pkg
+	} else if pkg.Name() != name {
+		errorf("conflicting names %s and %s for package %q", pkg.Name(), name, path)
+	}
+	p.pkgList = append(p.pkgList, pkg)
+
+	return pkg
+}
+
+// objTag returns the tag value for each object kind.
+func objTag(obj types.Object) int {
+	switch obj.(type) {
+	case *types.Const:
+		return constTag
+	case *types.TypeName:
+		return typeTag
+	case *types.Var:
+		return varTag
+	case *types.Func:
+		return funcTag
+	default:
+		errorf("unexpected object: %v (%T)", obj, obj) // panics
+		panic("unreachable")
+	}
+}
+
+func sameObj(a, b types.Object) bool {
+	// Because unnamed types are not canonicalized, we cannot simply compare types for
+	// (pointer) identity.
+	// Ideally we'd check equality of constant values as well, but this is good enough.
+	return objTag(a) == objTag(b) && types.Identical(a.Type(), b.Type())
+}
+
+func (p *importer) declare(obj types.Object) {
+	pkg := obj.Pkg()
+	if alt := pkg.Scope().Insert(obj); alt != nil {
+		// This can only trigger if we import a (non-type) object a second time.
+		// Excluding type aliases, this cannot happen because 1) we only import a package
+		// once; and b) we ignore compiler-specific export data which may contain
+		// functions whose inlined function bodies refer to other functions that
+		// were already imported.
+		// However, type aliases require reexporting the original type, so we need
+		// to allow it (see also the comment in cmd/compile/internal/gc/bimport.go,
+		// method importer.obj, switch case importing functions).
+		// TODO(gri) review/update this comment once the gc compiler handles type aliases.
+		if !sameObj(obj, alt) {
+			errorf("inconsistent import:\n\t%v\npreviously imported as:\n\t%v\n", obj, alt)
+		}
+	}
+}
+
+func (p *importer) obj(tag int) {
+	switch tag {
+	case constTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		val := p.value()
+		p.declare(types.NewConst(pos, pkg, name, typ, val))
+
+	case aliasTag:
+		// TODO(gri) verify type alias hookup is correct
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		p.declare(types.NewTypeName(pos, pkg, name, typ))
+
+	case typeTag:
+		p.typ(nil)
+
+	case varTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil)
+		p.declare(types.NewVar(pos, pkg, name, typ))
+
+	case funcTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		sig := types.NewSignature(nil, params, result, isddd)
+		p.declare(types.NewFunc(pos, pkg, name, sig))
+
+	default:
+		errorf("unexpected object tag %d", tag)
+	}
+}
+
+const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
+
+func (p *importer) pos() token.Pos {
+	if !p.posInfoFormat {
+		return token.NoPos
+	}
+
+	file := p.prevFile
+	line := p.prevLine
+	delta := p.int()
+	line += delta
+	if p.version >= 5 {
+		if delta == deltaNewFile {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.path()
+				line = n
+			}
+		}
+	} else {
+		if delta == 0 {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.prevFile[:n] + p.string()
+				line = p.int()
+			}
+		}
+	}
+	p.prevFile = file
+	p.prevLine = line
+
+	// Synthesize a token.Pos
+
+	// Since we don't know the set of needed file positions, we
+	// reserve maxlines positions per file.
+	const maxlines = 64 * 1024
+	f := p.files[file]
+	if f == nil {
+		f = p.fset.AddFile(file, -1, maxlines)
+		p.files[file] = f
+		// Allocate the fake linebreak indices on first use.
+		// TODO(adonovan): opt: save ~512KB using a more complex scheme?
+		fakeLinesOnce.Do(func() {
+			fakeLines = make([]int, maxlines)
+			for i := range fakeLines {
+				fakeLines[i] = i
+			}
+		})
+		f.SetLines(fakeLines)
+	}
+
+	if line > maxlines {
+		line = 1
+	}
+
+	// Treat the file as if it contained only newlines
+	// and column=1: use the line number as the offset.
+	return f.Pos(line - 1)
+}
+
+var (
+	fakeLines     []int
+	fakeLinesOnce sync.Once
+)
+
+func (p *importer) qualifiedName() (pkg *types.Package, name string) {
+	name = p.string()
+	pkg = p.pkg()
+	return
+}
+
+func (p *importer) record(t types.Type) {
+	p.typList = append(p.typList, t)
+}
+
+// A dddSlice is a types.Type representing ...T parameters.
+// It only appears for parameter types and does not escape
+// the importer.
+type dddSlice struct {
+	elem types.Type
+}
+
+func (t *dddSlice) Underlying() types.Type { return t }
+func (t *dddSlice) String() string         { return "..." + t.elem.String() }
+
+// parent is the package which declared the type; parent == nil means
+// the package currently imported. The parent package is needed for
+// exported struct fields and interface methods which don't contain
+// explicit package information in the export data.
+func (p *importer) typ(parent *types.Package) types.Type {
+	// if the type was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.typList[i]
+	}
+
+	// otherwise, i is the type tag (< 0)
+	switch i {
+	case namedTag:
+		// read type object
+		pos := p.pos()
+		parent, name := p.qualifiedName()
+		scope := parent.Scope()
+		obj := scope.Lookup(name)
+
+		// if the object doesn't exist yet, create and insert it
+		if obj == nil {
+			obj = types.NewTypeName(pos, parent, name, nil)
+			scope.Insert(obj)
+		}
+
+		if _, ok := obj.(*types.TypeName); !ok {
+			errorf("pkg = %s, name = %s => %s", parent, name, obj)
+		}
+
+		// associate new named type with obj if it doesn't exist yet
+		t0 := types.NewNamed(obj.(*types.TypeName), nil, nil)
+
+		// but record the existing type, if any
+		t := obj.Type().(*types.Named)
+		p.record(t)
+
+		// read underlying type
+		t0.SetUnderlying(p.typ(parent))
+
+		// interfaces don't have associated methods
+		if types.IsInterface(t0) {
+			return t
+		}
+
+		// read associated methods
+		for i := p.int(); i > 0; i-- {
+			// TODO(gri) replace this with something closer to fieldName
+			pos := p.pos()
+			name := p.string()
+			if !exported(name) {
+				p.pkg()
+			}
+
+			recv, _ := p.paramList() // TODO(gri) do we need a full param list for the receiver?
+			params, isddd := p.paramList()
+			result, _ := p.paramList()
+			p.int() // go:nointerface pragma - discarded
+
+			sig := types.NewSignature(recv.At(0), params, result, isddd)
+			t0.AddMethod(types.NewFunc(pos, parent, name, sig))
+		}
+
+		return t
+
+	case arrayTag:
+		t := new(types.Array)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		n := p.int64()
+		*t = *types.NewArray(p.typ(parent), n)
+		return t
+
+	case sliceTag:
+		t := new(types.Slice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewSlice(p.typ(parent))
+		return t
+
+	case dddTag:
+		t := new(dddSlice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		t.elem = p.typ(parent)
+		return t
+
+	case structTag:
+		t := new(types.Struct)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewStruct(p.fieldList(parent))
+		return t
+
+	case pointerTag:
+		t := new(types.Pointer)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewPointer(p.typ(parent))
+		return t
+
+	case signatureTag:
+		t := new(types.Signature)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		*t = *types.NewSignature(nil, params, result, isddd)
+		return t
+
+	case interfaceTag:
+		// Create a dummy entry in the type list. This is safe because we
+		// cannot expect the interface type to appear in a cycle, as any
+		// such cycle must contain a named type which would have been
+		// first defined earlier.
+		n := len(p.typList)
+		if p.trackAllTypes {
+			p.record(nil)
+		}
+
+		var embeddeds []*types.Named
+		for n := p.int(); n > 0; n-- {
+			p.pos()
+			embeddeds = append(embeddeds, p.typ(parent).(*types.Named))
+		}
+
+		t := types.NewInterface(p.methodList(parent), embeddeds)
+		p.interfaceList = append(p.interfaceList, t)
+		if p.trackAllTypes {
+			p.typList[n] = t
+		}
+		return t
+
+	case mapTag:
+		t := new(types.Map)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		key := p.typ(parent)
+		val := p.typ(parent)
+		*t = *types.NewMap(key, val)
+		return t
+
+	case chanTag:
+		t := new(types.Chan)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		var dir types.ChanDir
+		// tag values must match the constants in cmd/compile/internal/gc/go.go
+		switch d := p.int(); d {
+		case 1 /* Crecv */ :
+			dir = types.RecvOnly
+		case 2 /* Csend */ :
+			dir = types.SendOnly
+		case 3 /* Cboth */ :
+			dir = types.SendRecv
+		default:
+			errorf("unexpected channel dir %d", d)
+		}
+		val := p.typ(parent)
+		*t = *types.NewChan(dir, val)
+		return t
+
+	default:
+		errorf("unexpected type tag %d", i) // panics
+		panic("unreachable")
+	}
+}
+
+func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {
+	if n := p.int(); n > 0 {
+		fields = make([]*types.Var, n)
+		tags = make([]string, n)
+		for i := range fields {
+			fields[i], tags[i] = p.field(parent)
+		}
+	}
+	return
+}
+
+func (p *importer) field(parent *types.Package) (*types.Var, string) {
+	pos := p.pos()
+	pkg, name, alias := p.fieldName(parent)
+	typ := p.typ(parent)
+	tag := p.string()
+
+	anonymous := false
+	if name == "" {
+		// anonymous field - typ must be T or *T and T must be a type name
+		switch typ := deref(typ).(type) {
+		case *types.Basic: // basic types are named types
+			pkg = nil // // objects defined in Universe scope have no package
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			errorf("named base type expected")
+		}
+		anonymous = true
+	} else if alias {
+		// anonymous field: we have an explicit name because it's an alias
+		anonymous = true
+	}
+
+	return types.NewField(pos, pkg, name, typ, anonymous), tag
+}
+
+func (p *importer) methodList(parent *types.Package) (methods []*types.Func) {
+	if n := p.int(); n > 0 {
+		methods = make([]*types.Func, n)
+		for i := range methods {
+			methods[i] = p.method(parent)
+		}
+	}
+	return
+}
+
+func (p *importer) method(parent *types.Package) *types.Func {
+	pos := p.pos()
+	pkg, name, _ := p.fieldName(parent)
+	params, isddd := p.paramList()
+	result, _ := p.paramList()
+	sig := types.NewSignature(nil, params, result, isddd)
+	return types.NewFunc(pos, pkg, name, sig)
+}
+
+func (p *importer) fieldName(parent *types.Package) (pkg *types.Package, name string, alias bool) {
+	name = p.string()
+	pkg = parent
+	if pkg == nil {
+		// use the imported package instead
+		pkg = p.pkgList[0]
+	}
+	if p.version == 0 && name == "_" {
+		// version 0 didn't export a package for _ fields
+		return
+	}
+	switch name {
+	case "":
+		// 1) field name matches base type name and is exported: nothing to do
+	case "?":
+		// 2) field name matches base type name and is not exported: need package
+		name = ""
+		pkg = p.pkg()
+	case "@":
+		// 3) field name doesn't match type name (alias)
+		name = p.string()
+		alias = true
+		fallthrough
+	default:
+		if !exported(name) {
+			pkg = p.pkg()
+		}
+	}
+	return
+}
+
+func (p *importer) paramList() (*types.Tuple, bool) {
+	n := p.int()
+	if n == 0 {
+		return nil, false
+	}
+	// negative length indicates unnamed parameters
+	named := true
+	if n < 0 {
+		n = -n
+		named = false
+	}
+	// n > 0
+	params := make([]*types.Var, n)
+	isddd := false
+	for i := range params {
+		params[i], isddd = p.param(named)
+	}
+	return types.NewTuple(params...), isddd
+}
+
+func (p *importer) param(named bool) (*types.Var, bool) {
+	t := p.typ(nil)
+	td, isddd := t.(*dddSlice)
+	if isddd {
+		t = types.NewSlice(td.elem)
+	}
+
+	var pkg *types.Package
+	var name string
+	if named {
+		name = p.string()
+		if name == "" {
+			errorf("expected named parameter")
+		}
+		if name != "_" {
+			pkg = p.pkg()
+		}
+		if i := strings.Index(name, "·"); i > 0 {
+			name = name[:i] // cut off gc-specific parameter numbering
+		}
+	}
+
+	// read and discard compiler-specific info
+	p.string()
+
+	return types.NewVar(token.NoPos, pkg, name, t), isddd
+}
+
+func exported(name string) bool {
+	ch, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(ch)
+}
+
+func (p *importer) value() constant.Value {
+	switch tag := p.tagOrIndex(); tag {
+	case falseTag:
+		return constant.MakeBool(false)
+	case trueTag:
+		return constant.MakeBool(true)
+	case int64Tag:
+		return constant.MakeInt64(p.int64())
+	case floatTag:
+		return p.float()
+	case complexTag:
+		re := p.float()
+		im := p.float()
+		return constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+	case stringTag:
+		return constant.MakeString(p.string())
+	case unknownTag:
+		return constant.MakeUnknown()
+	default:
+		errorf("unexpected value tag %d", tag) // panics
+		panic("unreachable")
+	}
+}
+
+func (p *importer) float() constant.Value {
+	sign := p.int()
+	if sign == 0 {
+		return constant.MakeInt64(0)
+	}
+
+	exp := p.int()
+	mant := []byte(p.string()) // big endian
+
+	// remove leading 0's if any
+	for len(mant) > 0 && mant[0] == 0 {
+		mant = mant[1:]
+	}
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(mant)-1; i < j; i, j = i+1, j-1 {
+		mant[i], mant[j] = mant[j], mant[i]
+	}
+
+	// adjust exponent (constant.MakeFromBytes creates an integer value,
+	// but mant represents the mantissa bits such that 0.5 <= mant < 1.0)
+	exp -= len(mant) << 3
+	if len(mant) > 0 {
+		for msd := mant[len(mant)-1]; msd&0x80 == 0; msd <<= 1 {
+			exp++
+		}
+	}
+
+	x := constant.MakeFromBytes(mant)
+	switch {
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	}
+
+	if sign < 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+// ----------------------------------------------------------------------------
+// Low-level decoders
+
+func (p *importer) tagOrIndex() int {
+	if p.debugFormat {
+		p.marker('t')
+	}
+
+	return int(p.rawInt64())
+}
+
+func (p *importer) int() int {
+	x := p.int64()
+	if int64(int(x)) != x {
+		errorf("exported integer too large")
+	}
+	return int(x)
+}
+
+func (p *importer) int64() int64 {
+	if p.debugFormat {
+		p.marker('i')
+	}
+
+	return p.rawInt64()
+}
+
+func (p *importer) path() string {
+	if p.debugFormat {
+		p.marker('p')
+	}
+	// if the path was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.pathList[i]
+	}
+	// otherwise, i is the negative path length (< 0)
+	a := make([]string, -i)
+	for n := range a {
+		a[n] = p.string()
+	}
+	s := strings.Join(a, "/")
+	p.pathList = append(p.pathList, s)
+	return s
+}
+
+func (p *importer) string() string {
+	if p.debugFormat {
+		p.marker('s')
+	}
+	// if the string was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.strList[i]
+	}
+	// otherwise, i is the negative string length (< 0)
+	if n := int(-i); n <= cap(p.buf) {
+		p.buf = p.buf[:n]
+	} else {
+		p.buf = make([]byte, n)
+	}
+	for i := range p.buf {
+		p.buf[i] = p.rawByte()
+	}
+	s := string(p.buf)
+	p.strList = append(p.strList, s)
+	return s
+}
+
+func (p *importer) marker(want byte) {
+	if got := p.rawByte(); got != want {
+		errorf("incorrect marker: got %c; want %c (pos = %d)", got, want, p.read)
+	}
+
+	pos := p.read
+	if n := int(p.rawInt64()); n != pos {
+		errorf("incorrect position: got %d; want %d", n, pos)
+	}
+}
+
+// rawInt64 should only be used by low-level decoders.
+func (p *importer) rawInt64() int64 {
+	i, err := binary.ReadVarint(p)
+	if err != nil {
+		errorf("read error: %v", err)
+	}
+	return i
+}
+
+// rawStringln should only be used to read the initial version string.
+func (p *importer) rawStringln(b byte) string {
+	p.buf = p.buf[:0]
+	for b != '\n' {
+		p.buf = append(p.buf, b)
+		b = p.rawByte()
+	}
+	return string(p.buf)
+}
+
+// needed for binary.ReadVarint in rawInt64
+func (p *importer) ReadByte() (byte, error) {
+	return p.rawByte(), nil
+}
+
+// byte is the bottleneck interface for reading p.data.
+// It unescapes '|' 'S' to '$' and '|' '|' to '|'.
+// rawByte should only be used by low-level decoders.
+func (p *importer) rawByte() byte {
+	b := p.data[0]
+	r := 1
+	if b == '|' {
+		b = p.data[1]
+		r = 2
+		switch b {
+		case 'S':
+			b = '$'
+		case '|':
+			// nothing to do
+		default:
+			errorf("unexpected escape sequence in export data")
+		}
+	}
+	p.data = p.data[r:]
+	p.read += r
+	return b
+
+}
+
+// ----------------------------------------------------------------------------
+// Export format
+
+// Tags. Must be < 0.
+const (
+	// Objects
+	packageTag = -(iota + 1)
+	constTag
+	typeTag
+	varTag
+	funcTag
+	endTag
+
+	// Types
+	namedTag
+	arrayTag
+	sliceTag
+	dddTag
+	structTag
+	pointerTag
+	signatureTag
+	interfaceTag
+	mapTag
+	chanTag
+
+	// Values
+	falseTag
+	trueTag
+	int64Tag
+	floatTag
+	fractionTag // not used by gc
+	complexTag
+	stringTag
+	nilTag     // only used by gc (appears in exported inlined function bodies)
+	unknownTag // not used by gc (only appears in packages with errors)
+
+	// Type aliases
+	aliasTag
+)
+
+var predeclared = []types.Type{
+	// basic types
+	types.Typ[types.Bool],
+	types.Typ[types.Int],
+	types.Typ[types.Int8],
+	types.Typ[types.Int16],
+	types.Typ[types.Int32],
+	types.Typ[types.Int64],
+	types.Typ[types.Uint],
+	types.Typ[types.Uint8],
+	types.Typ[types.Uint16],
+	types.Typ[types.Uint32],
+	types.Typ[types.Uint64],
+	types.Typ[types.Uintptr],
+	types.Typ[types.Float32],
+	types.Typ[types.Float64],
+	types.Typ[types.Complex64],
+	types.Typ[types.Complex128],
+	types.Typ[types.String],
+
+	// basic type aliases
+	types.Universe.Lookup("byte").Type(),
+	types.Universe.Lookup("rune").Type(),
+
+	// error
+	types.Universe.Lookup("error").Type(),
+
+	// untyped types
+	types.Typ[types.UntypedBool],
+	types.Typ[types.UntypedInt],
+	types.Typ[types.UntypedRune],
+	types.Typ[types.UntypedFloat],
+	types.Typ[types.UntypedComplex],
+	types.Typ[types.UntypedString],
+	types.Typ[types.UntypedNil],
+
+	// package unsafe
+	types.Typ[types.UnsafePointer],
+
+	// invalid type
+	types.Typ[types.Invalid], // only appears in packages with errors
+
+	// used internally by gc; never used by this package or in .a files
+	anyType{},
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types.Type { return t }
+func (t anyType) String() string         { return "any" }
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go b/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
new file mode 100644
index 0000000000000000000000000000000000000000..f33dc5613e712eb0dc9454864f772d1edcf8f425
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/exportdata.go
@@ -0,0 +1,93 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/exportdata.go.
+
+// This file implements FindExportData.
+
+package gcimporter
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+func readGopackHeader(r *bufio.Reader) (name string, size int, err error) {
+	// See $GOROOT/include/ar.h.
+	hdr := make([]byte, 16+12+6+6+8+10+2)
+	_, err = io.ReadFull(r, hdr)
+	if err != nil {
+		return
+	}
+	// leave for debugging
+	if false {
+		fmt.Printf("header: %s", hdr)
+	}
+	s := strings.TrimSpace(string(hdr[16+12+6+6+8:][:10]))
+	size, err = strconv.Atoi(s)
+	if err != nil || hdr[len(hdr)-2] != '`' || hdr[len(hdr)-1] != '\n' {
+		err = fmt.Errorf("invalid archive header")
+		return
+	}
+	name = strings.TrimSpace(string(hdr[:16]))
+	return
+}
+
+// FindExportData positions the reader r at the beginning of the
+// export data section of an underlying GC-created object/archive
+// file by reading from it. The reader must be positioned at the
+// start of the file before calling this function. The hdr result
+// is the string before the export data, either "$$" or "$$B".
+//
+func FindExportData(r *bufio.Reader) (hdr string, err error) {
+	// Read first line to make sure this is an object file.
+	line, err := r.ReadSlice('\n')
+	if err != nil {
+		err = fmt.Errorf("can't find export data (%v)", err)
+		return
+	}
+
+	if string(line) == "!<arch>\n" {
+		// Archive file. Scan to __.PKGDEF.
+		var name string
+		if name, _, err = readGopackHeader(r); err != nil {
+			return
+		}
+
+		// First entry should be __.PKGDEF.
+		if name != "__.PKGDEF" {
+			err = fmt.Errorf("go archive is missing __.PKGDEF")
+			return
+		}
+
+		// Read first line of __.PKGDEF data, so that line
+		// is once again the first line of the input.
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+
+	// Now at __.PKGDEF in archive or still at beginning of file.
+	// Either way, line should begin with "go object ".
+	if !strings.HasPrefix(string(line), "go object ") {
+		err = fmt.Errorf("not a Go object file")
+		return
+	}
+
+	// Skip over object header to export data.
+	// Begins after first line starting with $$.
+	for line[0] != '$' {
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+	hdr = string(line)
+
+	return
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
new file mode 100644
index 0000000000000000000000000000000000000000..6fbc9d7617bda8108f91f6043759b5fb210bdcb2
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/gcimporter.go
@@ -0,0 +1,1041 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/gcimporter.go,
+// but it also contains the original source-based importer code for Go1.6.
+// Once we stop supporting 1.6, we can remove that code.
+
+// Package gcimporter15 provides various functions for reading
+// gc-generated object files that can be used to implement the
+// Importer interface defined by the Go 1.5 standard library package.
+//
+// Deprecated: this package will be deleted in October 2017.
+// New code should use golang.org/x/tools/go/gcexportdata.
+//
+package gcimporter // import "golang.org/x/tools/go/gcimporter15"
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"go/build"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+// debugging/development support
+const debug = false
+
+var pkgExts = [...]string{".a", ".o"}
+
+// FindPkg returns the filename and unique package id for an import
+// path based on package information provided by build.Import (using
+// the build.Default build.Context). A relative srcDir is interpreted
+// relative to the current working directory.
+// If no file was found, an empty filename is returned.
+//
+func FindPkg(path, srcDir string) (filename, id string) {
+	if path == "" {
+		return
+	}
+
+	var noext string
+	switch {
+	default:
+		// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
+		// Don't require the source files to be present.
+		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
+			srcDir = abs
+		}
+		bp, _ := build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
+		if bp.PkgObj == "" {
+			return
+		}
+		noext = strings.TrimSuffix(bp.PkgObj, ".a")
+		id = bp.ImportPath
+
+	case build.IsLocalImport(path):
+		// "./x" -> "/this/directory/x.ext", "/this/directory/x"
+		noext = filepath.Join(srcDir, path)
+		id = noext
+
+	case filepath.IsAbs(path):
+		// for completeness only - go/build.Import
+		// does not support absolute imports
+		// "/x" -> "/x.ext", "/x"
+		noext = path
+		id = path
+	}
+
+	if false { // for debugging
+		if path != id {
+			fmt.Printf("%s -> %s\n", path, id)
+		}
+	}
+
+	// try extensions
+	for _, ext := range pkgExts {
+		filename = noext + ext
+		if f, err := os.Stat(filename); err == nil && !f.IsDir() {
+			return
+		}
+	}
+
+	filename = "" // not found
+	return
+}
+
+// ImportData imports a package by reading the gc-generated export data,
+// adds the corresponding package object to the packages map indexed by id,
+// and returns the object.
+//
+// The packages map must contains all packages already imported. The data
+// reader position must be the beginning of the export data section. The
+// filename is only used in error messages.
+//
+// If packages[id] contains the completely imported package, that package
+// can be used directly, and there is no need to call this function (but
+// there is also no harm but for extra time used).
+//
+func ImportData(packages map[string]*types.Package, filename, id string, data io.Reader) (pkg *types.Package, err error) {
+	// support for parser error handling
+	defer func() {
+		switch r := recover().(type) {
+		case nil:
+			// nothing to do
+		case importError:
+			err = r
+		default:
+			panic(r) // internal error
+		}
+	}()
+
+	var p parser
+	p.init(filename, id, data, packages)
+	pkg = p.parseExport()
+
+	return
+}
+
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
+// The packages map must contain all packages already imported.
+//
+func Import(packages map[string]*types.Package, path, srcDir string) (pkg *types.Package, err error) {
+	filename, id := FindPkg(path, srcDir)
+	if filename == "" {
+		if path == "unsafe" {
+			return types.Unsafe, nil
+		}
+		err = fmt.Errorf("can't find import: %s", id)
+		return
+	}
+
+	// no need to re-import if the package was imported completely before
+	if pkg = packages[id]; pkg != nil && pkg.Complete() {
+		return
+	}
+
+	// open file
+	f, err := os.Open(filename)
+	if err != nil {
+		return
+	}
+	defer func() {
+		f.Close()
+		if err != nil {
+			// add file name to error
+			err = fmt.Errorf("reading export data: %s: %v", filename, err)
+		}
+	}()
+
+	var hdr string
+	buf := bufio.NewReader(f)
+	if hdr, err = FindExportData(buf); err != nil {
+		return
+	}
+
+	switch hdr {
+	case "$$\n":
+		return ImportData(packages, filename, id, buf)
+	case "$$B\n":
+		var data []byte
+		data, err = ioutil.ReadAll(buf)
+		if err == nil {
+			fset := token.NewFileSet()
+			_, pkg, err = BImportData(fset, packages, data, id)
+			return
+		}
+	default:
+		err = fmt.Errorf("unknown export data header: %q", hdr)
+	}
+
+	return
+}
+
+// ----------------------------------------------------------------------------
+// Parser
+
+// TODO(gri) Imported objects don't have position information.
+//           Ideally use the debug table line info; alternatively
+//           create some fake position (or the position of the
+//           import). That way error messages referring to imported
+//           objects can print meaningful information.
+
+// parser parses the exports inside a gc compiler-produced
+// object/archive file and populates its scope with the results.
+type parser struct {
+	scanner    scanner.Scanner
+	tok        rune                      // current token
+	lit        string                    // literal string; only valid for Ident, Int, String tokens
+	id         string                    // package id of imported package
+	sharedPkgs map[string]*types.Package // package id -> package object (across importer)
+	localPkgs  map[string]*types.Package // package id -> package object (just this package)
+}
+
+func (p *parser) init(filename, id string, src io.Reader, packages map[string]*types.Package) {
+	p.scanner.Init(src)
+	p.scanner.Error = func(_ *scanner.Scanner, msg string) { p.error(msg) }
+	p.scanner.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanChars | scanner.ScanStrings | scanner.ScanComments | scanner.SkipComments
+	p.scanner.Whitespace = 1<<'\t' | 1<<' '
+	p.scanner.Filename = filename // for good error messages
+	p.next()
+	p.id = id
+	p.sharedPkgs = packages
+	if debug {
+		// check consistency of packages map
+		for _, pkg := range packages {
+			if pkg.Name() == "" {
+				fmt.Printf("no package name for %s\n", pkg.Path())
+			}
+		}
+	}
+}
+
+func (p *parser) next() {
+	p.tok = p.scanner.Scan()
+	switch p.tok {
+	case scanner.Ident, scanner.Int, scanner.Char, scanner.String, '·':
+		p.lit = p.scanner.TokenText()
+	default:
+		p.lit = ""
+	}
+	if debug {
+		fmt.Printf("%s: %q -> %q\n", scanner.TokenString(p.tok), p.scanner.TokenText(), p.lit)
+	}
+}
+
+func declTypeName(pkg *types.Package, name string) *types.TypeName {
+	scope := pkg.Scope()
+	if obj := scope.Lookup(name); obj != nil {
+		return obj.(*types.TypeName)
+	}
+	obj := types.NewTypeName(token.NoPos, pkg, name, nil)
+	// a named type may be referred to before the underlying type
+	// is known - set it up
+	types.NewNamed(obj, nil, nil)
+	scope.Insert(obj)
+	return obj
+}
+
+// ----------------------------------------------------------------------------
+// Error handling
+
+// Internal errors are boxed as importErrors.
+type importError struct {
+	pos scanner.Position
+	err error
+}
+
+func (e importError) Error() string {
+	return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err)
+}
+
+func (p *parser) error(err interface{}) {
+	if s, ok := err.(string); ok {
+		err = errors.New(s)
+	}
+	// panic with a runtime.Error if err is not an error
+	panic(importError{p.scanner.Pos(), err.(error)})
+}
+
+func (p *parser) errorf(format string, args ...interface{}) {
+	p.error(fmt.Sprintf(format, args...))
+}
+
+func (p *parser) expect(tok rune) string {
+	lit := p.lit
+	if p.tok != tok {
+		p.errorf("expected %s, got %s (%s)", scanner.TokenString(tok), scanner.TokenString(p.tok), lit)
+	}
+	p.next()
+	return lit
+}
+
+func (p *parser) expectSpecial(tok string) {
+	sep := 'x' // not white space
+	i := 0
+	for i < len(tok) && p.tok == rune(tok[i]) && sep > ' ' {
+		sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
+		p.next()
+		i++
+	}
+	if i < len(tok) {
+		p.errorf("expected %q, got %q", tok, tok[0:i])
+	}
+}
+
+func (p *parser) expectKeyword(keyword string) {
+	lit := p.expect(scanner.Ident)
+	if lit != keyword {
+		p.errorf("expected keyword %s, got %q", keyword, lit)
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Qualified and unqualified names
+
+// PackageId = string_lit .
+//
+func (p *parser) parsePackageId() string {
+	id, err := strconv.Unquote(p.expect(scanner.String))
+	if err != nil {
+		p.error(err)
+	}
+	// id == "" stands for the imported package id
+	// (only known at time of package installation)
+	if id == "" {
+		id = p.id
+	}
+	return id
+}
+
+// PackageName = ident .
+//
+func (p *parser) parsePackageName() string {
+	return p.expect(scanner.Ident)
+}
+
+// dotIdentifier = ( ident | '·' ) { ident | int | '·' } .
+func (p *parser) parseDotIdent() string {
+	ident := ""
+	if p.tok != scanner.Int {
+		sep := 'x' // not white space
+		for (p.tok == scanner.Ident || p.tok == scanner.Int || p.tok == '·') && sep > ' ' {
+			ident += p.lit
+			sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
+			p.next()
+		}
+	}
+	if ident == "" {
+		p.expect(scanner.Ident) // use expect() for error handling
+	}
+	return ident
+}
+
+// QualifiedName = "@" PackageId "." ( "?" | dotIdentifier ) .
+//
+func (p *parser) parseQualifiedName() (id, name string) {
+	p.expect('@')
+	id = p.parsePackageId()
+	p.expect('.')
+	// Per rev f280b8a485fd (10/2/2013), qualified names may be used for anonymous fields.
+	if p.tok == '?' {
+		p.next()
+	} else {
+		name = p.parseDotIdent()
+	}
+	return
+}
+
+// getPkg returns the package for a given id. If the package is
+// not found, create the package and add it to the p.localPkgs
+// and p.sharedPkgs maps. name is the (expected) name of the
+// package. If name == "", the package name is expected to be
+// set later via an import clause in the export data.
+//
+// id identifies a package, usually by a canonical package path like
+// "encoding/json" but possibly by a non-canonical import path like
+// "./json".
+//
+func (p *parser) getPkg(id, name string) *types.Package {
+	// package unsafe is not in the packages maps - handle explicitly
+	if id == "unsafe" {
+		return types.Unsafe
+	}
+
+	pkg := p.localPkgs[id]
+	if pkg == nil {
+		// first import of id from this package
+		pkg = p.sharedPkgs[id]
+		if pkg == nil {
+			// first import of id by this importer;
+			// add (possibly unnamed) pkg to shared packages
+			pkg = types.NewPackage(id, name)
+			p.sharedPkgs[id] = pkg
+		}
+		// add (possibly unnamed) pkg to local packages
+		if p.localPkgs == nil {
+			p.localPkgs = make(map[string]*types.Package)
+		}
+		p.localPkgs[id] = pkg
+	} else if name != "" {
+		// package exists already and we have an expected package name;
+		// make sure names match or set package name if necessary
+		if pname := pkg.Name(); pname == "" {
+			pkg.SetName(name)
+		} else if pname != name {
+			p.errorf("%s package name mismatch: %s (given) vs %s (expected)", id, pname, name)
+		}
+	}
+	return pkg
+}
+
+// parseExportedName is like parseQualifiedName, but
+// the package id is resolved to an imported *types.Package.
+//
+func (p *parser) parseExportedName() (pkg *types.Package, name string) {
+	id, name := p.parseQualifiedName()
+	pkg = p.getPkg(id, "")
+	return
+}
+
+// ----------------------------------------------------------------------------
+// Types
+
+// BasicType = identifier .
+//
+func (p *parser) parseBasicType() types.Type {
+	id := p.expect(scanner.Ident)
+	obj := types.Universe.Lookup(id)
+	if obj, ok := obj.(*types.TypeName); ok {
+		return obj.Type()
+	}
+	p.errorf("not a basic type: %s", id)
+	return nil
+}
+
+// ArrayType = "[" int_lit "]" Type .
+//
+func (p *parser) parseArrayType(parent *types.Package) types.Type {
+	// "[" already consumed and lookahead known not to be "]"
+	lit := p.expect(scanner.Int)
+	p.expect(']')
+	elem := p.parseType(parent)
+	n, err := strconv.ParseInt(lit, 10, 64)
+	if err != nil {
+		p.error(err)
+	}
+	return types.NewArray(elem, n)
+}
+
+// MapType = "map" "[" Type "]" Type .
+//
+func (p *parser) parseMapType(parent *types.Package) types.Type {
+	p.expectKeyword("map")
+	p.expect('[')
+	key := p.parseType(parent)
+	p.expect(']')
+	elem := p.parseType(parent)
+	return types.NewMap(key, elem)
+}
+
+// Name = identifier | "?" | QualifiedName .
+//
+// For unqualified and anonymous names, the returned package is the parent
+// package unless parent == nil, in which case the returned package is the
+// package being imported. (The parent package is not nil if the the name
+// is an unqualified struct field or interface method name belonging to a
+// type declared in another package.)
+//
+// For qualified names, the returned package is nil (and not created if
+// it doesn't exist yet) unless materializePkg is set (which creates an
+// unnamed package with valid package path). In the latter case, a
+// subsequent import clause is expected to provide a name for the package.
+//
+func (p *parser) parseName(parent *types.Package, materializePkg bool) (pkg *types.Package, name string) {
+	pkg = parent
+	if pkg == nil {
+		pkg = p.sharedPkgs[p.id]
+	}
+	switch p.tok {
+	case scanner.Ident:
+		name = p.lit
+		p.next()
+	case '?':
+		// anonymous
+		p.next()
+	case '@':
+		// exported name prefixed with package path
+		pkg = nil
+		var id string
+		id, name = p.parseQualifiedName()
+		if materializePkg {
+			pkg = p.getPkg(id, "")
+		}
+	default:
+		p.error("name expected")
+	}
+	return
+}
+
+func deref(typ types.Type) types.Type {
+	if p, _ := typ.(*types.Pointer); p != nil {
+		return p.Elem()
+	}
+	return typ
+}
+
+// Field = Name Type [ string_lit ] .
+//
+func (p *parser) parseField(parent *types.Package) (*types.Var, string) {
+	pkg, name := p.parseName(parent, true)
+
+	if name == "_" {
+		// Blank fields should be package-qualified because they
+		// are unexported identifiers, but gc does not qualify them.
+		// Assuming that the ident belongs to the current package
+		// causes types to change during re-exporting, leading
+		// to spurious "can't assign A to B" errors from go/types.
+		// As a workaround, pretend all blank fields belong
+		// to the same unique dummy package.
+		const blankpkg = "<_>"
+		pkg = p.getPkg(blankpkg, blankpkg)
+	}
+
+	typ := p.parseType(parent)
+	anonymous := false
+	if name == "" {
+		// anonymous field - typ must be T or *T and T must be a type name
+		switch typ := deref(typ).(type) {
+		case *types.Basic: // basic types are named types
+			pkg = nil // objects defined in Universe scope have no package
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			p.errorf("anonymous field expected")
+		}
+		anonymous = true
+	}
+	tag := ""
+	if p.tok == scanner.String {
+		s := p.expect(scanner.String)
+		var err error
+		tag, err = strconv.Unquote(s)
+		if err != nil {
+			p.errorf("invalid struct tag %s: %s", s, err)
+		}
+	}
+	return types.NewField(token.NoPos, pkg, name, typ, anonymous), tag
+}
+
+// StructType = "struct" "{" [ FieldList ] "}" .
+// FieldList  = Field { ";" Field } .
+//
+func (p *parser) parseStructType(parent *types.Package) types.Type {
+	var fields []*types.Var
+	var tags []string
+
+	p.expectKeyword("struct")
+	p.expect('{')
+	for i := 0; p.tok != '}' && p.tok != scanner.EOF; i++ {
+		if i > 0 {
+			p.expect(';')
+		}
+		fld, tag := p.parseField(parent)
+		if tag != "" && tags == nil {
+			tags = make([]string, i)
+		}
+		if tags != nil {
+			tags = append(tags, tag)
+		}
+		fields = append(fields, fld)
+	}
+	p.expect('}')
+
+	return types.NewStruct(fields, tags)
+}
+
+// Parameter = ( identifier | "?" ) [ "..." ] Type [ string_lit ] .
+//
+func (p *parser) parseParameter() (par *types.Var, isVariadic bool) {
+	_, name := p.parseName(nil, false)
+	// remove gc-specific parameter numbering
+	if i := strings.Index(name, "·"); i >= 0 {
+		name = name[:i]
+	}
+	if p.tok == '.' {
+		p.expectSpecial("...")
+		isVariadic = true
+	}
+	typ := p.parseType(nil)
+	if isVariadic {
+		typ = types.NewSlice(typ)
+	}
+	// ignore argument tag (e.g. "noescape")
+	if p.tok == scanner.String {
+		p.next()
+	}
+	// TODO(gri) should we provide a package?
+	par = types.NewVar(token.NoPos, nil, name, typ)
+	return
+}
+
+// Parameters    = "(" [ ParameterList ] ")" .
+// ParameterList = { Parameter "," } Parameter .
+//
+func (p *parser) parseParameters() (list []*types.Var, isVariadic bool) {
+	p.expect('(')
+	for p.tok != ')' && p.tok != scanner.EOF {
+		if len(list) > 0 {
+			p.expect(',')
+		}
+		par, variadic := p.parseParameter()
+		list = append(list, par)
+		if variadic {
+			if isVariadic {
+				p.error("... not on final argument")
+			}
+			isVariadic = true
+		}
+	}
+	p.expect(')')
+
+	return
+}
+
+// Signature = Parameters [ Result ] .
+// Result    = Type | Parameters .
+//
+func (p *parser) parseSignature(recv *types.Var) *types.Signature {
+	params, isVariadic := p.parseParameters()
+
+	// optional result type
+	var results []*types.Var
+	if p.tok == '(' {
+		var variadic bool
+		results, variadic = p.parseParameters()
+		if variadic {
+			p.error("... not permitted on result type")
+		}
+	}
+
+	return types.NewSignature(recv, types.NewTuple(params...), types.NewTuple(results...), isVariadic)
+}
+
+// InterfaceType = "interface" "{" [ MethodList ] "}" .
+// MethodList    = Method { ";" Method } .
+// Method        = Name Signature .
+//
+// The methods of embedded interfaces are always "inlined"
+// by the compiler and thus embedded interfaces are never
+// visible in the export data.
+//
+func (p *parser) parseInterfaceType(parent *types.Package) types.Type {
+	var methods []*types.Func
+
+	p.expectKeyword("interface")
+	p.expect('{')
+	for i := 0; p.tok != '}' && p.tok != scanner.EOF; i++ {
+		if i > 0 {
+			p.expect(';')
+		}
+		pkg, name := p.parseName(parent, true)
+		sig := p.parseSignature(nil)
+		methods = append(methods, types.NewFunc(token.NoPos, pkg, name, sig))
+	}
+	p.expect('}')
+
+	// Complete requires the type's embedded interfaces to be fully defined,
+	// but we do not define any
+	return types.NewInterface(methods, nil).Complete()
+}
+
+// ChanType = ( "chan" [ "<-" ] | "<-" "chan" ) Type .
+//
+func (p *parser) parseChanType(parent *types.Package) types.Type {
+	dir := types.SendRecv
+	if p.tok == scanner.Ident {
+		p.expectKeyword("chan")
+		if p.tok == '<' {
+			p.expectSpecial("<-")
+			dir = types.SendOnly
+		}
+	} else {
+		p.expectSpecial("<-")
+		p.expectKeyword("chan")
+		dir = types.RecvOnly
+	}
+	elem := p.parseType(parent)
+	return types.NewChan(dir, elem)
+}
+
+// Type =
+//	BasicType | TypeName | ArrayType | SliceType | StructType |
+//      PointerType | FuncType | InterfaceType | MapType | ChanType |
+//      "(" Type ")" .
+//
+// BasicType   = ident .
+// TypeName    = ExportedName .
+// SliceType   = "[" "]" Type .
+// PointerType = "*" Type .
+// FuncType    = "func" Signature .
+//
+func (p *parser) parseType(parent *types.Package) types.Type {
+	switch p.tok {
+	case scanner.Ident:
+		switch p.lit {
+		default:
+			return p.parseBasicType()
+		case "struct":
+			return p.parseStructType(parent)
+		case "func":
+			// FuncType
+			p.next()
+			return p.parseSignature(nil)
+		case "interface":
+			return p.parseInterfaceType(parent)
+		case "map":
+			return p.parseMapType(parent)
+		case "chan":
+			return p.parseChanType(parent)
+		}
+	case '@':
+		// TypeName
+		pkg, name := p.parseExportedName()
+		return declTypeName(pkg, name).Type()
+	case '[':
+		p.next() // look ahead
+		if p.tok == ']' {
+			// SliceType
+			p.next()
+			return types.NewSlice(p.parseType(parent))
+		}
+		return p.parseArrayType(parent)
+	case '*':
+		// PointerType
+		p.next()
+		return types.NewPointer(p.parseType(parent))
+	case '<':
+		return p.parseChanType(parent)
+	case '(':
+		// "(" Type ")"
+		p.next()
+		typ := p.parseType(parent)
+		p.expect(')')
+		return typ
+	}
+	p.errorf("expected type, got %s (%q)", scanner.TokenString(p.tok), p.lit)
+	return nil
+}
+
+// ----------------------------------------------------------------------------
+// Declarations
+
+// ImportDecl = "import" PackageName PackageId .
+//
+func (p *parser) parseImportDecl() {
+	p.expectKeyword("import")
+	name := p.parsePackageName()
+	p.getPkg(p.parsePackageId(), name)
+}
+
+// int_lit = [ "+" | "-" ] { "0" ... "9" } .
+//
+func (p *parser) parseInt() string {
+	s := ""
+	switch p.tok {
+	case '-':
+		s = "-"
+		p.next()
+	case '+':
+		p.next()
+	}
+	return s + p.expect(scanner.Int)
+}
+
+// number = int_lit [ "p" int_lit ] .
+//
+func (p *parser) parseNumber() (typ *types.Basic, val exact.Value) {
+	// mantissa
+	mant := exact.MakeFromLiteral(p.parseInt(), token.INT, 0)
+	if mant == nil {
+		panic("invalid mantissa")
+	}
+
+	if p.lit == "p" {
+		// exponent (base 2)
+		p.next()
+		exp, err := strconv.ParseInt(p.parseInt(), 10, 0)
+		if err != nil {
+			p.error(err)
+		}
+		if exp < 0 {
+			denom := exact.MakeInt64(1)
+			denom = exact.Shift(denom, token.SHL, uint(-exp))
+			typ = types.Typ[types.UntypedFloat]
+			val = exact.BinaryOp(mant, token.QUO, denom)
+			return
+		}
+		if exp > 0 {
+			mant = exact.Shift(mant, token.SHL, uint(exp))
+		}
+		typ = types.Typ[types.UntypedFloat]
+		val = mant
+		return
+	}
+
+	typ = types.Typ[types.UntypedInt]
+	val = mant
+	return
+}
+
+// ConstDecl   = "const" ExportedName [ Type ] "=" Literal .
+// Literal     = bool_lit | int_lit | float_lit | complex_lit | rune_lit | string_lit .
+// bool_lit    = "true" | "false" .
+// complex_lit = "(" float_lit "+" float_lit "i" ")" .
+// rune_lit    = "(" int_lit "+" int_lit ")" .
+// string_lit  = `"` { unicode_char } `"` .
+//
+func (p *parser) parseConstDecl() {
+	p.expectKeyword("const")
+	pkg, name := p.parseExportedName()
+
+	var typ0 types.Type
+	if p.tok != '=' {
+		// constant types are never structured - no need for parent type
+		typ0 = p.parseType(nil)
+	}
+
+	p.expect('=')
+	var typ types.Type
+	var val exact.Value
+	switch p.tok {
+	case scanner.Ident:
+		// bool_lit
+		if p.lit != "true" && p.lit != "false" {
+			p.error("expected true or false")
+		}
+		typ = types.Typ[types.UntypedBool]
+		val = exact.MakeBool(p.lit == "true")
+		p.next()
+
+	case '-', scanner.Int:
+		// int_lit
+		typ, val = p.parseNumber()
+
+	case '(':
+		// complex_lit or rune_lit
+		p.next()
+		if p.tok == scanner.Char {
+			p.next()
+			p.expect('+')
+			typ = types.Typ[types.UntypedRune]
+			_, val = p.parseNumber()
+			p.expect(')')
+			break
+		}
+		_, re := p.parseNumber()
+		p.expect('+')
+		_, im := p.parseNumber()
+		p.expectKeyword("i")
+		p.expect(')')
+		typ = types.Typ[types.UntypedComplex]
+		val = exact.BinaryOp(re, token.ADD, exact.MakeImag(im))
+
+	case scanner.Char:
+		// rune_lit
+		typ = types.Typ[types.UntypedRune]
+		val = exact.MakeFromLiteral(p.lit, token.CHAR, 0)
+		p.next()
+
+	case scanner.String:
+		// string_lit
+		typ = types.Typ[types.UntypedString]
+		val = exact.MakeFromLiteral(p.lit, token.STRING, 0)
+		p.next()
+
+	default:
+		p.errorf("expected literal got %s", scanner.TokenString(p.tok))
+	}
+
+	if typ0 == nil {
+		typ0 = typ
+	}
+
+	pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, name, typ0, val))
+}
+
+// TypeDecl = "type" ExportedName Type .
+//
+func (p *parser) parseTypeDecl() {
+	p.expectKeyword("type")
+	pkg, name := p.parseExportedName()
+	obj := declTypeName(pkg, name)
+
+	// The type object may have been imported before and thus already
+	// have a type associated with it. We still need to parse the type
+	// structure, but throw it away if the object already has a type.
+	// This ensures that all imports refer to the same type object for
+	// a given type declaration.
+	typ := p.parseType(pkg)
+
+	if name := obj.Type().(*types.Named); name.Underlying() == nil {
+		name.SetUnderlying(typ)
+	}
+}
+
+// VarDecl = "var" ExportedName Type .
+//
+func (p *parser) parseVarDecl() {
+	p.expectKeyword("var")
+	pkg, name := p.parseExportedName()
+	typ := p.parseType(pkg)
+	pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, name, typ))
+}
+
+// Func = Signature [ Body ] .
+// Body = "{" ... "}" .
+//
+func (p *parser) parseFunc(recv *types.Var) *types.Signature {
+	sig := p.parseSignature(recv)
+	if p.tok == '{' {
+		p.next()
+		for i := 1; i > 0; p.next() {
+			switch p.tok {
+			case '{':
+				i++
+			case '}':
+				i--
+			}
+		}
+	}
+	return sig
+}
+
+// MethodDecl = "func" Receiver Name Func .
+// Receiver   = "(" ( identifier | "?" ) [ "*" ] ExportedName ")" .
+//
+func (p *parser) parseMethodDecl() {
+	// "func" already consumed
+	p.expect('(')
+	recv, _ := p.parseParameter() // receiver
+	p.expect(')')
+
+	// determine receiver base type object
+	base := deref(recv.Type()).(*types.Named)
+
+	// parse method name, signature, and possibly inlined body
+	_, name := p.parseName(nil, false)
+	sig := p.parseFunc(recv)
+
+	// methods always belong to the same package as the base type object
+	pkg := base.Obj().Pkg()
+
+	// add method to type unless type was imported before
+	// and method exists already
+	// TODO(gri) This leads to a quadratic algorithm - ok for now because method counts are small.
+	base.AddMethod(types.NewFunc(token.NoPos, pkg, name, sig))
+}
+
+// FuncDecl = "func" ExportedName Func .
+//
+func (p *parser) parseFuncDecl() {
+	// "func" already consumed
+	pkg, name := p.parseExportedName()
+	typ := p.parseFunc(nil)
+	pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, name, typ))
+}
+
+// Decl = [ ImportDecl | ConstDecl | TypeDecl | VarDecl | FuncDecl | MethodDecl ] "\n" .
+//
+func (p *parser) parseDecl() {
+	if p.tok == scanner.Ident {
+		switch p.lit {
+		case "import":
+			p.parseImportDecl()
+		case "const":
+			p.parseConstDecl()
+		case "type":
+			p.parseTypeDecl()
+		case "var":
+			p.parseVarDecl()
+		case "func":
+			p.next() // look ahead
+			if p.tok == '(' {
+				p.parseMethodDecl()
+			} else {
+				p.parseFuncDecl()
+			}
+		}
+	}
+	p.expect('\n')
+}
+
+// ----------------------------------------------------------------------------
+// Export
+
+// Export        = "PackageClause { Decl } "$$" .
+// PackageClause = "package" PackageName [ "safe" ] "\n" .
+//
+func (p *parser) parseExport() *types.Package {
+	p.expectKeyword("package")
+	name := p.parsePackageName()
+	if p.tok == scanner.Ident && p.lit == "safe" {
+		// package was compiled with -u option - ignore
+		p.next()
+	}
+	p.expect('\n')
+
+	pkg := p.getPkg(p.id, name)
+
+	for p.tok != '$' && p.tok != scanner.EOF {
+		p.parseDecl()
+	}
+
+	if ch := p.scanner.Peek(); p.tok != '$' || ch != '$' {
+		// don't call next()/expect() since reading past the
+		// export data may cause scanner errors (e.g. NUL chars)
+		p.errorf("expected '$$', got %s %c", scanner.TokenString(p.tok), ch)
+	}
+
+	if n := p.scanner.ErrorCount; n != 0 {
+		p.errorf("expected no scanner errors, got %d", n)
+	}
+
+	// Record all locally referenced packages as imports.
+	var imports []*types.Package
+	for id, pkg2 := range p.localPkgs {
+		if pkg2.Name() == "" {
+			p.errorf("%s package has no name", id)
+		}
+		if id == p.id {
+			continue // avoid self-edge
+		}
+		imports = append(imports, pkg2)
+	}
+	sort.Sort(byPath(imports))
+	pkg.SetImports(imports)
+
+	// package was imported completely and without errors
+	pkg.MarkComplete()
+
+	return pkg
+}
+
+type byPath []*types.Package
+
+func (a byPath) Len() int           { return len(a) }
+func (a byPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go b/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go
new file mode 100644
index 0000000000000000000000000000000000000000..225ffeedfa4ad93c80995754180985c6ff062b9e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/isAlias18.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.9
+
+package gcimporter
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return false // there are no type aliases before Go 1.9
+}
diff --git a/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go b/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2025d84a952c11b0051b9248ada0b5f751c5aa1
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcimporter15/isAlias19.go
@@ -0,0 +1,13 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.9
+
+package gcimporter
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return obj.IsAlias()
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk.go b/vendor/golang.org/x/tools/imports/fastwalk.go
new file mode 100644
index 0000000000000000000000000000000000000000..31e6e27b0d564ec6deebe6ddb19e5666eb25a509
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk.go
@@ -0,0 +1,187 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// A faster implementation of filepath.Walk.
+//
+// filepath.Walk's design necessarily calls os.Lstat on each file,
+// even if the caller needs less info. And goimports only need to know
+// the type of each file. The kernel interface provides the type in
+// the Readdir call but the standard library ignored it.
+// fastwalk_unix.go contains a fork of the syscall routines.
+//
+// See golang.org/issue/16399
+
+package imports
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+// traverseLink is a sentinel error for fastWalk, similar to filepath.SkipDir.
+var traverseLink = errors.New("traverse symlink, assuming target is a directory")
+
+// fastWalk walks the file tree rooted at root, calling walkFn for
+// each file or directory in the tree, including root.
+//
+// If fastWalk returns filepath.SkipDir, the directory is skipped.
+//
+// Unlike filepath.Walk:
+//   * file stat calls must be done by the user.
+//     The only provided metadata is the file type, which does not include
+//     any permission bits.
+//   * multiple goroutines stat the filesystem concurrently. The provided
+//     walkFn must be safe for concurrent use.
+//   * fastWalk can follow symlinks if walkFn returns the traverseLink
+//     sentinel error. It is the walkFn's responsibility to prevent
+//     fastWalk from going into symlink cycles.
+func fastWalk(root string, walkFn func(path string, typ os.FileMode) error) error {
+	// TODO(bradfitz): make numWorkers configurable? We used a
+	// minimum of 4 to give the kernel more info about multiple
+	// things we want, in hopes its I/O scheduling can take
+	// advantage of that. Hopefully most are in cache. Maybe 4 is
+	// even too low of a minimum. Profile more.
+	numWorkers := 4
+	if n := runtime.NumCPU(); n > numWorkers {
+		numWorkers = n
+	}
+
+	// Make sure to wait for all workers to finish, otherwise
+	// walkFn could still be called after returning. This Wait call
+	// runs after close(e.donec) below.
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	w := &walker{
+		fn:       walkFn,
+		enqueuec: make(chan walkItem, numWorkers), // buffered for performance
+		workc:    make(chan walkItem, numWorkers), // buffered for performance
+		donec:    make(chan struct{}),
+
+		// buffered for correctness & not leaking goroutines:
+		resc: make(chan error, numWorkers),
+	}
+	defer close(w.donec)
+
+	for i := 0; i < numWorkers; i++ {
+		wg.Add(1)
+		go w.doWork(&wg)
+	}
+	todo := []walkItem{{dir: root}}
+	out := 0
+	for {
+		workc := w.workc
+		var workItem walkItem
+		if len(todo) == 0 {
+			workc = nil
+		} else {
+			workItem = todo[len(todo)-1]
+		}
+		select {
+		case workc <- workItem:
+			todo = todo[:len(todo)-1]
+			out++
+		case it := <-w.enqueuec:
+			todo = append(todo, it)
+		case err := <-w.resc:
+			out--
+			if err != nil {
+				return err
+			}
+			if out == 0 && len(todo) == 0 {
+				// It's safe to quit here, as long as the buffered
+				// enqueue channel isn't also readable, which might
+				// happen if the worker sends both another unit of
+				// work and its result before the other select was
+				// scheduled and both w.resc and w.enqueuec were
+				// readable.
+				select {
+				case it := <-w.enqueuec:
+					todo = append(todo, it)
+				default:
+					return nil
+				}
+			}
+		}
+	}
+}
+
+// doWork reads directories as instructed (via workc) and runs the
+// user's callback function.
+func (w *walker) doWork(wg *sync.WaitGroup) {
+	defer wg.Done()
+	for {
+		select {
+		case <-w.donec:
+			return
+		case it := <-w.workc:
+			select {
+			case <-w.donec:
+				return
+			case w.resc <- w.walk(it.dir, !it.callbackDone):
+			}
+		}
+	}
+}
+
+type walker struct {
+	fn func(path string, typ os.FileMode) error
+
+	donec    chan struct{} // closed on fastWalk's return
+	workc    chan walkItem // to workers
+	enqueuec chan walkItem // from workers
+	resc     chan error    // from workers
+}
+
+type walkItem struct {
+	dir          string
+	callbackDone bool // callback already called; don't do it again
+}
+
+func (w *walker) enqueue(it walkItem) {
+	select {
+	case w.enqueuec <- it:
+	case <-w.donec:
+	}
+}
+
+func (w *walker) onDirEnt(dirName, baseName string, typ os.FileMode) error {
+	joined := dirName + string(os.PathSeparator) + baseName
+	if typ == os.ModeDir {
+		w.enqueue(walkItem{dir: joined})
+		return nil
+	}
+
+	err := w.fn(joined, typ)
+	if typ == os.ModeSymlink {
+		if err == traverseLink {
+			// Set callbackDone so we don't call it twice for both the
+			// symlink-as-symlink and the symlink-as-directory later:
+			w.enqueue(walkItem{dir: joined, callbackDone: true})
+			return nil
+		}
+		if err == filepath.SkipDir {
+			// Permit SkipDir on symlinks too.
+			return nil
+		}
+	}
+	return err
+}
+
+func (w *walker) walk(root string, runUserCallback bool) error {
+	if runUserCallback {
+		err := w.fn(root, os.ModeDir)
+		if err == filepath.SkipDir {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return readDir(root, w.onDirEnt)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go b/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go
new file mode 100644
index 0000000000000000000000000000000000000000..f1fd64949dbf05ddea09be684d6fd0e7a3815e4f
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_dirent_fileno.go
@@ -0,0 +1,13 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build freebsd openbsd netbsd
+
+package imports
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Fileno)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go b/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fc6de0387bd7aa5b39aa0f974073ac9294ddc72
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_dirent_ino.go
@@ -0,0 +1,14 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin
+// +build !appengine
+
+package imports
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Ino)
+}
diff --git a/vendor/golang.org/x/tools/imports/fastwalk_unix.go b/vendor/golang.org/x/tools/imports/fastwalk_unix.go
new file mode 100644
index 0000000000000000000000000000000000000000..db6ee8dafba8a97cb6a18549b82e24220c5635f7
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fastwalk_unix.go
@@ -0,0 +1,123 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin freebsd openbsd netbsd
+// +build !appengine
+
+package imports
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const blockSize = 8 << 10
+
+// unknownFileMode is a sentinel (and bogus) os.FileMode
+// value used to represent a syscall.DT_UNKNOWN Dirent.Type.
+const unknownFileMode os.FileMode = os.ModeNamedPipe | os.ModeSocket | os.ModeDevice
+
+func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
+	fd, err := syscall.Open(dirName, 0, 0)
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(fd)
+
+	// The buffer must be at least a block long.
+	buf := make([]byte, blockSize) // stack-allocated; doesn't escape
+	bufp := 0                      // starting read position in buf
+	nbuf := 0                      // end valid data in buf
+	for {
+		if bufp >= nbuf {
+			bufp = 0
+			nbuf, err = syscall.ReadDirent(fd, buf)
+			if err != nil {
+				return os.NewSyscallError("readdirent", err)
+			}
+			if nbuf <= 0 {
+				return nil
+			}
+		}
+		consumed, name, typ := parseDirEnt(buf[bufp:nbuf])
+		bufp += consumed
+		if name == "" || name == "." || name == ".." {
+			continue
+		}
+		// Fallback for filesystems (like old XFS) that don't
+		// support Dirent.Type and have DT_UNKNOWN (0) there
+		// instead.
+		if typ == unknownFileMode {
+			fi, err := os.Lstat(dirName + "/" + name)
+			if err != nil {
+				// It got deleted in the meantime.
+				if os.IsNotExist(err) {
+					continue
+				}
+				return err
+			}
+			typ = fi.Mode() & os.ModeType
+		}
+		if err := fn(dirName, name, typ); err != nil {
+			return err
+		}
+	}
+}
+
+func parseDirEnt(buf []byte) (consumed int, name string, typ os.FileMode) {
+	// golang.org/issue/15653
+	dirent := (*syscall.Dirent)(unsafe.Pointer(&buf[0]))
+	if v := unsafe.Offsetof(dirent.Reclen) + unsafe.Sizeof(dirent.Reclen); uintptr(len(buf)) < v {
+		panic(fmt.Sprintf("buf size of %d smaller than dirent header size %d", len(buf), v))
+	}
+	if len(buf) < int(dirent.Reclen) {
+		panic(fmt.Sprintf("buf size %d < record length %d", len(buf), dirent.Reclen))
+	}
+	consumed = int(dirent.Reclen)
+	if direntInode(dirent) == 0 { // File absent in directory.
+		return
+	}
+	switch dirent.Type {
+	case syscall.DT_REG:
+		typ = 0
+	case syscall.DT_DIR:
+		typ = os.ModeDir
+	case syscall.DT_LNK:
+		typ = os.ModeSymlink
+	case syscall.DT_BLK:
+		typ = os.ModeDevice
+	case syscall.DT_FIFO:
+		typ = os.ModeNamedPipe
+	case syscall.DT_SOCK:
+		typ = os.ModeSocket
+	case syscall.DT_UNKNOWN:
+		typ = unknownFileMode
+	default:
+		// Skip weird things.
+		// It's probably a DT_WHT (http://lwn.net/Articles/325369/)
+		// or something. Revisit if/when this package is moved outside
+		// of goimports. goimports only cares about regular files,
+		// symlinks, and directories.
+		return
+	}
+
+	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+	nameLen := bytes.IndexByte(nameBuf[:], 0)
+	if nameLen < 0 {
+		panic("failed to find terminating 0 byte in dirent")
+	}
+
+	// Special cases for common things:
+	if nameLen == 1 && nameBuf[0] == '.' {
+		name = "."
+	} else if nameLen == 2 && nameBuf[0] == '.' && nameBuf[1] == '.' {
+		name = ".."
+	} else {
+		name = string(nameBuf[:nameLen])
+	}
+	return
+}
diff --git a/vendor/golang.org/x/tools/imports/fix.go b/vendor/golang.org/x/tools/imports/fix.go
new file mode 100644
index 0000000000000000000000000000000000000000..e2460849763060cd6f42a504662282e128e14ce8
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/fix.go
@@ -0,0 +1,1008 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package imports
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// Debug controls verbose logging.
+var Debug = false
+
+var (
+	inTests = false      // set true by fix_test.go; if false, no need to use testMu
+	testMu  sync.RWMutex // guards globals reset by tests; used only if inTests
+)
+
+// LocalPrefix, if set, instructs Process to sort import paths with the given
+// prefix into another group after 3rd-party packages.
+var LocalPrefix string
+
+// importToGroup is a list of functions which map from an import path to
+// a group number.
+var importToGroup = []func(importPath string) (num int, ok bool){
+	func(importPath string) (num int, ok bool) {
+		if LocalPrefix != "" && strings.HasPrefix(importPath, LocalPrefix) {
+			return 3, true
+		}
+		return
+	},
+	func(importPath string) (num int, ok bool) {
+		if strings.HasPrefix(importPath, "appengine") {
+			return 2, true
+		}
+		return
+	},
+	func(importPath string) (num int, ok bool) {
+		if strings.Contains(importPath, ".") {
+			return 1, true
+		}
+		return
+	},
+}
+
+func importGroup(importPath string) int {
+	for _, fn := range importToGroup {
+		if n, ok := fn(importPath); ok {
+			return n
+		}
+	}
+	return 0
+}
+
+// importInfo is a summary of information about one import.
+type importInfo struct {
+	Path  string // full import path (e.g. "crypto/rand")
+	Alias string // import alias, if present (e.g. "crand")
+}
+
+// packageInfo is a summary of features found in a package.
+type packageInfo struct {
+	Globals map[string]bool       // symbol => true
+	Imports map[string]importInfo // pkg base name or alias => info
+}
+
+// dirPackageInfo exposes the dirPackageInfoFile function so that it can be overridden.
+var dirPackageInfo = dirPackageInfoFile
+
+// dirPackageInfoFile gets information from other files in the package.
+func dirPackageInfoFile(pkgName, srcDir, filename string) (*packageInfo, error) {
+	considerTests := strings.HasSuffix(filename, "_test.go")
+
+	// Handle file from stdin
+	if _, err := os.Stat(filename); err != nil {
+		if os.IsNotExist(err) {
+			return &packageInfo{}, nil
+		}
+		return nil, err
+	}
+
+	fileBase := filepath.Base(filename)
+	packageFileInfos, err := ioutil.ReadDir(srcDir)
+	if err != nil {
+		return nil, err
+	}
+
+	info := &packageInfo{Globals: make(map[string]bool), Imports: make(map[string]importInfo)}
+	for _, fi := range packageFileInfos {
+		if fi.Name() == fileBase || !strings.HasSuffix(fi.Name(), ".go") {
+			continue
+		}
+		if !considerTests && strings.HasSuffix(fi.Name(), "_test.go") {
+			continue
+		}
+
+		fileSet := token.NewFileSet()
+		root, err := parser.ParseFile(fileSet, filepath.Join(srcDir, fi.Name()), nil, 0)
+		if err != nil {
+			continue
+		}
+
+		for _, decl := range root.Decls {
+			genDecl, ok := decl.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+
+			for _, spec := range genDecl.Specs {
+				valueSpec, ok := spec.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				info.Globals[valueSpec.Names[0].Name] = true
+			}
+		}
+
+		for _, imp := range root.Imports {
+			impInfo := importInfo{Path: strings.Trim(imp.Path.Value, `"`)}
+			name := path.Base(impInfo.Path)
+			if imp.Name != nil {
+				name = strings.Trim(imp.Name.Name, `"`)
+				impInfo.Alias = name
+			}
+			info.Imports[name] = impInfo
+		}
+	}
+	return info, nil
+}
+
+func fixImports(fset *token.FileSet, f *ast.File, filename string) (added []string, err error) {
+	// refs are a set of possible package references currently unsatisfied by imports.
+	// first key: either base package (e.g. "fmt") or renamed package
+	// second key: referenced package symbol (e.g. "Println")
+	refs := make(map[string]map[string]bool)
+
+	// decls are the current package imports. key is base package or renamed package.
+	decls := make(map[string]*ast.ImportSpec)
+
+	abs, err := filepath.Abs(filename)
+	if err != nil {
+		return nil, err
+	}
+	srcDir := filepath.Dir(abs)
+	if Debug {
+		log.Printf("fixImports(filename=%q), abs=%q, srcDir=%q ...", filename, abs, srcDir)
+	}
+
+	var packageInfo *packageInfo
+	var loadedPackageInfo bool
+
+	// collect potential uses of packages.
+	var visitor visitFn
+	visitor = visitFn(func(node ast.Node) ast.Visitor {
+		if node == nil {
+			return visitor
+		}
+		switch v := node.(type) {
+		case *ast.ImportSpec:
+			if v.Name != nil {
+				decls[v.Name.Name] = v
+				break
+			}
+			ipath := strings.Trim(v.Path.Value, `"`)
+			if ipath == "C" {
+				break
+			}
+			local := importPathToName(ipath, srcDir)
+			decls[local] = v
+		case *ast.SelectorExpr:
+			xident, ok := v.X.(*ast.Ident)
+			if !ok {
+				break
+			}
+			if xident.Obj != nil {
+				// if the parser can resolve it, it's not a package ref
+				break
+			}
+			pkgName := xident.Name
+			if refs[pkgName] == nil {
+				refs[pkgName] = make(map[string]bool)
+			}
+			if !loadedPackageInfo {
+				loadedPackageInfo = true
+				packageInfo, _ = dirPackageInfo(f.Name.Name, srcDir, filename)
+			}
+			if decls[pkgName] == nil && (packageInfo == nil || !packageInfo.Globals[pkgName]) {
+				refs[pkgName][v.Sel.Name] = true
+			}
+		}
+		return visitor
+	})
+	ast.Walk(visitor, f)
+
+	// Nil out any unused ImportSpecs, to be removed in following passes
+	unusedImport := map[string]string{}
+	for pkg, is := range decls {
+		if refs[pkg] == nil && pkg != "_" && pkg != "." {
+			name := ""
+			if is.Name != nil {
+				name = is.Name.Name
+			}
+			unusedImport[strings.Trim(is.Path.Value, `"`)] = name
+		}
+	}
+	for ipath, name := range unusedImport {
+		if ipath == "C" {
+			// Don't remove cgo stuff.
+			continue
+		}
+		astutil.DeleteNamedImport(fset, f, name, ipath)
+	}
+
+	for pkgName, symbols := range refs {
+		if len(symbols) == 0 {
+			// skip over packages already imported
+			delete(refs, pkgName)
+		}
+	}
+
+	// Fast path, all references already imported.
+	if len(refs) == 0 {
+		return nil, nil
+	}
+
+	// Can assume this will be necessary in all cases now.
+	if !loadedPackageInfo {
+		packageInfo, _ = dirPackageInfo(f.Name.Name, srcDir, filename)
+	}
+
+	// Search for imports matching potential package references.
+	searches := 0
+	type result struct {
+		ipath string // import path (if err == nil)
+		name  string // optional name to rename import as
+		err   error
+	}
+	results := make(chan result)
+	for pkgName, symbols := range refs {
+		go func(pkgName string, symbols map[string]bool) {
+			if packageInfo != nil {
+				sibling := packageInfo.Imports[pkgName]
+				if sibling.Path != "" {
+					results <- result{ipath: sibling.Path, name: sibling.Alias}
+					return
+				}
+			}
+			ipath, rename, err := findImport(pkgName, symbols, filename)
+			r := result{ipath: ipath, err: err}
+			if rename {
+				r.name = pkgName
+			}
+			results <- r
+		}(pkgName, symbols)
+		searches++
+	}
+	for i := 0; i < searches; i++ {
+		result := <-results
+		if result.err != nil {
+			return nil, result.err
+		}
+		if result.ipath != "" {
+			if result.name != "" {
+				astutil.AddNamedImport(fset, f, result.name, result.ipath)
+			} else {
+				astutil.AddImport(fset, f, result.ipath)
+			}
+			added = append(added, result.ipath)
+		}
+	}
+
+	return added, nil
+}
+
+// importPathToName returns the package name for the given import path.
+var importPathToName func(importPath, srcDir string) (packageName string) = importPathToNameGoPath
+
+// importPathToNameBasic assumes the package name is the base of import path.
+func importPathToNameBasic(importPath, srcDir string) (packageName string) {
+	return path.Base(importPath)
+}
+
+// importPathToNameGoPath finds out the actual package name, as declared in its .go files.
+// If there's a problem, it falls back to using importPathToNameBasic.
+func importPathToNameGoPath(importPath, srcDir string) (packageName string) {
+	// Fast path for standard library without going to disk.
+	if pkg, ok := stdImportPackage[importPath]; ok {
+		return pkg
+	}
+
+	pkgName, err := importPathToNameGoPathParse(importPath, srcDir)
+	if Debug {
+		log.Printf("importPathToNameGoPathParse(%q, srcDir=%q) = %q, %v", importPath, srcDir, pkgName, err)
+	}
+	if err == nil {
+		return pkgName
+	}
+	return importPathToNameBasic(importPath, srcDir)
+}
+
+// importPathToNameGoPathParse is a faster version of build.Import if
+// the only thing desired is the package name. It uses build.FindOnly
+// to find the directory and then only parses one file in the package,
+// trusting that the files in the directory are consistent.
+func importPathToNameGoPathParse(importPath, srcDir string) (packageName string, err error) {
+	buildPkg, err := build.Import(importPath, srcDir, build.FindOnly)
+	if err != nil {
+		return "", err
+	}
+	d, err := os.Open(buildPkg.Dir)
+	if err != nil {
+		return "", err
+	}
+	names, err := d.Readdirnames(-1)
+	d.Close()
+	if err != nil {
+		return "", err
+	}
+	sort.Strings(names) // to have predictable behavior
+	var lastErr error
+	var nfile int
+	for _, name := range names {
+		if !strings.HasSuffix(name, ".go") {
+			continue
+		}
+		if strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		nfile++
+		fullFile := filepath.Join(buildPkg.Dir, name)
+
+		fset := token.NewFileSet()
+		f, err := parser.ParseFile(fset, fullFile, nil, parser.PackageClauseOnly)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		pkgName := f.Name.Name
+		if pkgName == "documentation" {
+			// Special case from go/build.ImportDir, not
+			// handled by ctx.MatchFile.
+			continue
+		}
+		if pkgName == "main" {
+			// Also skip package main, assuming it's a +build ignore generator or example.
+			// Since you can't import a package main anyway, there's no harm here.
+			continue
+		}
+		return pkgName, nil
+	}
+	if lastErr != nil {
+		return "", lastErr
+	}
+	return "", fmt.Errorf("no importable package found in %d Go files", nfile)
+}
+
+var stdImportPackage = map[string]string{} // "net/http" => "http"
+
+func init() {
+	// Nothing in the standard library has a package name not
+	// matching its import base name.
+	for _, pkg := range stdlib {
+		if _, ok := stdImportPackage[pkg]; !ok {
+			stdImportPackage[pkg] = path.Base(pkg)
+		}
+	}
+}
+
+// Directory-scanning state.
+var (
+	// scanGoRootOnce guards calling scanGoRoot (for $GOROOT)
+	scanGoRootOnce sync.Once
+	// scanGoPathOnce guards calling scanGoPath (for $GOPATH)
+	scanGoPathOnce sync.Once
+
+	// populateIgnoreOnce guards calling populateIgnore
+	populateIgnoreOnce sync.Once
+	ignoredDirs        []os.FileInfo
+
+	dirScanMu sync.RWMutex
+	dirScan   map[string]*pkg // abs dir path => *pkg
+)
+
+type pkg struct {
+	dir             string // absolute file path to pkg directory ("/usr/lib/go/src/net/http")
+	importPath      string // full pkg import path ("net/http", "foo/bar/vendor/a/b")
+	importPathShort string // vendorless import path ("net/http", "a/b")
+}
+
+// byImportPathShortLength sorts by the short import path length, breaking ties on the
+// import string itself.
+type byImportPathShortLength []*pkg
+
+func (s byImportPathShortLength) Len() int { return len(s) }
+func (s byImportPathShortLength) Less(i, j int) bool {
+	vi, vj := s[i].importPathShort, s[j].importPathShort
+	return len(vi) < len(vj) || (len(vi) == len(vj) && vi < vj)
+
+}
+func (s byImportPathShortLength) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// guarded by populateIgnoreOnce; populates ignoredDirs.
+func populateIgnore() {
+	for _, srcDir := range build.Default.SrcDirs() {
+		if srcDir == filepath.Join(build.Default.GOROOT, "src") {
+			continue
+		}
+		populateIgnoredDirs(srcDir)
+	}
+}
+
+// populateIgnoredDirs reads an optional config file at <path>/.goimportsignore
+// of relative directories to ignore when scanning for go files.
+// The provided path is one of the $GOPATH entries with "src" appended.
+func populateIgnoredDirs(path string) {
+	file := filepath.Join(path, ".goimportsignore")
+	slurp, err := ioutil.ReadFile(file)
+	if Debug {
+		if err != nil {
+			log.Print(err)
+		} else {
+			log.Printf("Read %s", file)
+		}
+	}
+	if err != nil {
+		return
+	}
+	bs := bufio.NewScanner(bytes.NewReader(slurp))
+	for bs.Scan() {
+		line := strings.TrimSpace(bs.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		full := filepath.Join(path, line)
+		if fi, err := os.Stat(full); err == nil {
+			ignoredDirs = append(ignoredDirs, fi)
+			if Debug {
+				log.Printf("Directory added to ignore list: %s", full)
+			}
+		} else if Debug {
+			log.Printf("Error statting entry in .goimportsignore: %v", err)
+		}
+	}
+}
+
+func skipDir(fi os.FileInfo) bool {
+	for _, ignoredDir := range ignoredDirs {
+		if os.SameFile(fi, ignoredDir) {
+			return true
+		}
+	}
+	return false
+}
+
+// shouldTraverse reports whether the symlink fi should, found in dir,
+// should be followed.  It makes sure symlinks were never visited
+// before to avoid symlink loops.
+func shouldTraverse(dir string, fi os.FileInfo) bool {
+	path := filepath.Join(dir, fi.Name())
+	target, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			fmt.Fprintln(os.Stderr, err)
+		}
+		return false
+	}
+	ts, err := os.Stat(target)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return false
+	}
+	if !ts.IsDir() {
+		return false
+	}
+	if skipDir(ts) {
+		return false
+	}
+	// Check for symlink loops by statting each directory component
+	// and seeing if any are the same file as ts.
+	for {
+		parent := filepath.Dir(path)
+		if parent == path {
+			// Made it to the root without seeing a cycle.
+			// Use this symlink.
+			return true
+		}
+		parentInfo, err := os.Stat(parent)
+		if err != nil {
+			return false
+		}
+		if os.SameFile(ts, parentInfo) {
+			// Cycle. Don't traverse.
+			return false
+		}
+		path = parent
+	}
+
+}
+
+var testHookScanDir = func(dir string) {}
+
+var scanGoRootDone = make(chan struct{}) // closed when scanGoRoot is done
+
+func scanGoRoot() {
+	go func() {
+		scanGoDirs(true)
+		close(scanGoRootDone)
+	}()
+}
+
+func scanGoPath() { scanGoDirs(false) }
+
+func scanGoDirs(goRoot bool) {
+	if Debug {
+		which := "$GOROOT"
+		if !goRoot {
+			which = "$GOPATH"
+		}
+		log.Printf("scanning " + which)
+		defer log.Printf("scanned " + which)
+	}
+	dirScanMu.Lock()
+	if dirScan == nil {
+		dirScan = make(map[string]*pkg)
+	}
+	dirScanMu.Unlock()
+
+	for _, srcDir := range build.Default.SrcDirs() {
+		isGoroot := srcDir == filepath.Join(build.Default.GOROOT, "src")
+		if isGoroot != goRoot {
+			continue
+		}
+		testHookScanDir(srcDir)
+		walkFn := func(path string, typ os.FileMode) error {
+			dir := filepath.Dir(path)
+			if typ.IsRegular() {
+				if dir == srcDir {
+					// Doesn't make sense to have regular files
+					// directly in your $GOPATH/src or $GOROOT/src.
+					return nil
+				}
+				if !strings.HasSuffix(path, ".go") {
+					return nil
+				}
+				dirScanMu.Lock()
+				if _, dup := dirScan[dir]; !dup {
+					importpath := filepath.ToSlash(dir[len(srcDir)+len("/"):])
+					dirScan[dir] = &pkg{
+						importPath:      importpath,
+						importPathShort: vendorlessImportPath(importpath),
+						dir:             dir,
+					}
+				}
+				dirScanMu.Unlock()
+				return nil
+			}
+			if typ == os.ModeDir {
+				base := filepath.Base(path)
+				if base == "" || base[0] == '.' || base[0] == '_' ||
+					base == "testdata" || base == "node_modules" {
+					return filepath.SkipDir
+				}
+				fi, err := os.Lstat(path)
+				if err == nil && skipDir(fi) {
+					if Debug {
+						log.Printf("skipping directory %q under %s", fi.Name(), dir)
+					}
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			if typ == os.ModeSymlink {
+				base := filepath.Base(path)
+				if strings.HasPrefix(base, ".#") {
+					// Emacs noise.
+					return nil
+				}
+				fi, err := os.Lstat(path)
+				if err != nil {
+					// Just ignore it.
+					return nil
+				}
+				if shouldTraverse(dir, fi) {
+					return traverseLink
+				}
+			}
+			return nil
+		}
+		if err := fastWalk(srcDir, walkFn); err != nil {
+			log.Printf("goimports: scanning directory %v: %v", srcDir, err)
+		}
+	}
+}
+
+// vendorlessImportPath returns the devendorized version of the provided import path.
+// e.g. "foo/bar/vendor/a/b" => "a/b"
+func vendorlessImportPath(ipath string) string {
+	// Devendorize for use in import statement.
+	if i := strings.LastIndex(ipath, "/vendor/"); i >= 0 {
+		return ipath[i+len("/vendor/"):]
+	}
+	if strings.HasPrefix(ipath, "vendor/") {
+		return ipath[len("vendor/"):]
+	}
+	return ipath
+}
+
+// loadExports returns the set of exported symbols in the package at dir.
+// It returns nil on error or if the package name in dir does not match expectPackage.
+var loadExports func(expectPackage, dir string) map[string]bool = loadExportsGoPath
+
+func loadExportsGoPath(expectPackage, dir string) map[string]bool {
+	if Debug {
+		log.Printf("loading exports in dir %s (seeking package %s)", dir, expectPackage)
+	}
+	exports := make(map[string]bool)
+
+	ctx := build.Default
+
+	// ReadDir is like ioutil.ReadDir, but only returns *.go files
+	// and filters out _test.go files since they're not relevant
+	// and only slow things down.
+	ctx.ReadDir = func(dir string) (notTests []os.FileInfo, err error) {
+		all, err := ioutil.ReadDir(dir)
+		if err != nil {
+			return nil, err
+		}
+		notTests = all[:0]
+		for _, fi := range all {
+			name := fi.Name()
+			if strings.HasSuffix(name, ".go") && !strings.HasSuffix(name, "_test.go") {
+				notTests = append(notTests, fi)
+			}
+		}
+		return notTests, nil
+	}
+
+	files, err := ctx.ReadDir(dir)
+	if err != nil {
+		log.Print(err)
+		return nil
+	}
+
+	fset := token.NewFileSet()
+
+	for _, fi := range files {
+		match, err := ctx.MatchFile(dir, fi.Name())
+		if err != nil || !match {
+			continue
+		}
+		fullFile := filepath.Join(dir, fi.Name())
+		f, err := parser.ParseFile(fset, fullFile, nil, 0)
+		if err != nil {
+			if Debug {
+				log.Printf("Parsing %s: %v", fullFile, err)
+			}
+			return nil
+		}
+		pkgName := f.Name.Name
+		if pkgName == "documentation" {
+			// Special case from go/build.ImportDir, not
+			// handled by ctx.MatchFile.
+			continue
+		}
+		if pkgName != expectPackage {
+			if Debug {
+				log.Printf("scan of dir %v is not expected package %v (actually %v)", dir, expectPackage, pkgName)
+			}
+			return nil
+		}
+		for name := range f.Scope.Objects {
+			if ast.IsExported(name) {
+				exports[name] = true
+			}
+		}
+	}
+
+	if Debug {
+		exportList := make([]string, 0, len(exports))
+		for k := range exports {
+			exportList = append(exportList, k)
+		}
+		sort.Strings(exportList)
+		log.Printf("loaded exports in dir %v (package %v): %v", dir, expectPackage, strings.Join(exportList, ", "))
+	}
+	return exports
+}
+
+// findImport searches for a package with the given symbols.
+// If no package is found, findImport returns ("", false, nil)
+//
+// This is declared as a variable rather than a function so goimports
+// can be easily extended by adding a file with an init function.
+//
+// The rename value tells goimports whether to use the package name as
+// a local qualifier in an import. For example, if findImports("pkg",
+// "X") returns ("foo/bar", rename=true), then goimports adds the
+// import line:
+// 	import pkg "foo/bar"
+// to satisfy uses of pkg.X in the file.
+var findImport func(pkgName string, symbols map[string]bool, filename string) (foundPkg string, rename bool, err error) = findImportGoPath
+
+// findImportGoPath is the normal implementation of findImport.
+// (Some companies have their own internally.)
+func findImportGoPath(pkgName string, symbols map[string]bool, filename string) (foundPkg string, rename bool, err error) {
+	if inTests {
+		testMu.RLock()
+		defer testMu.RUnlock()
+	}
+
+	// Fast path for the standard library.
+	// In the common case we hopefully never have to scan the GOPATH, which can
+	// be slow with moving disks.
+	if pkg, rename, ok := findImportStdlib(pkgName, symbols); ok {
+		return pkg, rename, nil
+	}
+	if pkgName == "rand" && symbols["Read"] {
+		// Special-case rand.Read.
+		//
+		// If findImportStdlib didn't find it above, don't go
+		// searching for it, lest it find and pick math/rand
+		// in GOROOT (new as of Go 1.6)
+		//
+		// crypto/rand is the safer choice.
+		return "", false, nil
+	}
+
+	// TODO(sameer): look at the import lines for other Go files in the
+	// local directory, since the user is likely to import the same packages
+	// in the current Go file.  Return rename=true when the other Go files
+	// use a renamed package that's also used in the current file.
+
+	// Read all the $GOPATH/src/.goimportsignore files before scanning directories.
+	populateIgnoreOnce.Do(populateIgnore)
+
+	// Start scanning the $GOROOT asynchronously, then run the
+	// GOPATH scan synchronously if needed, and then wait for the
+	// $GOROOT to finish.
+	//
+	// TODO(bradfitz): run each $GOPATH entry async. But nobody
+	// really has more than one anyway, so low priority.
+	scanGoRootOnce.Do(scanGoRoot) // async
+	if !fileInDir(filename, build.Default.GOROOT) {
+		scanGoPathOnce.Do(scanGoPath) // blocking
+	}
+	<-scanGoRootDone
+
+	// Find candidate packages, looking only at their directory names first.
+	var candidates []*pkg
+	for _, pkg := range dirScan {
+		if pkgIsCandidate(filename, pkgName, pkg) {
+			candidates = append(candidates, pkg)
+		}
+	}
+
+	// Sort the candidates by their import package length,
+	// assuming that shorter package names are better than long
+	// ones.  Note that this sorts by the de-vendored name, so
+	// there's no "penalty" for vendoring.
+	sort.Sort(byImportPathShortLength(candidates))
+	if Debug {
+		for i, pkg := range candidates {
+			log.Printf("%s candidate %d/%d: %v in %v", pkgName, i+1, len(candidates), pkg.importPathShort, pkg.dir)
+		}
+	}
+
+	// Collect exports for packages with matching names.
+
+	done := make(chan struct{}) // closed when we find the answer
+	defer close(done)
+
+	rescv := make([]chan *pkg, len(candidates))
+	for i := range candidates {
+		rescv[i] = make(chan *pkg)
+	}
+	const maxConcurrentPackageImport = 4
+	loadExportsSem := make(chan struct{}, maxConcurrentPackageImport)
+
+	go func() {
+		for i, pkg := range candidates {
+			select {
+			case loadExportsSem <- struct{}{}:
+				select {
+				case <-done:
+					return
+				default:
+				}
+			case <-done:
+				return
+			}
+			pkg := pkg
+			resc := rescv[i]
+			go func() {
+				if inTests {
+					testMu.RLock()
+					defer testMu.RUnlock()
+				}
+				defer func() { <-loadExportsSem }()
+				exports := loadExports(pkgName, pkg.dir)
+
+				// If it doesn't have the right
+				// symbols, send nil to mean no match.
+				for symbol := range symbols {
+					if !exports[symbol] {
+						pkg = nil
+						break
+					}
+				}
+				select {
+				case resc <- pkg:
+				case <-done:
+				}
+			}()
+		}
+	}()
+	for _, resc := range rescv {
+		pkg := <-resc
+		if pkg == nil {
+			continue
+		}
+		// If the package name in the source doesn't match the import path's base,
+		// return true so the rewriter adds a name (import foo "github.com/bar/go-foo")
+		needsRename := path.Base(pkg.importPath) != pkgName
+		return pkg.importPathShort, needsRename, nil
+	}
+	return "", false, nil
+}
+
+// pkgIsCandidate reports whether pkg is a candidate for satisfying the
+// finding which package pkgIdent in the file named by filename is trying
+// to refer to.
+//
+// This check is purely lexical and is meant to be as fast as possible
+// because it's run over all $GOPATH directories to filter out poor
+// candidates in order to limit the CPU and I/O later parsing the
+// exports in candidate packages.
+//
+// filename is the file being formatted.
+// pkgIdent is the package being searched for, like "client" (if
+// searching for "client.New")
+func pkgIsCandidate(filename, pkgIdent string, pkg *pkg) bool {
+	// Check "internal" and "vendor" visibility:
+	if !canUse(filename, pkg.dir) {
+		return false
+	}
+
+	// Speed optimization to minimize disk I/O:
+	// the last two components on disk must contain the
+	// package name somewhere.
+	//
+	// This permits mismatch naming like directory
+	// "go-foo" being package "foo", or "pkg.v3" being "pkg",
+	// or directory "google.golang.org/api/cloudbilling/v1"
+	// being package "cloudbilling", but doesn't
+	// permit a directory "foo" to be package
+	// "bar", which is strongly discouraged
+	// anyway. There's no reason goimports needs
+	// to be slow just to accomodate that.
+	lastTwo := lastTwoComponents(pkg.importPathShort)
+	if strings.Contains(lastTwo, pkgIdent) {
+		return true
+	}
+	if hasHyphenOrUpperASCII(lastTwo) && !hasHyphenOrUpperASCII(pkgIdent) {
+		lastTwo = lowerASCIIAndRemoveHyphen(lastTwo)
+		if strings.Contains(lastTwo, pkgIdent) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func hasHyphenOrUpperASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if b == '-' || ('A' <= b && b <= 'Z') {
+			return true
+		}
+	}
+	return false
+}
+
+func lowerASCIIAndRemoveHyphen(s string) (ret string) {
+	buf := make([]byte, 0, len(s))
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		switch {
+		case b == '-':
+			continue
+		case 'A' <= b && b <= 'Z':
+			buf = append(buf, b+('a'-'A'))
+		default:
+			buf = append(buf, b)
+		}
+	}
+	return string(buf)
+}
+
+// canUse reports whether the package in dir is usable from filename,
+// respecting the Go "internal" and "vendor" visibility rules.
+func canUse(filename, dir string) bool {
+	// Fast path check, before any allocations. If it doesn't contain vendor
+	// or internal, it's not tricky:
+	// Note that this can false-negative on directories like "notinternal",
+	// but we check it correctly below. This is just a fast path.
+	if !strings.Contains(dir, "vendor") && !strings.Contains(dir, "internal") {
+		return true
+	}
+
+	dirSlash := filepath.ToSlash(dir)
+	if !strings.Contains(dirSlash, "/vendor/") && !strings.Contains(dirSlash, "/internal/") && !strings.HasSuffix(dirSlash, "/internal") {
+		return true
+	}
+	// Vendor or internal directory only visible from children of parent.
+	// That means the path from the current directory to the target directory
+	// can contain ../vendor or ../internal but not ../foo/vendor or ../foo/internal
+	// or bar/vendor or bar/internal.
+	// After stripping all the leading ../, the only okay place to see vendor or internal
+	// is at the very beginning of the path.
+	absfile, err := filepath.Abs(filename)
+	if err != nil {
+		return false
+	}
+	absdir, err := filepath.Abs(dir)
+	if err != nil {
+		return false
+	}
+	rel, err := filepath.Rel(absfile, absdir)
+	if err != nil {
+		return false
+	}
+	relSlash := filepath.ToSlash(rel)
+	if i := strings.LastIndex(relSlash, "../"); i >= 0 {
+		relSlash = relSlash[i+len("../"):]
+	}
+	return !strings.Contains(relSlash, "/vendor/") && !strings.Contains(relSlash, "/internal/") && !strings.HasSuffix(relSlash, "/internal")
+}
+
+// lastTwoComponents returns at most the last two path components
+// of v, using either / or \ as the path separator.
+func lastTwoComponents(v string) string {
+	nslash := 0
+	for i := len(v) - 1; i >= 0; i-- {
+		if v[i] == '/' || v[i] == '\\' {
+			nslash++
+			if nslash == 2 {
+				return v[i:]
+			}
+		}
+	}
+	return v
+}
+
+type visitFn func(node ast.Node) ast.Visitor
+
+func (fn visitFn) Visit(node ast.Node) ast.Visitor {
+	return fn(node)
+}
+
+func findImportStdlib(shortPkg string, symbols map[string]bool) (importPath string, rename, ok bool) {
+	for symbol := range symbols {
+		key := shortPkg + "." + symbol
+		path := stdlib[key]
+		if path == "" {
+			if key == "rand.Read" {
+				continue
+			}
+			return "", false, false
+		}
+		if importPath != "" && importPath != path {
+			// Ambiguous. Symbols pointed to different things.
+			return "", false, false
+		}
+		importPath = path
+	}
+	if importPath == "" && shortPkg == "rand" && symbols["Read"] {
+		return "crypto/rand", false, true
+	}
+	return importPath, false, importPath != ""
+}
+
+// fileInDir reports whether the provided file path looks like
+// it's in dir. (without hitting the filesystem)
+func fileInDir(file, dir string) bool {
+	rest := strings.TrimPrefix(file, dir)
+	if len(rest) == len(file) {
+		// dir is not a prefix of file.
+		return false
+	}
+	// Check for boundary: either nothing (file == dir), or a slash.
+	return len(rest) == 0 || rest[0] == '/' || rest[0] == '\\'
+}
diff --git a/vendor/golang.org/x/tools/imports/imports.go b/vendor/golang.org/x/tools/imports/imports.go
new file mode 100644
index 0000000000000000000000000000000000000000..67573f497e4a7610d36d82bbbcec5e9bdd7fac84
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/imports.go
@@ -0,0 +1,289 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run mkstdlib.go
+
+// Package imports implements a Go pretty-printer (like package "go/format")
+// that also adds or removes import statements as necessary.
+package imports // import "golang.org/x/tools/imports"
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// Options specifies options for processing files.
+type Options struct {
+	Fragment  bool // Accept fragment of a source file (no package statement)
+	AllErrors bool // Report all errors (not just the first 10 on different lines)
+
+	Comments  bool // Print comments (true if nil *Options provided)
+	TabIndent bool // Use tabs for indent (true if nil *Options provided)
+	TabWidth  int  // Tab width (8 if nil *Options provided)
+
+	FormatOnly bool // Disable the insertion and deletion of imports
+}
+
+// Process formats and adjusts imports for the provided file.
+// If opt is nil the defaults are used.
+//
+// Note that filename's directory influences which imports can be chosen,
+// so it is important that filename be accurate.
+// To process data ``as if'' it were in filename, pass the data as a non-nil src.
+func Process(filename string, src []byte, opt *Options) ([]byte, error) {
+	if opt == nil {
+		opt = &Options{Comments: true, TabIndent: true, TabWidth: 8}
+	}
+
+	fileSet := token.NewFileSet()
+	file, adjust, err := parse(fileSet, filename, src, opt)
+	if err != nil {
+		return nil, err
+	}
+
+	if !opt.FormatOnly {
+		_, err = fixImports(fileSet, file, filename)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	sortImports(fileSet, file)
+	imps := astutil.Imports(fileSet, file)
+
+	var spacesBefore []string // import paths we need spaces before
+	for _, impSection := range imps {
+		// Within each block of contiguous imports, see if any
+		// import lines are in different group numbers. If so,
+		// we'll need to put a space between them so it's
+		// compatible with gofmt.
+		lastGroup := -1
+		for _, importSpec := range impSection {
+			importPath, _ := strconv.Unquote(importSpec.Path.Value)
+			groupNum := importGroup(importPath)
+			if groupNum != lastGroup && lastGroup != -1 {
+				spacesBefore = append(spacesBefore, importPath)
+			}
+			lastGroup = groupNum
+		}
+
+	}
+
+	printerMode := printer.UseSpaces
+	if opt.TabIndent {
+		printerMode |= printer.TabIndent
+	}
+	printConfig := &printer.Config{Mode: printerMode, Tabwidth: opt.TabWidth}
+
+	var buf bytes.Buffer
+	err = printConfig.Fprint(&buf, fileSet, file)
+	if err != nil {
+		return nil, err
+	}
+	out := buf.Bytes()
+	if adjust != nil {
+		out = adjust(src, out)
+	}
+	if len(spacesBefore) > 0 {
+		out = addImportSpaces(bytes.NewReader(out), spacesBefore)
+	}
+
+	out, err = format.Source(out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// parse parses src, which was read from filename,
+// as a Go source file or statement list.
+func parse(fset *token.FileSet, filename string, src []byte, opt *Options) (*ast.File, func(orig, src []byte) []byte, error) {
+	parserMode := parser.Mode(0)
+	if opt.Comments {
+		parserMode |= parser.ParseComments
+	}
+	if opt.AllErrors {
+		parserMode |= parser.AllErrors
+	}
+
+	// Try as whole source file.
+	file, err := parser.ParseFile(fset, filename, src, parserMode)
+	if err == nil {
+		return file, nil, nil
+	}
+	// If the error is that the source file didn't begin with a
+	// package line and we accept fragmented input, fall through to
+	// try as a source fragment.  Stop and return on any other error.
+	if !opt.Fragment || !strings.Contains(err.Error(), "expected 'package'") {
+		return nil, nil, err
+	}
+
+	// If this is a declaration list, make it a source file
+	// by inserting a package clause.
+	// Insert using a ;, not a newline, so that the line numbers
+	// in psrc match the ones in src.
+	psrc := append([]byte("package main;"), src...)
+	file, err = parser.ParseFile(fset, filename, psrc, parserMode)
+	if err == nil {
+		// If a main function exists, we will assume this is a main
+		// package and leave the file.
+		if containsMainFunc(file) {
+			return file, nil, nil
+		}
+
+		adjust := func(orig, src []byte) []byte {
+			// Remove the package clause.
+			// Gofmt has turned the ; into a \n.
+			src = src[len("package main\n"):]
+			return matchSpace(orig, src)
+		}
+		return file, adjust, nil
+	}
+	// If the error is that the source file didn't begin with a
+	// declaration, fall through to try as a statement list.
+	// Stop and return on any other error.
+	if !strings.Contains(err.Error(), "expected declaration") {
+		return nil, nil, err
+	}
+
+	// If this is a statement list, make it a source file
+	// by inserting a package clause and turning the list
+	// into a function body.  This handles expressions too.
+	// Insert using a ;, not a newline, so that the line numbers
+	// in fsrc match the ones in src.
+	fsrc := append(append([]byte("package p; func _() {"), src...), '}')
+	file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
+	if err == nil {
+		adjust := func(orig, src []byte) []byte {
+			// Remove the wrapping.
+			// Gofmt has turned the ; into a \n\n.
+			src = src[len("package p\n\nfunc _() {"):]
+			src = src[:len(src)-len("}\n")]
+			// Gofmt has also indented the function body one level.
+			// Remove that indent.
+			src = bytes.Replace(src, []byte("\n\t"), []byte("\n"), -1)
+			return matchSpace(orig, src)
+		}
+		return file, adjust, nil
+	}
+
+	// Failed, and out of options.
+	return nil, nil, err
+}
+
+// containsMainFunc checks if a file contains a function declaration with the
+// function signature 'func main()'
+func containsMainFunc(file *ast.File) bool {
+	for _, decl := range file.Decls {
+		if f, ok := decl.(*ast.FuncDecl); ok {
+			if f.Name.Name != "main" {
+				continue
+			}
+
+			if len(f.Type.Params.List) != 0 {
+				continue
+			}
+
+			if f.Type.Results != nil && len(f.Type.Results.List) != 0 {
+				continue
+			}
+
+			return true
+		}
+	}
+
+	return false
+}
+
+func cutSpace(b []byte) (before, middle, after []byte) {
+	i := 0
+	for i < len(b) && (b[i] == ' ' || b[i] == '\t' || b[i] == '\n') {
+		i++
+	}
+	j := len(b)
+	for j > 0 && (b[j-1] == ' ' || b[j-1] == '\t' || b[j-1] == '\n') {
+		j--
+	}
+	if i <= j {
+		return b[:i], b[i:j], b[j:]
+	}
+	return nil, nil, b[j:]
+}
+
+// matchSpace reformats src to use the same space context as orig.
+// 1) If orig begins with blank lines, matchSpace inserts them at the beginning of src.
+// 2) matchSpace copies the indentation of the first non-blank line in orig
+//    to every non-blank line in src.
+// 3) matchSpace copies the trailing space from orig and uses it in place
+//   of src's trailing space.
+func matchSpace(orig []byte, src []byte) []byte {
+	before, _, after := cutSpace(orig)
+	i := bytes.LastIndex(before, []byte{'\n'})
+	before, indent := before[:i+1], before[i+1:]
+
+	_, src, _ = cutSpace(src)
+
+	var b bytes.Buffer
+	b.Write(before)
+	for len(src) > 0 {
+		line := src
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, src = line[:i+1], line[i+1:]
+		} else {
+			src = nil
+		}
+		if len(line) > 0 && line[0] != '\n' { // not blank
+			b.Write(indent)
+		}
+		b.Write(line)
+	}
+	b.Write(after)
+	return b.Bytes()
+}
+
+var impLine = regexp.MustCompile(`^\s+(?:[\w\.]+\s+)?"(.+)"`)
+
+func addImportSpaces(r io.Reader, breaks []string) []byte {
+	var out bytes.Buffer
+	sc := bufio.NewScanner(r)
+	inImports := false
+	done := false
+	for sc.Scan() {
+		s := sc.Text()
+
+		if !inImports && !done && strings.HasPrefix(s, "import") {
+			inImports = true
+		}
+		if inImports && (strings.HasPrefix(s, "var") ||
+			strings.HasPrefix(s, "func") ||
+			strings.HasPrefix(s, "const") ||
+			strings.HasPrefix(s, "type")) {
+			done = true
+			inImports = false
+		}
+		if inImports && len(breaks) > 0 {
+			if m := impLine.FindStringSubmatch(s); m != nil {
+				if m[1] == breaks[0] {
+					out.WriteByte('\n')
+					breaks = breaks[1:]
+				}
+			}
+		}
+
+		fmt.Fprintln(&out, s)
+	}
+	return out.Bytes()
+}
diff --git a/vendor/golang.org/x/tools/imports/mkindex.go b/vendor/golang.org/x/tools/imports/mkindex.go
new file mode 100644
index 0000000000000000000000000000000000000000..755e2394f2d75ff74b4c753e0776b2381afc6cf3
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/mkindex.go
@@ -0,0 +1,173 @@
+// +build ignore
+
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Command mkindex creates the file "pkgindex.go" containing an index of the Go
+// standard library. The file is intended to be built as part of the imports
+// package, so that the package may be used in environments where a GOROOT is
+// not available (such as App Engine).
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+var (
+	pkgIndex = make(map[string][]pkg)
+	exports  = make(map[string]map[string]bool)
+)
+
+func main() {
+	// Don't use GOPATH.
+	ctx := build.Default
+	ctx.GOPATH = ""
+
+	// Populate pkgIndex global from GOROOT.
+	for _, path := range ctx.SrcDirs() {
+		f, err := os.Open(path)
+		if err != nil {
+			log.Print(err)
+			continue
+		}
+		children, err := f.Readdir(-1)
+		f.Close()
+		if err != nil {
+			log.Print(err)
+			continue
+		}
+		for _, child := range children {
+			if child.IsDir() {
+				loadPkg(path, child.Name())
+			}
+		}
+	}
+	// Populate exports global.
+	for _, ps := range pkgIndex {
+		for _, p := range ps {
+			e := loadExports(p.dir)
+			if e != nil {
+				exports[p.dir] = e
+			}
+		}
+	}
+
+	// Construct source file.
+	var buf bytes.Buffer
+	fmt.Fprint(&buf, pkgIndexHead)
+	fmt.Fprintf(&buf, "var pkgIndexMaster = %#v\n", pkgIndex)
+	fmt.Fprintf(&buf, "var exportsMaster = %#v\n", exports)
+	src := buf.Bytes()
+
+	// Replace main.pkg type name with pkg.
+	src = bytes.Replace(src, []byte("main.pkg"), []byte("pkg"), -1)
+	// Replace actual GOROOT with "/go".
+	src = bytes.Replace(src, []byte(ctx.GOROOT), []byte("/go"), -1)
+	// Add some line wrapping.
+	src = bytes.Replace(src, []byte("}, "), []byte("},\n"), -1)
+	src = bytes.Replace(src, []byte("true, "), []byte("true,\n"), -1)
+
+	var err error
+	src, err = format.Source(src)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Write out source file.
+	err = ioutil.WriteFile("pkgindex.go", src, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+const pkgIndexHead = `package imports
+
+func init() {
+	pkgIndexOnce.Do(func() {
+		pkgIndex.m = pkgIndexMaster
+	})
+	loadExports = func(dir string) map[string]bool {
+		return exportsMaster[dir]
+	}
+}
+`
+
+type pkg struct {
+	importpath string // full pkg import path, e.g. "net/http"
+	dir        string // absolute file path to pkg directory e.g. "/usr/lib/go/src/fmt"
+}
+
+var fset = token.NewFileSet()
+
+func loadPkg(root, importpath string) {
+	shortName := path.Base(importpath)
+	if shortName == "testdata" {
+		return
+	}
+
+	dir := filepath.Join(root, importpath)
+	pkgIndex[shortName] = append(pkgIndex[shortName], pkg{
+		importpath: importpath,
+		dir:        dir,
+	})
+
+	pkgDir, err := os.Open(dir)
+	if err != nil {
+		return
+	}
+	children, err := pkgDir.Readdir(-1)
+	pkgDir.Close()
+	if err != nil {
+		return
+	}
+	for _, child := range children {
+		name := child.Name()
+		if name == "" {
+			continue
+		}
+		if c := name[0]; c == '.' || ('0' <= c && c <= '9') {
+			continue
+		}
+		if child.IsDir() {
+			loadPkg(root, filepath.Join(importpath, name))
+		}
+	}
+}
+
+func loadExports(dir string) map[string]bool {
+	exports := make(map[string]bool)
+	buildPkg, err := build.ImportDir(dir, 0)
+	if err != nil {
+		if strings.Contains(err.Error(), "no buildable Go source files in") {
+			return nil
+		}
+		log.Printf("could not import %q: %v", dir, err)
+		return nil
+	}
+	for _, file := range buildPkg.GoFiles {
+		f, err := parser.ParseFile(fset, filepath.Join(dir, file), nil, 0)
+		if err != nil {
+			log.Printf("could not parse %q: %v", file, err)
+			continue
+		}
+		for name := range f.Scope.Objects {
+			if ast.IsExported(name) {
+				exports[name] = true
+			}
+		}
+	}
+	return exports
+}
diff --git a/vendor/golang.org/x/tools/imports/mkstdlib.go b/vendor/golang.org/x/tools/imports/mkstdlib.go
new file mode 100644
index 0000000000000000000000000000000000000000..6e6e1d6dc67d874803a52899588debe99474e5d5
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/mkstdlib.go
@@ -0,0 +1,105 @@
+// +build ignore
+
+// mkstdlib generates the zstdlib.go file, containing the Go standard
+// library API symbols. It's baked into the binary to avoid scanning
+// GOPATH in the common case.
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+func mustOpen(name string) io.Reader {
+	f, err := os.Open(name)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return f
+}
+
+func api(base string) string {
+	return filepath.Join(os.Getenv("GOROOT"), "api", base)
+}
+
+var sym = regexp.MustCompile(`^pkg (\S+).*?, (?:var|func|type|const) ([A-Z]\w*)`)
+
+func main() {
+	var buf bytes.Buffer
+	outf := func(format string, args ...interface{}) {
+		fmt.Fprintf(&buf, format, args...)
+	}
+	outf("// Code generated by mkstdlib.go. DO NOT EDIT.\n\n")
+	outf("package imports\n")
+	outf("var stdlib = map[string]string{\n")
+	f := io.MultiReader(
+		mustOpen(api("go1.txt")),
+		mustOpen(api("go1.1.txt")),
+		mustOpen(api("go1.2.txt")),
+		mustOpen(api("go1.3.txt")),
+		mustOpen(api("go1.4.txt")),
+		mustOpen(api("go1.5.txt")),
+		mustOpen(api("go1.6.txt")),
+		mustOpen(api("go1.7.txt")),
+		mustOpen(api("go1.8.txt")),
+		mustOpen(api("go1.9.txt")),
+	)
+	sc := bufio.NewScanner(f)
+	fullImport := map[string]string{} // "zip.NewReader" => "archive/zip"
+	ambiguous := map[string]bool{}
+	var keys []string
+	for sc.Scan() {
+		l := sc.Text()
+		has := func(v string) bool { return strings.Contains(l, v) }
+		if has("struct, ") || has("interface, ") || has(", method (") {
+			continue
+		}
+		if m := sym.FindStringSubmatch(l); m != nil {
+			full := m[1]
+			key := path.Base(full) + "." + m[2]
+			if exist, ok := fullImport[key]; ok {
+				if exist != full {
+					ambiguous[key] = true
+				}
+			} else {
+				fullImport[key] = full
+				keys = append(keys, key)
+			}
+		}
+	}
+	if err := sc.Err(); err != nil {
+		log.Fatal(err)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		if ambiguous[key] {
+			outf("\t// %q is ambiguous\n", key)
+		} else {
+			outf("\t%q: %q,\n", key, fullImport[key])
+		}
+	}
+	outf("\n")
+	for _, sym := range [...]string{"Alignof", "ArbitraryType", "Offsetof", "Pointer", "Sizeof"} {
+		outf("\t%q: %q,\n", "unsafe."+sym, "unsafe")
+	}
+	outf("}\n")
+	fmtbuf, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile("zstdlib.go", fmtbuf, 0666)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/vendor/golang.org/x/tools/imports/sortimports.go b/vendor/golang.org/x/tools/imports/sortimports.go
new file mode 100644
index 0000000000000000000000000000000000000000..653afc51776a09c6766dad36894bbe16a1accdc9
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/sortimports.go
@@ -0,0 +1,212 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Hacked up copy of go/ast/import.go
+
+package imports
+
+import (
+	"go/ast"
+	"go/token"
+	"sort"
+	"strconv"
+)
+
+// sortImports sorts runs of consecutive import lines in import blocks in f.
+// It also removes duplicate imports when it is possible to do so without data loss.
+func sortImports(fset *token.FileSet, f *ast.File) {
+	for i, d := range f.Decls {
+		d, ok := d.(*ast.GenDecl)
+		if !ok || d.Tok != token.IMPORT {
+			// Not an import declaration, so we're done.
+			// Imports are always first.
+			break
+		}
+
+		if len(d.Specs) == 0 {
+			// Empty import block, remove it.
+			f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
+		}
+
+		if !d.Lparen.IsValid() {
+			// Not a block: sorted by default.
+			continue
+		}
+
+		// Identify and sort runs of specs on successive lines.
+		i := 0
+		specs := d.Specs[:0]
+		for j, s := range d.Specs {
+			if j > i && fset.Position(s.Pos()).Line > 1+fset.Position(d.Specs[j-1].End()).Line {
+				// j begins a new run.  End this one.
+				specs = append(specs, sortSpecs(fset, f, d.Specs[i:j])...)
+				i = j
+			}
+		}
+		specs = append(specs, sortSpecs(fset, f, d.Specs[i:])...)
+		d.Specs = specs
+
+		// Deduping can leave a blank line before the rparen; clean that up.
+		if len(d.Specs) > 0 {
+			lastSpec := d.Specs[len(d.Specs)-1]
+			lastLine := fset.Position(lastSpec.Pos()).Line
+			if rParenLine := fset.Position(d.Rparen).Line; rParenLine > lastLine+1 {
+				fset.File(d.Rparen).MergeLine(rParenLine - 1)
+			}
+		}
+	}
+}
+
+func importPath(s ast.Spec) string {
+	t, err := strconv.Unquote(s.(*ast.ImportSpec).Path.Value)
+	if err == nil {
+		return t
+	}
+	return ""
+}
+
+func importName(s ast.Spec) string {
+	n := s.(*ast.ImportSpec).Name
+	if n == nil {
+		return ""
+	}
+	return n.Name
+}
+
+func importComment(s ast.Spec) string {
+	c := s.(*ast.ImportSpec).Comment
+	if c == nil {
+		return ""
+	}
+	return c.Text()
+}
+
+// collapse indicates whether prev may be removed, leaving only next.
+func collapse(prev, next ast.Spec) bool {
+	if importPath(next) != importPath(prev) || importName(next) != importName(prev) {
+		return false
+	}
+	return prev.(*ast.ImportSpec).Comment == nil
+}
+
+type posSpan struct {
+	Start token.Pos
+	End   token.Pos
+}
+
+func sortSpecs(fset *token.FileSet, f *ast.File, specs []ast.Spec) []ast.Spec {
+	// Can't short-circuit here even if specs are already sorted,
+	// since they might yet need deduplication.
+	// A lone import, however, may be safely ignored.
+	if len(specs) <= 1 {
+		return specs
+	}
+
+	// Record positions for specs.
+	pos := make([]posSpan, len(specs))
+	for i, s := range specs {
+		pos[i] = posSpan{s.Pos(), s.End()}
+	}
+
+	// Identify comments in this range.
+	// Any comment from pos[0].Start to the final line counts.
+	lastLine := fset.Position(pos[len(pos)-1].End).Line
+	cstart := len(f.Comments)
+	cend := len(f.Comments)
+	for i, g := range f.Comments {
+		if g.Pos() < pos[0].Start {
+			continue
+		}
+		if i < cstart {
+			cstart = i
+		}
+		if fset.Position(g.End()).Line > lastLine {
+			cend = i
+			break
+		}
+	}
+	comments := f.Comments[cstart:cend]
+
+	// Assign each comment to the import spec preceding it.
+	importComment := map[*ast.ImportSpec][]*ast.CommentGroup{}
+	specIndex := 0
+	for _, g := range comments {
+		for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
+			specIndex++
+		}
+		s := specs[specIndex].(*ast.ImportSpec)
+		importComment[s] = append(importComment[s], g)
+	}
+
+	// Sort the import specs by import path.
+	// Remove duplicates, when possible without data loss.
+	// Reassign the import paths to have the same position sequence.
+	// Reassign each comment to abut the end of its spec.
+	// Sort the comments by new position.
+	sort.Sort(byImportSpec(specs))
+
+	// Dedup. Thanks to our sorting, we can just consider
+	// adjacent pairs of imports.
+	deduped := specs[:0]
+	for i, s := range specs {
+		if i == len(specs)-1 || !collapse(s, specs[i+1]) {
+			deduped = append(deduped, s)
+		} else {
+			p := s.Pos()
+			fset.File(p).MergeLine(fset.Position(p).Line)
+		}
+	}
+	specs = deduped
+
+	// Fix up comment positions
+	for i, s := range specs {
+		s := s.(*ast.ImportSpec)
+		if s.Name != nil {
+			s.Name.NamePos = pos[i].Start
+		}
+		s.Path.ValuePos = pos[i].Start
+		s.EndPos = pos[i].End
+		for _, g := range importComment[s] {
+			for _, c := range g.List {
+				c.Slash = pos[i].End
+			}
+		}
+	}
+
+	sort.Sort(byCommentPos(comments))
+
+	return specs
+}
+
+type byImportSpec []ast.Spec // slice of *ast.ImportSpec
+
+func (x byImportSpec) Len() int      { return len(x) }
+func (x byImportSpec) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x byImportSpec) Less(i, j int) bool {
+	ipath := importPath(x[i])
+	jpath := importPath(x[j])
+
+	igroup := importGroup(ipath)
+	jgroup := importGroup(jpath)
+	if igroup != jgroup {
+		return igroup < jgroup
+	}
+
+	if ipath != jpath {
+		return ipath < jpath
+	}
+	iname := importName(x[i])
+	jname := importName(x[j])
+
+	if iname != jname {
+		return iname < jname
+	}
+	return importComment(x[i]) < importComment(x[j])
+}
+
+type byCommentPos []*ast.CommentGroup
+
+func (x byCommentPos) Len() int           { return len(x) }
+func (x byCommentPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() }
diff --git a/vendor/golang.org/x/tools/imports/zstdlib.go b/vendor/golang.org/x/tools/imports/zstdlib.go
new file mode 100644
index 0000000000000000000000000000000000000000..974c2d0401df1a5eaea844295469daa19a03458c
--- /dev/null
+++ b/vendor/golang.org/x/tools/imports/zstdlib.go
@@ -0,0 +1,9448 @@
+// Code generated by mkstdlib.go. DO NOT EDIT.
+
+package imports
+
+var stdlib = map[string]string{
+	"adler32.Checksum":                              "hash/adler32",
+	"adler32.New":                                   "hash/adler32",
+	"adler32.Size":                                  "hash/adler32",
+	"aes.BlockSize":                                 "crypto/aes",
+	"aes.KeySizeError":                              "crypto/aes",
+	"aes.NewCipher":                                 "crypto/aes",
+	"ascii85.CorruptInputError":                     "encoding/ascii85",
+	"ascii85.Decode":                                "encoding/ascii85",
+	"ascii85.Encode":                                "encoding/ascii85",
+	"ascii85.MaxEncodedLen":                         "encoding/ascii85",
+	"ascii85.NewDecoder":                            "encoding/ascii85",
+	"ascii85.NewEncoder":                            "encoding/ascii85",
+	"asn1.BitString":                                "encoding/asn1",
+	"asn1.ClassApplication":                         "encoding/asn1",
+	"asn1.ClassContextSpecific":                     "encoding/asn1",
+	"asn1.ClassPrivate":                             "encoding/asn1",
+	"asn1.ClassUniversal":                           "encoding/asn1",
+	"asn1.Enumerated":                               "encoding/asn1",
+	"asn1.Flag":                                     "encoding/asn1",
+	"asn1.Marshal":                                  "encoding/asn1",
+	"asn1.NullBytes":                                "encoding/asn1",
+	"asn1.NullRawValue":                             "encoding/asn1",
+	"asn1.ObjectIdentifier":                         "encoding/asn1",
+	"asn1.RawContent":                               "encoding/asn1",
+	"asn1.RawValue":                                 "encoding/asn1",
+	"asn1.StructuralError":                          "encoding/asn1",
+	"asn1.SyntaxError":                              "encoding/asn1",
+	"asn1.TagBitString":                             "encoding/asn1",
+	"asn1.TagBoolean":                               "encoding/asn1",
+	"asn1.TagEnum":                                  "encoding/asn1",
+	"asn1.TagGeneralString":                         "encoding/asn1",
+	"asn1.TagGeneralizedTime":                       "encoding/asn1",
+	"asn1.TagIA5String":                             "encoding/asn1",
+	"asn1.TagInteger":                               "encoding/asn1",
+	"asn1.TagNull":                                  "encoding/asn1",
+	"asn1.TagOID":                                   "encoding/asn1",
+	"asn1.TagOctetString":                           "encoding/asn1",
+	"asn1.TagPrintableString":                       "encoding/asn1",
+	"asn1.TagSequence":                              "encoding/asn1",
+	"asn1.TagSet":                                   "encoding/asn1",
+	"asn1.TagT61String":                             "encoding/asn1",
+	"asn1.TagUTCTime":                               "encoding/asn1",
+	"asn1.TagUTF8String":                            "encoding/asn1",
+	"asn1.Unmarshal":                                "encoding/asn1",
+	"asn1.UnmarshalWithParams":                      "encoding/asn1",
+	"ast.ArrayType":                                 "go/ast",
+	"ast.AssignStmt":                                "go/ast",
+	"ast.Bad":                                       "go/ast",
+	"ast.BadDecl":                                   "go/ast",
+	"ast.BadExpr":                                   "go/ast",
+	"ast.BadStmt":                                   "go/ast",
+	"ast.BasicLit":                                  "go/ast",
+	"ast.BinaryExpr":                                "go/ast",
+	"ast.BlockStmt":                                 "go/ast",
+	"ast.BranchStmt":                                "go/ast",
+	"ast.CallExpr":                                  "go/ast",
+	"ast.CaseClause":                                "go/ast",
+	"ast.ChanDir":                                   "go/ast",
+	"ast.ChanType":                                  "go/ast",
+	"ast.CommClause":                                "go/ast",
+	"ast.Comment":                                   "go/ast",
+	"ast.CommentGroup":                              "go/ast",
+	"ast.CommentMap":                                "go/ast",
+	"ast.CompositeLit":                              "go/ast",
+	"ast.Con":                                       "go/ast",
+	"ast.DeclStmt":                                  "go/ast",
+	"ast.DeferStmt":                                 "go/ast",
+	"ast.Ellipsis":                                  "go/ast",
+	"ast.EmptyStmt":                                 "go/ast",
+	"ast.ExprStmt":                                  "go/ast",
+	"ast.Field":                                     "go/ast",
+	"ast.FieldFilter":                               "go/ast",
+	"ast.FieldList":                                 "go/ast",
+	"ast.File":                                      "go/ast",
+	"ast.FileExports":                               "go/ast",
+	"ast.Filter":                                    "go/ast",
+	"ast.FilterDecl":                                "go/ast",
+	"ast.FilterFile":                                "go/ast",
+	"ast.FilterFuncDuplicates":                      "go/ast",
+	"ast.FilterImportDuplicates":                    "go/ast",
+	"ast.FilterPackage":                             "go/ast",
+	"ast.FilterUnassociatedComments":                "go/ast",
+	"ast.ForStmt":                                   "go/ast",
+	"ast.Fprint":                                    "go/ast",
+	"ast.Fun":                                       "go/ast",
+	"ast.FuncDecl":                                  "go/ast",
+	"ast.FuncLit":                                   "go/ast",
+	"ast.FuncType":                                  "go/ast",
+	"ast.GenDecl":                                   "go/ast",
+	"ast.GoStmt":                                    "go/ast",
+	"ast.Ident":                                     "go/ast",
+	"ast.IfStmt":                                    "go/ast",
+	"ast.ImportSpec":                                "go/ast",
+	"ast.Importer":                                  "go/ast",
+	"ast.IncDecStmt":                                "go/ast",
+	"ast.IndexExpr":                                 "go/ast",
+	"ast.Inspect":                                   "go/ast",
+	"ast.InterfaceType":                             "go/ast",
+	"ast.IsExported":                                "go/ast",
+	"ast.KeyValueExpr":                              "go/ast",
+	"ast.LabeledStmt":                               "go/ast",
+	"ast.Lbl":                                       "go/ast",
+	"ast.MapType":                                   "go/ast",
+	"ast.MergeMode":                                 "go/ast",
+	"ast.MergePackageFiles":                         "go/ast",
+	"ast.NewCommentMap":                             "go/ast",
+	"ast.NewIdent":                                  "go/ast",
+	"ast.NewObj":                                    "go/ast",
+	"ast.NewPackage":                                "go/ast",
+	"ast.NewScope":                                  "go/ast",
+	"ast.Node":                                      "go/ast",
+	"ast.NotNilFilter":                              "go/ast",
+	"ast.ObjKind":                                   "go/ast",
+	"ast.Object":                                    "go/ast",
+	"ast.Package":                                   "go/ast",
+	"ast.PackageExports":                            "go/ast",
+	"ast.ParenExpr":                                 "go/ast",
+	"ast.Pkg":                                       "go/ast",
+	"ast.Print":                                     "go/ast",
+	"ast.RECV":                                      "go/ast",
+	"ast.RangeStmt":                                 "go/ast",
+	"ast.ReturnStmt":                                "go/ast",
+	"ast.SEND":                                      "go/ast",
+	"ast.Scope":                                     "go/ast",
+	"ast.SelectStmt":                                "go/ast",
+	"ast.SelectorExpr":                              "go/ast",
+	"ast.SendStmt":                                  "go/ast",
+	"ast.SliceExpr":                                 "go/ast",
+	"ast.SortImports":                               "go/ast",
+	"ast.StarExpr":                                  "go/ast",
+	"ast.StructType":                                "go/ast",
+	"ast.SwitchStmt":                                "go/ast",
+	"ast.Typ":                                       "go/ast",
+	"ast.TypeAssertExpr":                            "go/ast",
+	"ast.TypeSpec":                                  "go/ast",
+	"ast.TypeSwitchStmt":                            "go/ast",
+	"ast.UnaryExpr":                                 "go/ast",
+	"ast.ValueSpec":                                 "go/ast",
+	"ast.Var":                                       "go/ast",
+	"ast.Visitor":                                   "go/ast",
+	"ast.Walk":                                      "go/ast",
+	"atomic.AddInt32":                               "sync/atomic",
+	"atomic.AddInt64":                               "sync/atomic",
+	"atomic.AddUint32":                              "sync/atomic",
+	"atomic.AddUint64":                              "sync/atomic",
+	"atomic.AddUintptr":                             "sync/atomic",
+	"atomic.CompareAndSwapInt32":                    "sync/atomic",
+	"atomic.CompareAndSwapInt64":                    "sync/atomic",
+	"atomic.CompareAndSwapPointer":                  "sync/atomic",
+	"atomic.CompareAndSwapUint32":                   "sync/atomic",
+	"atomic.CompareAndSwapUint64":                   "sync/atomic",
+	"atomic.CompareAndSwapUintptr":                  "sync/atomic",
+	"atomic.LoadInt32":                              "sync/atomic",
+	"atomic.LoadInt64":                              "sync/atomic",
+	"atomic.LoadPointer":                            "sync/atomic",
+	"atomic.LoadUint32":                             "sync/atomic",
+	"atomic.LoadUint64":                             "sync/atomic",
+	"atomic.LoadUintptr":                            "sync/atomic",
+	"atomic.StoreInt32":                             "sync/atomic",
+	"atomic.StoreInt64":                             "sync/atomic",
+	"atomic.StorePointer":                           "sync/atomic",
+	"atomic.StoreUint32":                            "sync/atomic",
+	"atomic.StoreUint64":                            "sync/atomic",
+	"atomic.StoreUintptr":                           "sync/atomic",
+	"atomic.SwapInt32":                              "sync/atomic",
+	"atomic.SwapInt64":                              "sync/atomic",
+	"atomic.SwapPointer":                            "sync/atomic",
+	"atomic.SwapUint32":                             "sync/atomic",
+	"atomic.SwapUint64":                             "sync/atomic",
+	"atomic.SwapUintptr":                            "sync/atomic",
+	"atomic.Value":                                  "sync/atomic",
+	"base32.CorruptInputError":                      "encoding/base32",
+	"base32.Encoding":                               "encoding/base32",
+	"base32.HexEncoding":                            "encoding/base32",
+	"base32.NewDecoder":                             "encoding/base32",
+	"base32.NewEncoder":                             "encoding/base32",
+	"base32.NewEncoding":                            "encoding/base32",
+	"base32.NoPadding":                              "encoding/base32",
+	"base32.StdEncoding":                            "encoding/base32",
+	"base32.StdPadding":                             "encoding/base32",
+	"base64.CorruptInputError":                      "encoding/base64",
+	"base64.Encoding":                               "encoding/base64",
+	"base64.NewDecoder":                             "encoding/base64",
+	"base64.NewEncoder":                             "encoding/base64",
+	"base64.NewEncoding":                            "encoding/base64",
+	"base64.NoPadding":                              "encoding/base64",
+	"base64.RawStdEncoding":                         "encoding/base64",
+	"base64.RawURLEncoding":                         "encoding/base64",
+	"base64.StdEncoding":                            "encoding/base64",
+	"base64.StdPadding":                             "encoding/base64",
+	"base64.URLEncoding":                            "encoding/base64",
+	"big.Above":                                     "math/big",
+	"big.Accuracy":                                  "math/big",
+	"big.AwayFromZero":                              "math/big",
+	"big.Below":                                     "math/big",
+	"big.ErrNaN":                                    "math/big",
+	"big.Exact":                                     "math/big",
+	"big.Float":                                     "math/big",
+	"big.Int":                                       "math/big",
+	"big.Jacobi":                                    "math/big",
+	"big.MaxBase":                                   "math/big",
+	"big.MaxExp":                                    "math/big",
+	"big.MaxPrec":                                   "math/big",
+	"big.MinExp":                                    "math/big",
+	"big.NewFloat":                                  "math/big",
+	"big.NewInt":                                    "math/big",
+	"big.NewRat":                                    "math/big",
+	"big.ParseFloat":                                "math/big",
+	"big.Rat":                                       "math/big",
+	"big.RoundingMode":                              "math/big",
+	"big.ToNearestAway":                             "math/big",
+	"big.ToNearestEven":                             "math/big",
+	"big.ToNegativeInf":                             "math/big",
+	"big.ToPositiveInf":                             "math/big",
+	"big.ToZero":                                    "math/big",
+	"big.Word":                                      "math/big",
+	"binary.BigEndian":                              "encoding/binary",
+	"binary.ByteOrder":                              "encoding/binary",
+	"binary.LittleEndian":                           "encoding/binary",
+	"binary.MaxVarintLen16":                         "encoding/binary",
+	"binary.MaxVarintLen32":                         "encoding/binary",
+	"binary.MaxVarintLen64":                         "encoding/binary",
+	"binary.PutUvarint":                             "encoding/binary",
+	"binary.PutVarint":                              "encoding/binary",
+	"binary.Read":                                   "encoding/binary",
+	"binary.ReadUvarint":                            "encoding/binary",
+	"binary.ReadVarint":                             "encoding/binary",
+	"binary.Size":                                   "encoding/binary",
+	"binary.Uvarint":                                "encoding/binary",
+	"binary.Varint":                                 "encoding/binary",
+	"binary.Write":                                  "encoding/binary",
+	"bits.LeadingZeros":                             "math/bits",
+	"bits.LeadingZeros16":                           "math/bits",
+	"bits.LeadingZeros32":                           "math/bits",
+	"bits.LeadingZeros64":                           "math/bits",
+	"bits.LeadingZeros8":                            "math/bits",
+	"bits.Len":                                      "math/bits",
+	"bits.Len16":                                    "math/bits",
+	"bits.Len32":                                    "math/bits",
+	"bits.Len64":                                    "math/bits",
+	"bits.Len8":                                     "math/bits",
+	"bits.OnesCount":                                "math/bits",
+	"bits.OnesCount16":                              "math/bits",
+	"bits.OnesCount32":                              "math/bits",
+	"bits.OnesCount64":                              "math/bits",
+	"bits.OnesCount8":                               "math/bits",
+	"bits.Reverse":                                  "math/bits",
+	"bits.Reverse16":                                "math/bits",
+	"bits.Reverse32":                                "math/bits",
+	"bits.Reverse64":                                "math/bits",
+	"bits.Reverse8":                                 "math/bits",
+	"bits.ReverseBytes":                             "math/bits",
+	"bits.ReverseBytes16":                           "math/bits",
+	"bits.ReverseBytes32":                           "math/bits",
+	"bits.ReverseBytes64":                           "math/bits",
+	"bits.RotateLeft":                               "math/bits",
+	"bits.RotateLeft16":                             "math/bits",
+	"bits.RotateLeft32":                             "math/bits",
+	"bits.RotateLeft64":                             "math/bits",
+	"bits.RotateLeft8":                              "math/bits",
+	"bits.TrailingZeros":                            "math/bits",
+	"bits.TrailingZeros16":                          "math/bits",
+	"bits.TrailingZeros32":                          "math/bits",
+	"bits.TrailingZeros64":                          "math/bits",
+	"bits.TrailingZeros8":                           "math/bits",
+	"bits.UintSize":                                 "math/bits",
+	"bufio.ErrAdvanceTooFar":                        "bufio",
+	"bufio.ErrBufferFull":                           "bufio",
+	"bufio.ErrFinalToken":                           "bufio",
+	"bufio.ErrInvalidUnreadByte":                    "bufio",
+	"bufio.ErrInvalidUnreadRune":                    "bufio",
+	"bufio.ErrNegativeAdvance":                      "bufio",
+	"bufio.ErrNegativeCount":                        "bufio",
+	"bufio.ErrTooLong":                              "bufio",
+	"bufio.MaxScanTokenSize":                        "bufio",
+	"bufio.NewReadWriter":                           "bufio",
+	"bufio.NewReader":                               "bufio",
+	"bufio.NewReaderSize":                           "bufio",
+	"bufio.NewScanner":                              "bufio",
+	"bufio.NewWriter":                               "bufio",
+	"bufio.NewWriterSize":                           "bufio",
+	"bufio.ReadWriter":                              "bufio",
+	"bufio.Reader":                                  "bufio",
+	"bufio.ScanBytes":                               "bufio",
+	"bufio.ScanLines":                               "bufio",
+	"bufio.ScanRunes":                               "bufio",
+	"bufio.ScanWords":                               "bufio",
+	"bufio.Scanner":                                 "bufio",
+	"bufio.SplitFunc":                               "bufio",
+	"bufio.Writer":                                  "bufio",
+	"build.AllowBinary":                             "go/build",
+	"build.ArchChar":                                "go/build",
+	"build.Context":                                 "go/build",
+	"build.Default":                                 "go/build",
+	"build.FindOnly":                                "go/build",
+	"build.IgnoreVendor":                            "go/build",
+	"build.Import":                                  "go/build",
+	"build.ImportComment":                           "go/build",
+	"build.ImportDir":                               "go/build",
+	"build.ImportMode":                              "go/build",
+	"build.IsLocalImport":                           "go/build",
+	"build.MultiplePackageError":                    "go/build",
+	"build.NoGoError":                               "go/build",
+	"build.Package":                                 "go/build",
+	"build.ToolDir":                                 "go/build",
+	"bytes.Buffer":                                  "bytes",
+	"bytes.Compare":                                 "bytes",
+	"bytes.Contains":                                "bytes",
+	"bytes.ContainsAny":                             "bytes",
+	"bytes.ContainsRune":                            "bytes",
+	"bytes.Count":                                   "bytes",
+	"bytes.Equal":                                   "bytes",
+	"bytes.EqualFold":                               "bytes",
+	"bytes.ErrTooLarge":                             "bytes",
+	"bytes.Fields":                                  "bytes",
+	"bytes.FieldsFunc":                              "bytes",
+	"bytes.HasPrefix":                               "bytes",
+	"bytes.HasSuffix":                               "bytes",
+	"bytes.Index":                                   "bytes",
+	"bytes.IndexAny":                                "bytes",
+	"bytes.IndexByte":                               "bytes",
+	"bytes.IndexFunc":                               "bytes",
+	"bytes.IndexRune":                               "bytes",
+	"bytes.Join":                                    "bytes",
+	"bytes.LastIndex":                               "bytes",
+	"bytes.LastIndexAny":                            "bytes",
+	"bytes.LastIndexByte":                           "bytes",
+	"bytes.LastIndexFunc":                           "bytes",
+	"bytes.Map":                                     "bytes",
+	"bytes.MinRead":                                 "bytes",
+	"bytes.NewBuffer":                               "bytes",
+	"bytes.NewBufferString":                         "bytes",
+	"bytes.NewReader":                               "bytes",
+	"bytes.Reader":                                  "bytes",
+	"bytes.Repeat":                                  "bytes",
+	"bytes.Replace":                                 "bytes",
+	"bytes.Runes":                                   "bytes",
+	"bytes.Split":                                   "bytes",
+	"bytes.SplitAfter":                              "bytes",
+	"bytes.SplitAfterN":                             "bytes",
+	"bytes.SplitN":                                  "bytes",
+	"bytes.Title":                                   "bytes",
+	"bytes.ToLower":                                 "bytes",
+	"bytes.ToLowerSpecial":                          "bytes",
+	"bytes.ToTitle":                                 "bytes",
+	"bytes.ToTitleSpecial":                          "bytes",
+	"bytes.ToUpper":                                 "bytes",
+	"bytes.ToUpperSpecial":                          "bytes",
+	"bytes.Trim":                                    "bytes",
+	"bytes.TrimFunc":                                "bytes",
+	"bytes.TrimLeft":                                "bytes",
+	"bytes.TrimLeftFunc":                            "bytes",
+	"bytes.TrimPrefix":                              "bytes",
+	"bytes.TrimRight":                               "bytes",
+	"bytes.TrimRightFunc":                           "bytes",
+	"bytes.TrimSpace":                               "bytes",
+	"bytes.TrimSuffix":                              "bytes",
+	"bzip2.NewReader":                               "compress/bzip2",
+	"bzip2.StructuralError":                         "compress/bzip2",
+	"cgi.Handler":                                   "net/http/cgi",
+	"cgi.Request":                                   "net/http/cgi",
+	"cgi.RequestFromMap":                            "net/http/cgi",
+	"cgi.Serve":                                     "net/http/cgi",
+	"cipher.AEAD":                                   "crypto/cipher",
+	"cipher.Block":                                  "crypto/cipher",
+	"cipher.BlockMode":                              "crypto/cipher",
+	"cipher.NewCBCDecrypter":                        "crypto/cipher",
+	"cipher.NewCBCEncrypter":                        "crypto/cipher",
+	"cipher.NewCFBDecrypter":                        "crypto/cipher",
+	"cipher.NewCFBEncrypter":                        "crypto/cipher",
+	"cipher.NewCTR":                                 "crypto/cipher",
+	"cipher.NewGCM":                                 "crypto/cipher",
+	"cipher.NewGCMWithNonceSize":                    "crypto/cipher",
+	"cipher.NewOFB":                                 "crypto/cipher",
+	"cipher.Stream":                                 "crypto/cipher",
+	"cipher.StreamReader":                           "crypto/cipher",
+	"cipher.StreamWriter":                           "crypto/cipher",
+	"cmplx.Abs":                                     "math/cmplx",
+	"cmplx.Acos":                                    "math/cmplx",
+	"cmplx.Acosh":                                   "math/cmplx",
+	"cmplx.Asin":                                    "math/cmplx",
+	"cmplx.Asinh":                                   "math/cmplx",
+	"cmplx.Atan":                                    "math/cmplx",
+	"cmplx.Atanh":                                   "math/cmplx",
+	"cmplx.Conj":                                    "math/cmplx",
+	"cmplx.Cos":                                     "math/cmplx",
+	"cmplx.Cosh":                                    "math/cmplx",
+	"cmplx.Cot":                                     "math/cmplx",
+	"cmplx.Exp":                                     "math/cmplx",
+	"cmplx.Inf":                                     "math/cmplx",
+	"cmplx.IsInf":                                   "math/cmplx",
+	"cmplx.IsNaN":                                   "math/cmplx",
+	"cmplx.Log":                                     "math/cmplx",
+	"cmplx.Log10":                                   "math/cmplx",
+	"cmplx.NaN":                                     "math/cmplx",
+	"cmplx.Phase":                                   "math/cmplx",
+	"cmplx.Polar":                                   "math/cmplx",
+	"cmplx.Pow":                                     "math/cmplx",
+	"cmplx.Rect":                                    "math/cmplx",
+	"cmplx.Sin":                                     "math/cmplx",
+	"cmplx.Sinh":                                    "math/cmplx",
+	"cmplx.Sqrt":                                    "math/cmplx",
+	"cmplx.Tan":                                     "math/cmplx",
+	"cmplx.Tanh":                                    "math/cmplx",
+	"color.Alpha":                                   "image/color",
+	"color.Alpha16":                                 "image/color",
+	"color.Alpha16Model":                            "image/color",
+	"color.AlphaModel":                              "image/color",
+	"color.Black":                                   "image/color",
+	"color.CMYK":                                    "image/color",
+	"color.CMYKModel":                               "image/color",
+	"color.CMYKToRGB":                               "image/color",
+	"color.Color":                                   "image/color",
+	"color.Gray":                                    "image/color",
+	"color.Gray16":                                  "image/color",
+	"color.Gray16Model":                             "image/color",
+	"color.GrayModel":                               "image/color",
+	"color.Model":                                   "image/color",
+	"color.ModelFunc":                               "image/color",
+	"color.NRGBA":                                   "image/color",
+	"color.NRGBA64":                                 "image/color",
+	"color.NRGBA64Model":                            "image/color",
+	"color.NRGBAModel":                              "image/color",
+	"color.NYCbCrA":                                 "image/color",
+	"color.NYCbCrAModel":                            "image/color",
+	"color.Opaque":                                  "image/color",
+	"color.Palette":                                 "image/color",
+	"color.RGBA":                                    "image/color",
+	"color.RGBA64":                                  "image/color",
+	"color.RGBA64Model":                             "image/color",
+	"color.RGBAModel":                               "image/color",
+	"color.RGBToCMYK":                               "image/color",
+	"color.RGBToYCbCr":                              "image/color",
+	"color.Transparent":                             "image/color",
+	"color.White":                                   "image/color",
+	"color.YCbCr":                                   "image/color",
+	"color.YCbCrModel":                              "image/color",
+	"color.YCbCrToRGB":                              "image/color",
+	"constant.BinaryOp":                             "go/constant",
+	"constant.BitLen":                               "go/constant",
+	"constant.Bool":                                 "go/constant",
+	"constant.BoolVal":                              "go/constant",
+	"constant.Bytes":                                "go/constant",
+	"constant.Compare":                              "go/constant",
+	"constant.Complex":                              "go/constant",
+	"constant.Denom":                                "go/constant",
+	"constant.Float":                                "go/constant",
+	"constant.Float32Val":                           "go/constant",
+	"constant.Float64Val":                           "go/constant",
+	"constant.Imag":                                 "go/constant",
+	"constant.Int":                                  "go/constant",
+	"constant.Int64Val":                             "go/constant",
+	"constant.Kind":                                 "go/constant",
+	"constant.MakeBool":                             "go/constant",
+	"constant.MakeFloat64":                          "go/constant",
+	"constant.MakeFromBytes":                        "go/constant",
+	"constant.MakeFromLiteral":                      "go/constant",
+	"constant.MakeImag":                             "go/constant",
+	"constant.MakeInt64":                            "go/constant",
+	"constant.MakeString":                           "go/constant",
+	"constant.MakeUint64":                           "go/constant",
+	"constant.MakeUnknown":                          "go/constant",
+	"constant.Num":                                  "go/constant",
+	"constant.Real":                                 "go/constant",
+	"constant.Shift":                                "go/constant",
+	"constant.Sign":                                 "go/constant",
+	"constant.String":                               "go/constant",
+	"constant.StringVal":                            "go/constant",
+	"constant.ToComplex":                            "go/constant",
+	"constant.ToFloat":                              "go/constant",
+	"constant.ToInt":                                "go/constant",
+	"constant.Uint64Val":                            "go/constant",
+	"constant.UnaryOp":                              "go/constant",
+	"constant.Unknown":                              "go/constant",
+	"context.Background":                            "context",
+	"context.CancelFunc":                            "context",
+	"context.Canceled":                              "context",
+	"context.Context":                               "context",
+	"context.DeadlineExceeded":                      "context",
+	"context.TODO":                                  "context",
+	"context.WithCancel":                            "context",
+	"context.WithDeadline":                          "context",
+	"context.WithTimeout":                           "context",
+	"context.WithValue":                             "context",
+	"cookiejar.Jar":                                 "net/http/cookiejar",
+	"cookiejar.New":                                 "net/http/cookiejar",
+	"cookiejar.Options":                             "net/http/cookiejar",
+	"cookiejar.PublicSuffixList":                    "net/http/cookiejar",
+	"crc32.Castagnoli":                              "hash/crc32",
+	"crc32.Checksum":                                "hash/crc32",
+	"crc32.ChecksumIEEE":                            "hash/crc32",
+	"crc32.IEEE":                                    "hash/crc32",
+	"crc32.IEEETable":                               "hash/crc32",
+	"crc32.Koopman":                                 "hash/crc32",
+	"crc32.MakeTable":                               "hash/crc32",
+	"crc32.New":                                     "hash/crc32",
+	"crc32.NewIEEE":                                 "hash/crc32",
+	"crc32.Size":                                    "hash/crc32",
+	"crc32.Table":                                   "hash/crc32",
+	"crc32.Update":                                  "hash/crc32",
+	"crc64.Checksum":                                "hash/crc64",
+	"crc64.ECMA":                                    "hash/crc64",
+	"crc64.ISO":                                     "hash/crc64",
+	"crc64.MakeTable":                               "hash/crc64",
+	"crc64.New":                                     "hash/crc64",
+	"crc64.Size":                                    "hash/crc64",
+	"crc64.Table":                                   "hash/crc64",
+	"crc64.Update":                                  "hash/crc64",
+	"crypto.BLAKE2b_256":                            "crypto",
+	"crypto.BLAKE2b_384":                            "crypto",
+	"crypto.BLAKE2b_512":                            "crypto",
+	"crypto.BLAKE2s_256":                            "crypto",
+	"crypto.Decrypter":                              "crypto",
+	"crypto.DecrypterOpts":                          "crypto",
+	"crypto.Hash":                                   "crypto",
+	"crypto.MD4":                                    "crypto",
+	"crypto.MD5":                                    "crypto",
+	"crypto.MD5SHA1":                                "crypto",
+	"crypto.PrivateKey":                             "crypto",
+	"crypto.PublicKey":                              "crypto",
+	"crypto.RIPEMD160":                              "crypto",
+	"crypto.RegisterHash":                           "crypto",
+	"crypto.SHA1":                                   "crypto",
+	"crypto.SHA224":                                 "crypto",
+	"crypto.SHA256":                                 "crypto",
+	"crypto.SHA384":                                 "crypto",
+	"crypto.SHA3_224":                               "crypto",
+	"crypto.SHA3_256":                               "crypto",
+	"crypto.SHA3_384":                               "crypto",
+	"crypto.SHA3_512":                               "crypto",
+	"crypto.SHA512":                                 "crypto",
+	"crypto.SHA512_224":                             "crypto",
+	"crypto.SHA512_256":                             "crypto",
+	"crypto.Signer":                                 "crypto",
+	"crypto.SignerOpts":                             "crypto",
+	"csv.ErrBareQuote":                              "encoding/csv",
+	"csv.ErrFieldCount":                             "encoding/csv",
+	"csv.ErrQuote":                                  "encoding/csv",
+	"csv.ErrTrailingComma":                          "encoding/csv",
+	"csv.NewReader":                                 "encoding/csv",
+	"csv.NewWriter":                                 "encoding/csv",
+	"csv.ParseError":                                "encoding/csv",
+	"csv.Reader":                                    "encoding/csv",
+	"csv.Writer":                                    "encoding/csv",
+	"debug.FreeOSMemory":                            "runtime/debug",
+	"debug.GCStats":                                 "runtime/debug",
+	"debug.PrintStack":                              "runtime/debug",
+	"debug.ReadGCStats":                             "runtime/debug",
+	"debug.SetGCPercent":                            "runtime/debug",
+	"debug.SetMaxStack":                             "runtime/debug",
+	"debug.SetMaxThreads":                           "runtime/debug",
+	"debug.SetPanicOnFault":                         "runtime/debug",
+	"debug.SetTraceback":                            "runtime/debug",
+	"debug.Stack":                                   "runtime/debug",
+	"debug.WriteHeapDump":                           "runtime/debug",
+	"des.BlockSize":                                 "crypto/des",
+	"des.KeySizeError":                              "crypto/des",
+	"des.NewCipher":                                 "crypto/des",
+	"des.NewTripleDESCipher":                        "crypto/des",
+	"doc.AllDecls":                                  "go/doc",
+	"doc.AllMethods":                                "go/doc",
+	"doc.Example":                                   "go/doc",
+	"doc.Examples":                                  "go/doc",
+	"doc.Filter":                                    "go/doc",
+	"doc.Func":                                      "go/doc",
+	"doc.IllegalPrefixes":                           "go/doc",
+	"doc.IsPredeclared":                             "go/doc",
+	"doc.Mode":                                      "go/doc",
+	"doc.New":                                       "go/doc",
+	"doc.Note":                                      "go/doc",
+	"doc.Package":                                   "go/doc",
+	"doc.Synopsis":                                  "go/doc",
+	"doc.ToHTML":                                    "go/doc",
+	"doc.ToText":                                    "go/doc",
+	"doc.Type":                                      "go/doc",
+	"doc.Value":                                     "go/doc",
+	"draw.Draw":                                     "image/draw",
+	"draw.DrawMask":                                 "image/draw",
+	"draw.Drawer":                                   "image/draw",
+	"draw.FloydSteinberg":                           "image/draw",
+	"draw.Image":                                    "image/draw",
+	"draw.Op":                                       "image/draw",
+	"draw.Over":                                     "image/draw",
+	"draw.Quantizer":                                "image/draw",
+	"draw.Src":                                      "image/draw",
+	"driver.Bool":                                   "database/sql/driver",
+	"driver.ColumnConverter":                        "database/sql/driver",
+	"driver.Conn":                                   "database/sql/driver",
+	"driver.ConnBeginTx":                            "database/sql/driver",
+	"driver.ConnPrepareContext":                     "database/sql/driver",
+	"driver.DefaultParameterConverter":              "database/sql/driver",
+	"driver.Driver":                                 "database/sql/driver",
+	"driver.ErrBadConn":                             "database/sql/driver",
+	"driver.ErrRemoveArgument":                      "database/sql/driver",
+	"driver.ErrSkip":                                "database/sql/driver",
+	"driver.Execer":                                 "database/sql/driver",
+	"driver.ExecerContext":                          "database/sql/driver",
+	"driver.Int32":                                  "database/sql/driver",
+	"driver.IsScanValue":                            "database/sql/driver",
+	"driver.IsValue":                                "database/sql/driver",
+	"driver.IsolationLevel":                         "database/sql/driver",
+	"driver.NamedValue":                             "database/sql/driver",
+	"driver.NamedValueChecker":                      "database/sql/driver",
+	"driver.NotNull":                                "database/sql/driver",
+	"driver.Null":                                   "database/sql/driver",
+	"driver.Pinger":                                 "database/sql/driver",
+	"driver.Queryer":                                "database/sql/driver",
+	"driver.QueryerContext":                         "database/sql/driver",
+	"driver.Result":                                 "database/sql/driver",
+	"driver.ResultNoRows":                           "database/sql/driver",
+	"driver.Rows":                                   "database/sql/driver",
+	"driver.RowsAffected":                           "database/sql/driver",
+	"driver.RowsColumnTypeDatabaseTypeName":         "database/sql/driver",
+	"driver.RowsColumnTypeLength":                   "database/sql/driver",
+	"driver.RowsColumnTypeNullable":                 "database/sql/driver",
+	"driver.RowsColumnTypePrecisionScale":           "database/sql/driver",
+	"driver.RowsColumnTypeScanType":                 "database/sql/driver",
+	"driver.RowsNextResultSet":                      "database/sql/driver",
+	"driver.Stmt":                                   "database/sql/driver",
+	"driver.StmtExecContext":                        "database/sql/driver",
+	"driver.StmtQueryContext":                       "database/sql/driver",
+	"driver.String":                                 "database/sql/driver",
+	"driver.Tx":                                     "database/sql/driver",
+	"driver.TxOptions":                              "database/sql/driver",
+	"driver.Value":                                  "database/sql/driver",
+	"driver.ValueConverter":                         "database/sql/driver",
+	"driver.Valuer":                                 "database/sql/driver",
+	"dsa.ErrInvalidPublicKey":                       "crypto/dsa",
+	"dsa.GenerateKey":                               "crypto/dsa",
+	"dsa.GenerateParameters":                        "crypto/dsa",
+	"dsa.L1024N160":                                 "crypto/dsa",
+	"dsa.L2048N224":                                 "crypto/dsa",
+	"dsa.L2048N256":                                 "crypto/dsa",
+	"dsa.L3072N256":                                 "crypto/dsa",
+	"dsa.ParameterSizes":                            "crypto/dsa",
+	"dsa.Parameters":                                "crypto/dsa",
+	"dsa.PrivateKey":                                "crypto/dsa",
+	"dsa.PublicKey":                                 "crypto/dsa",
+	"dsa.Sign":                                      "crypto/dsa",
+	"dsa.Verify":                                    "crypto/dsa",
+	"dwarf.AddrType":                                "debug/dwarf",
+	"dwarf.ArrayType":                               "debug/dwarf",
+	"dwarf.Attr":                                    "debug/dwarf",
+	"dwarf.AttrAbstractOrigin":                      "debug/dwarf",
+	"dwarf.AttrAccessibility":                       "debug/dwarf",
+	"dwarf.AttrAddrClass":                           "debug/dwarf",
+	"dwarf.AttrAllocated":                           "debug/dwarf",
+	"dwarf.AttrArtificial":                          "debug/dwarf",
+	"dwarf.AttrAssociated":                          "debug/dwarf",
+	"dwarf.AttrBaseTypes":                           "debug/dwarf",
+	"dwarf.AttrBitOffset":                           "debug/dwarf",
+	"dwarf.AttrBitSize":                             "debug/dwarf",
+	"dwarf.AttrByteSize":                            "debug/dwarf",
+	"dwarf.AttrCallColumn":                          "debug/dwarf",
+	"dwarf.AttrCallFile":                            "debug/dwarf",
+	"dwarf.AttrCallLine":                            "debug/dwarf",
+	"dwarf.AttrCalling":                             "debug/dwarf",
+	"dwarf.AttrCommonRef":                           "debug/dwarf",
+	"dwarf.AttrCompDir":                             "debug/dwarf",
+	"dwarf.AttrConstValue":                          "debug/dwarf",
+	"dwarf.AttrContainingType":                      "debug/dwarf",
+	"dwarf.AttrCount":                               "debug/dwarf",
+	"dwarf.AttrDataLocation":                        "debug/dwarf",
+	"dwarf.AttrDataMemberLoc":                       "debug/dwarf",
+	"dwarf.AttrDeclColumn":                          "debug/dwarf",
+	"dwarf.AttrDeclFile":                            "debug/dwarf",
+	"dwarf.AttrDeclLine":                            "debug/dwarf",
+	"dwarf.AttrDeclaration":                         "debug/dwarf",
+	"dwarf.AttrDefaultValue":                        "debug/dwarf",
+	"dwarf.AttrDescription":                         "debug/dwarf",
+	"dwarf.AttrDiscr":                               "debug/dwarf",
+	"dwarf.AttrDiscrList":                           "debug/dwarf",
+	"dwarf.AttrDiscrValue":                          "debug/dwarf",
+	"dwarf.AttrEncoding":                            "debug/dwarf",
+	"dwarf.AttrEntrypc":                             "debug/dwarf",
+	"dwarf.AttrExtension":                           "debug/dwarf",
+	"dwarf.AttrExternal":                            "debug/dwarf",
+	"dwarf.AttrFrameBase":                           "debug/dwarf",
+	"dwarf.AttrFriend":                              "debug/dwarf",
+	"dwarf.AttrHighpc":                              "debug/dwarf",
+	"dwarf.AttrIdentifierCase":                      "debug/dwarf",
+	"dwarf.AttrImport":                              "debug/dwarf",
+	"dwarf.AttrInline":                              "debug/dwarf",
+	"dwarf.AttrIsOptional":                          "debug/dwarf",
+	"dwarf.AttrLanguage":                            "debug/dwarf",
+	"dwarf.AttrLocation":                            "debug/dwarf",
+	"dwarf.AttrLowerBound":                          "debug/dwarf",
+	"dwarf.AttrLowpc":                               "debug/dwarf",
+	"dwarf.AttrMacroInfo":                           "debug/dwarf",
+	"dwarf.AttrName":                                "debug/dwarf",
+	"dwarf.AttrNamelistItem":                        "debug/dwarf",
+	"dwarf.AttrOrdering":                            "debug/dwarf",
+	"dwarf.AttrPriority":                            "debug/dwarf",
+	"dwarf.AttrProducer":                            "debug/dwarf",
+	"dwarf.AttrPrototyped":                          "debug/dwarf",
+	"dwarf.AttrRanges":                              "debug/dwarf",
+	"dwarf.AttrReturnAddr":                          "debug/dwarf",
+	"dwarf.AttrSegment":                             "debug/dwarf",
+	"dwarf.AttrSibling":                             "debug/dwarf",
+	"dwarf.AttrSpecification":                       "debug/dwarf",
+	"dwarf.AttrStartScope":                          "debug/dwarf",
+	"dwarf.AttrStaticLink":                          "debug/dwarf",
+	"dwarf.AttrStmtList":                            "debug/dwarf",
+	"dwarf.AttrStride":                              "debug/dwarf",
+	"dwarf.AttrStrideSize":                          "debug/dwarf",
+	"dwarf.AttrStringLength":                        "debug/dwarf",
+	"dwarf.AttrTrampoline":                          "debug/dwarf",
+	"dwarf.AttrType":                                "debug/dwarf",
+	"dwarf.AttrUpperBound":                          "debug/dwarf",
+	"dwarf.AttrUseLocation":                         "debug/dwarf",
+	"dwarf.AttrUseUTF8":                             "debug/dwarf",
+	"dwarf.AttrVarParam":                            "debug/dwarf",
+	"dwarf.AttrVirtuality":                          "debug/dwarf",
+	"dwarf.AttrVisibility":                          "debug/dwarf",
+	"dwarf.AttrVtableElemLoc":                       "debug/dwarf",
+	"dwarf.BasicType":                               "debug/dwarf",
+	"dwarf.BoolType":                                "debug/dwarf",
+	"dwarf.CharType":                                "debug/dwarf",
+	"dwarf.Class":                                   "debug/dwarf",
+	"dwarf.ClassAddress":                            "debug/dwarf",
+	"dwarf.ClassBlock":                              "debug/dwarf",
+	"dwarf.ClassConstant":                           "debug/dwarf",
+	"dwarf.ClassExprLoc":                            "debug/dwarf",
+	"dwarf.ClassFlag":                               "debug/dwarf",
+	"dwarf.ClassLinePtr":                            "debug/dwarf",
+	"dwarf.ClassLocListPtr":                         "debug/dwarf",
+	"dwarf.ClassMacPtr":                             "debug/dwarf",
+	"dwarf.ClassRangeListPtr":                       "debug/dwarf",
+	"dwarf.ClassReference":                          "debug/dwarf",
+	"dwarf.ClassReferenceAlt":                       "debug/dwarf",
+	"dwarf.ClassReferenceSig":                       "debug/dwarf",
+	"dwarf.ClassString":                             "debug/dwarf",
+	"dwarf.ClassStringAlt":                          "debug/dwarf",
+	"dwarf.ClassUnknown":                            "debug/dwarf",
+	"dwarf.CommonType":                              "debug/dwarf",
+	"dwarf.ComplexType":                             "debug/dwarf",
+	"dwarf.Data":                                    "debug/dwarf",
+	"dwarf.DecodeError":                             "debug/dwarf",
+	"dwarf.DotDotDotType":                           "debug/dwarf",
+	"dwarf.Entry":                                   "debug/dwarf",
+	"dwarf.EnumType":                                "debug/dwarf",
+	"dwarf.EnumValue":                               "debug/dwarf",
+	"dwarf.ErrUnknownPC":                            "debug/dwarf",
+	"dwarf.Field":                                   "debug/dwarf",
+	"dwarf.FloatType":                               "debug/dwarf",
+	"dwarf.FuncType":                                "debug/dwarf",
+	"dwarf.IntType":                                 "debug/dwarf",
+	"dwarf.LineEntry":                               "debug/dwarf",
+	"dwarf.LineFile":                                "debug/dwarf",
+	"dwarf.LineReader":                              "debug/dwarf",
+	"dwarf.LineReaderPos":                           "debug/dwarf",
+	"dwarf.New":                                     "debug/dwarf",
+	"dwarf.Offset":                                  "debug/dwarf",
+	"dwarf.PtrType":                                 "debug/dwarf",
+	"dwarf.QualType":                                "debug/dwarf",
+	"dwarf.Reader":                                  "debug/dwarf",
+	"dwarf.StructField":                             "debug/dwarf",
+	"dwarf.StructType":                              "debug/dwarf",
+	"dwarf.Tag":                                     "debug/dwarf",
+	"dwarf.TagAccessDeclaration":                    "debug/dwarf",
+	"dwarf.TagArrayType":                            "debug/dwarf",
+	"dwarf.TagBaseType":                             "debug/dwarf",
+	"dwarf.TagCatchDwarfBlock":                      "debug/dwarf",
+	"dwarf.TagClassType":                            "debug/dwarf",
+	"dwarf.TagCommonDwarfBlock":                     "debug/dwarf",
+	"dwarf.TagCommonInclusion":                      "debug/dwarf",
+	"dwarf.TagCompileUnit":                          "debug/dwarf",
+	"dwarf.TagCondition":                            "debug/dwarf",
+	"dwarf.TagConstType":                            "debug/dwarf",
+	"dwarf.TagConstant":                             "debug/dwarf",
+	"dwarf.TagDwarfProcedure":                       "debug/dwarf",
+	"dwarf.TagEntryPoint":                           "debug/dwarf",
+	"dwarf.TagEnumerationType":                      "debug/dwarf",
+	"dwarf.TagEnumerator":                           "debug/dwarf",
+	"dwarf.TagFileType":                             "debug/dwarf",
+	"dwarf.TagFormalParameter":                      "debug/dwarf",
+	"dwarf.TagFriend":                               "debug/dwarf",
+	"dwarf.TagImportedDeclaration":                  "debug/dwarf",
+	"dwarf.TagImportedModule":                       "debug/dwarf",
+	"dwarf.TagImportedUnit":                         "debug/dwarf",
+	"dwarf.TagInheritance":                          "debug/dwarf",
+	"dwarf.TagInlinedSubroutine":                    "debug/dwarf",
+	"dwarf.TagInterfaceType":                        "debug/dwarf",
+	"dwarf.TagLabel":                                "debug/dwarf",
+	"dwarf.TagLexDwarfBlock":                        "debug/dwarf",
+	"dwarf.TagMember":                               "debug/dwarf",
+	"dwarf.TagModule":                               "debug/dwarf",
+	"dwarf.TagMutableType":                          "debug/dwarf",
+	"dwarf.TagNamelist":                             "debug/dwarf",
+	"dwarf.TagNamelistItem":                         "debug/dwarf",
+	"dwarf.TagNamespace":                            "debug/dwarf",
+	"dwarf.TagPackedType":                           "debug/dwarf",
+	"dwarf.TagPartialUnit":                          "debug/dwarf",
+	"dwarf.TagPointerType":                          "debug/dwarf",
+	"dwarf.TagPtrToMemberType":                      "debug/dwarf",
+	"dwarf.TagReferenceType":                        "debug/dwarf",
+	"dwarf.TagRestrictType":                         "debug/dwarf",
+	"dwarf.TagRvalueReferenceType":                  "debug/dwarf",
+	"dwarf.TagSetType":                              "debug/dwarf",
+	"dwarf.TagSharedType":                           "debug/dwarf",
+	"dwarf.TagStringType":                           "debug/dwarf",
+	"dwarf.TagStructType":                           "debug/dwarf",
+	"dwarf.TagSubprogram":                           "debug/dwarf",
+	"dwarf.TagSubrangeType":                         "debug/dwarf",
+	"dwarf.TagSubroutineType":                       "debug/dwarf",
+	"dwarf.TagTemplateAlias":                        "debug/dwarf",
+	"dwarf.TagTemplateTypeParameter":                "debug/dwarf",
+	"dwarf.TagTemplateValueParameter":               "debug/dwarf",
+	"dwarf.TagThrownType":                           "debug/dwarf",
+	"dwarf.TagTryDwarfBlock":                        "debug/dwarf",
+	"dwarf.TagTypeUnit":                             "debug/dwarf",
+	"dwarf.TagTypedef":                              "debug/dwarf",
+	"dwarf.TagUnionType":                            "debug/dwarf",
+	"dwarf.TagUnspecifiedParameters":                "debug/dwarf",
+	"dwarf.TagUnspecifiedType":                      "debug/dwarf",
+	"dwarf.TagVariable":                             "debug/dwarf",
+	"dwarf.TagVariant":                              "debug/dwarf",
+	"dwarf.TagVariantPart":                          "debug/dwarf",
+	"dwarf.TagVolatileType":                         "debug/dwarf",
+	"dwarf.TagWithStmt":                             "debug/dwarf",
+	"dwarf.Type":                                    "debug/dwarf",
+	"dwarf.TypedefType":                             "debug/dwarf",
+	"dwarf.UcharType":                               "debug/dwarf",
+	"dwarf.UintType":                                "debug/dwarf",
+	"dwarf.UnspecifiedType":                         "debug/dwarf",
+	"dwarf.VoidType":                                "debug/dwarf",
+	"ecdsa.GenerateKey":                             "crypto/ecdsa",
+	"ecdsa.PrivateKey":                              "crypto/ecdsa",
+	"ecdsa.PublicKey":                               "crypto/ecdsa",
+	"ecdsa.Sign":                                    "crypto/ecdsa",
+	"ecdsa.Verify":                                  "crypto/ecdsa",
+	"elf.ARM_MAGIC_TRAMP_NUMBER":                    "debug/elf",
+	"elf.COMPRESS_HIOS":                             "debug/elf",
+	"elf.COMPRESS_HIPROC":                           "debug/elf",
+	"elf.COMPRESS_LOOS":                             "debug/elf",
+	"elf.COMPRESS_LOPROC":                           "debug/elf",
+	"elf.COMPRESS_ZLIB":                             "debug/elf",
+	"elf.Chdr32":                                    "debug/elf",
+	"elf.Chdr64":                                    "debug/elf",
+	"elf.Class":                                     "debug/elf",
+	"elf.CompressionType":                           "debug/elf",
+	"elf.DF_BIND_NOW":                               "debug/elf",
+	"elf.DF_ORIGIN":                                 "debug/elf",
+	"elf.DF_STATIC_TLS":                             "debug/elf",
+	"elf.DF_SYMBOLIC":                               "debug/elf",
+	"elf.DF_TEXTREL":                                "debug/elf",
+	"elf.DT_BIND_NOW":                               "debug/elf",
+	"elf.DT_DEBUG":                                  "debug/elf",
+	"elf.DT_ENCODING":                               "debug/elf",
+	"elf.DT_FINI":                                   "debug/elf",
+	"elf.DT_FINI_ARRAY":                             "debug/elf",
+	"elf.DT_FINI_ARRAYSZ":                           "debug/elf",
+	"elf.DT_FLAGS":                                  "debug/elf",
+	"elf.DT_HASH":                                   "debug/elf",
+	"elf.DT_HIOS":                                   "debug/elf",
+	"elf.DT_HIPROC":                                 "debug/elf",
+	"elf.DT_INIT":                                   "debug/elf",
+	"elf.DT_INIT_ARRAY":                             "debug/elf",
+	"elf.DT_INIT_ARRAYSZ":                           "debug/elf",
+	"elf.DT_JMPREL":                                 "debug/elf",
+	"elf.DT_LOOS":                                   "debug/elf",
+	"elf.DT_LOPROC":                                 "debug/elf",
+	"elf.DT_NEEDED":                                 "debug/elf",
+	"elf.DT_NULL":                                   "debug/elf",
+	"elf.DT_PLTGOT":                                 "debug/elf",
+	"elf.DT_PLTREL":                                 "debug/elf",
+	"elf.DT_PLTRELSZ":                               "debug/elf",
+	"elf.DT_PREINIT_ARRAY":                          "debug/elf",
+	"elf.DT_PREINIT_ARRAYSZ":                        "debug/elf",
+	"elf.DT_REL":                                    "debug/elf",
+	"elf.DT_RELA":                                   "debug/elf",
+	"elf.DT_RELAENT":                                "debug/elf",
+	"elf.DT_RELASZ":                                 "debug/elf",
+	"elf.DT_RELENT":                                 "debug/elf",
+	"elf.DT_RELSZ":                                  "debug/elf",
+	"elf.DT_RPATH":                                  "debug/elf",
+	"elf.DT_RUNPATH":                                "debug/elf",
+	"elf.DT_SONAME":                                 "debug/elf",
+	"elf.DT_STRSZ":                                  "debug/elf",
+	"elf.DT_STRTAB":                                 "debug/elf",
+	"elf.DT_SYMBOLIC":                               "debug/elf",
+	"elf.DT_SYMENT":                                 "debug/elf",
+	"elf.DT_SYMTAB":                                 "debug/elf",
+	"elf.DT_TEXTREL":                                "debug/elf",
+	"elf.DT_VERNEED":                                "debug/elf",
+	"elf.DT_VERNEEDNUM":                             "debug/elf",
+	"elf.DT_VERSYM":                                 "debug/elf",
+	"elf.Data":                                      "debug/elf",
+	"elf.Dyn32":                                     "debug/elf",
+	"elf.Dyn64":                                     "debug/elf",
+	"elf.DynFlag":                                   "debug/elf",
+	"elf.DynTag":                                    "debug/elf",
+	"elf.EI_ABIVERSION":                             "debug/elf",
+	"elf.EI_CLASS":                                  "debug/elf",
+	"elf.EI_DATA":                                   "debug/elf",
+	"elf.EI_NIDENT":                                 "debug/elf",
+	"elf.EI_OSABI":                                  "debug/elf",
+	"elf.EI_PAD":                                    "debug/elf",
+	"elf.EI_VERSION":                                "debug/elf",
+	"elf.ELFCLASS32":                                "debug/elf",
+	"elf.ELFCLASS64":                                "debug/elf",
+	"elf.ELFCLASSNONE":                              "debug/elf",
+	"elf.ELFDATA2LSB":                               "debug/elf",
+	"elf.ELFDATA2MSB":                               "debug/elf",
+	"elf.ELFDATANONE":                               "debug/elf",
+	"elf.ELFMAG":                                    "debug/elf",
+	"elf.ELFOSABI_86OPEN":                           "debug/elf",
+	"elf.ELFOSABI_AIX":                              "debug/elf",
+	"elf.ELFOSABI_ARM":                              "debug/elf",
+	"elf.ELFOSABI_FREEBSD":                          "debug/elf",
+	"elf.ELFOSABI_HPUX":                             "debug/elf",
+	"elf.ELFOSABI_HURD":                             "debug/elf",
+	"elf.ELFOSABI_IRIX":                             "debug/elf",
+	"elf.ELFOSABI_LINUX":                            "debug/elf",
+	"elf.ELFOSABI_MODESTO":                          "debug/elf",
+	"elf.ELFOSABI_NETBSD":                           "debug/elf",
+	"elf.ELFOSABI_NONE":                             "debug/elf",
+	"elf.ELFOSABI_NSK":                              "debug/elf",
+	"elf.ELFOSABI_OPENBSD":                          "debug/elf",
+	"elf.ELFOSABI_OPENVMS":                          "debug/elf",
+	"elf.ELFOSABI_SOLARIS":                          "debug/elf",
+	"elf.ELFOSABI_STANDALONE":                       "debug/elf",
+	"elf.ELFOSABI_TRU64":                            "debug/elf",
+	"elf.EM_386":                                    "debug/elf",
+	"elf.EM_486":                                    "debug/elf",
+	"elf.EM_68HC12":                                 "debug/elf",
+	"elf.EM_68K":                                    "debug/elf",
+	"elf.EM_860":                                    "debug/elf",
+	"elf.EM_88K":                                    "debug/elf",
+	"elf.EM_960":                                    "debug/elf",
+	"elf.EM_AARCH64":                                "debug/elf",
+	"elf.EM_ALPHA":                                  "debug/elf",
+	"elf.EM_ALPHA_STD":                              "debug/elf",
+	"elf.EM_ARC":                                    "debug/elf",
+	"elf.EM_ARM":                                    "debug/elf",
+	"elf.EM_COLDFIRE":                               "debug/elf",
+	"elf.EM_FR20":                                   "debug/elf",
+	"elf.EM_H8S":                                    "debug/elf",
+	"elf.EM_H8_300":                                 "debug/elf",
+	"elf.EM_H8_300H":                                "debug/elf",
+	"elf.EM_H8_500":                                 "debug/elf",
+	"elf.EM_IA_64":                                  "debug/elf",
+	"elf.EM_M32":                                    "debug/elf",
+	"elf.EM_ME16":                                   "debug/elf",
+	"elf.EM_MIPS":                                   "debug/elf",
+	"elf.EM_MIPS_RS3_LE":                            "debug/elf",
+	"elf.EM_MIPS_RS4_BE":                            "debug/elf",
+	"elf.EM_MIPS_X":                                 "debug/elf",
+	"elf.EM_MMA":                                    "debug/elf",
+	"elf.EM_NCPU":                                   "debug/elf",
+	"elf.EM_NDR1":                                   "debug/elf",
+	"elf.EM_NONE":                                   "debug/elf",
+	"elf.EM_PARISC":                                 "debug/elf",
+	"elf.EM_PCP":                                    "debug/elf",
+	"elf.EM_PPC":                                    "debug/elf",
+	"elf.EM_PPC64":                                  "debug/elf",
+	"elf.EM_RCE":                                    "debug/elf",
+	"elf.EM_RH32":                                   "debug/elf",
+	"elf.EM_S370":                                   "debug/elf",
+	"elf.EM_S390":                                   "debug/elf",
+	"elf.EM_SH":                                     "debug/elf",
+	"elf.EM_SPARC":                                  "debug/elf",
+	"elf.EM_SPARC32PLUS":                            "debug/elf",
+	"elf.EM_SPARCV9":                                "debug/elf",
+	"elf.EM_ST100":                                  "debug/elf",
+	"elf.EM_STARCORE":                               "debug/elf",
+	"elf.EM_TINYJ":                                  "debug/elf",
+	"elf.EM_TRICORE":                                "debug/elf",
+	"elf.EM_V800":                                   "debug/elf",
+	"elf.EM_VPP500":                                 "debug/elf",
+	"elf.EM_X86_64":                                 "debug/elf",
+	"elf.ET_CORE":                                   "debug/elf",
+	"elf.ET_DYN":                                    "debug/elf",
+	"elf.ET_EXEC":                                   "debug/elf",
+	"elf.ET_HIOS":                                   "debug/elf",
+	"elf.ET_HIPROC":                                 "debug/elf",
+	"elf.ET_LOOS":                                   "debug/elf",
+	"elf.ET_LOPROC":                                 "debug/elf",
+	"elf.ET_NONE":                                   "debug/elf",
+	"elf.ET_REL":                                    "debug/elf",
+	"elf.EV_CURRENT":                                "debug/elf",
+	"elf.EV_NONE":                                   "debug/elf",
+	"elf.ErrNoSymbols":                              "debug/elf",
+	"elf.File":                                      "debug/elf",
+	"elf.FileHeader":                                "debug/elf",
+	"elf.FormatError":                               "debug/elf",
+	"elf.Header32":                                  "debug/elf",
+	"elf.Header64":                                  "debug/elf",
+	"elf.ImportedSymbol":                            "debug/elf",
+	"elf.Machine":                                   "debug/elf",
+	"elf.NT_FPREGSET":                               "debug/elf",
+	"elf.NT_PRPSINFO":                               "debug/elf",
+	"elf.NT_PRSTATUS":                               "debug/elf",
+	"elf.NType":                                     "debug/elf",
+	"elf.NewFile":                                   "debug/elf",
+	"elf.OSABI":                                     "debug/elf",
+	"elf.Open":                                      "debug/elf",
+	"elf.PF_MASKOS":                                 "debug/elf",
+	"elf.PF_MASKPROC":                               "debug/elf",
+	"elf.PF_R":                                      "debug/elf",
+	"elf.PF_W":                                      "debug/elf",
+	"elf.PF_X":                                      "debug/elf",
+	"elf.PT_DYNAMIC":                                "debug/elf",
+	"elf.PT_HIOS":                                   "debug/elf",
+	"elf.PT_HIPROC":                                 "debug/elf",
+	"elf.PT_INTERP":                                 "debug/elf",
+	"elf.PT_LOAD":                                   "debug/elf",
+	"elf.PT_LOOS":                                   "debug/elf",
+	"elf.PT_LOPROC":                                 "debug/elf",
+	"elf.PT_NOTE":                                   "debug/elf",
+	"elf.PT_NULL":                                   "debug/elf",
+	"elf.PT_PHDR":                                   "debug/elf",
+	"elf.PT_SHLIB":                                  "debug/elf",
+	"elf.PT_TLS":                                    "debug/elf",
+	"elf.Prog":                                      "debug/elf",
+	"elf.Prog32":                                    "debug/elf",
+	"elf.Prog64":                                    "debug/elf",
+	"elf.ProgFlag":                                  "debug/elf",
+	"elf.ProgHeader":                                "debug/elf",
+	"elf.ProgType":                                  "debug/elf",
+	"elf.R_386":                                     "debug/elf",
+	"elf.R_386_32":                                  "debug/elf",
+	"elf.R_386_COPY":                                "debug/elf",
+	"elf.R_386_GLOB_DAT":                            "debug/elf",
+	"elf.R_386_GOT32":                               "debug/elf",
+	"elf.R_386_GOTOFF":                              "debug/elf",
+	"elf.R_386_GOTPC":                               "debug/elf",
+	"elf.R_386_JMP_SLOT":                            "debug/elf",
+	"elf.R_386_NONE":                                "debug/elf",
+	"elf.R_386_PC32":                                "debug/elf",
+	"elf.R_386_PLT32":                               "debug/elf",
+	"elf.R_386_RELATIVE":                            "debug/elf",
+	"elf.R_386_TLS_DTPMOD32":                        "debug/elf",
+	"elf.R_386_TLS_DTPOFF32":                        "debug/elf",
+	"elf.R_386_TLS_GD":                              "debug/elf",
+	"elf.R_386_TLS_GD_32":                           "debug/elf",
+	"elf.R_386_TLS_GD_CALL":                         "debug/elf",
+	"elf.R_386_TLS_GD_POP":                          "debug/elf",
+	"elf.R_386_TLS_GD_PUSH":                         "debug/elf",
+	"elf.R_386_TLS_GOTIE":                           "debug/elf",
+	"elf.R_386_TLS_IE":                              "debug/elf",
+	"elf.R_386_TLS_IE_32":                           "debug/elf",
+	"elf.R_386_TLS_LDM":                             "debug/elf",
+	"elf.R_386_TLS_LDM_32":                          "debug/elf",
+	"elf.R_386_TLS_LDM_CALL":                        "debug/elf",
+	"elf.R_386_TLS_LDM_POP":                         "debug/elf",
+	"elf.R_386_TLS_LDM_PUSH":                        "debug/elf",
+	"elf.R_386_TLS_LDO_32":                          "debug/elf",
+	"elf.R_386_TLS_LE":                              "debug/elf",
+	"elf.R_386_TLS_LE_32":                           "debug/elf",
+	"elf.R_386_TLS_TPOFF":                           "debug/elf",
+	"elf.R_386_TLS_TPOFF32":                         "debug/elf",
+	"elf.R_390":                                     "debug/elf",
+	"elf.R_390_12":                                  "debug/elf",
+	"elf.R_390_16":                                  "debug/elf",
+	"elf.R_390_20":                                  "debug/elf",
+	"elf.R_390_32":                                  "debug/elf",
+	"elf.R_390_64":                                  "debug/elf",
+	"elf.R_390_8":                                   "debug/elf",
+	"elf.R_390_COPY":                                "debug/elf",
+	"elf.R_390_GLOB_DAT":                            "debug/elf",
+	"elf.R_390_GOT12":                               "debug/elf",
+	"elf.R_390_GOT16":                               "debug/elf",
+	"elf.R_390_GOT20":                               "debug/elf",
+	"elf.R_390_GOT32":                               "debug/elf",
+	"elf.R_390_GOT64":                               "debug/elf",
+	"elf.R_390_GOTENT":                              "debug/elf",
+	"elf.R_390_GOTOFF":                              "debug/elf",
+	"elf.R_390_GOTOFF16":                            "debug/elf",
+	"elf.R_390_GOTOFF64":                            "debug/elf",
+	"elf.R_390_GOTPC":                               "debug/elf",
+	"elf.R_390_GOTPCDBL":                            "debug/elf",
+	"elf.R_390_GOTPLT12":                            "debug/elf",
+	"elf.R_390_GOTPLT16":                            "debug/elf",
+	"elf.R_390_GOTPLT20":                            "debug/elf",
+	"elf.R_390_GOTPLT32":                            "debug/elf",
+	"elf.R_390_GOTPLT64":                            "debug/elf",
+	"elf.R_390_GOTPLTENT":                           "debug/elf",
+	"elf.R_390_GOTPLTOFF16":                         "debug/elf",
+	"elf.R_390_GOTPLTOFF32":                         "debug/elf",
+	"elf.R_390_GOTPLTOFF64":                         "debug/elf",
+	"elf.R_390_JMP_SLOT":                            "debug/elf",
+	"elf.R_390_NONE":                                "debug/elf",
+	"elf.R_390_PC16":                                "debug/elf",
+	"elf.R_390_PC16DBL":                             "debug/elf",
+	"elf.R_390_PC32":                                "debug/elf",
+	"elf.R_390_PC32DBL":                             "debug/elf",
+	"elf.R_390_PC64":                                "debug/elf",
+	"elf.R_390_PLT16DBL":                            "debug/elf",
+	"elf.R_390_PLT32":                               "debug/elf",
+	"elf.R_390_PLT32DBL":                            "debug/elf",
+	"elf.R_390_PLT64":                               "debug/elf",
+	"elf.R_390_RELATIVE":                            "debug/elf",
+	"elf.R_390_TLS_DTPMOD":                          "debug/elf",
+	"elf.R_390_TLS_DTPOFF":                          "debug/elf",
+	"elf.R_390_TLS_GD32":                            "debug/elf",
+	"elf.R_390_TLS_GD64":                            "debug/elf",
+	"elf.R_390_TLS_GDCALL":                          "debug/elf",
+	"elf.R_390_TLS_GOTIE12":                         "debug/elf",
+	"elf.R_390_TLS_GOTIE20":                         "debug/elf",
+	"elf.R_390_TLS_GOTIE32":                         "debug/elf",
+	"elf.R_390_TLS_GOTIE64":                         "debug/elf",
+	"elf.R_390_TLS_IE32":                            "debug/elf",
+	"elf.R_390_TLS_IE64":                            "debug/elf",
+	"elf.R_390_TLS_IEENT":                           "debug/elf",
+	"elf.R_390_TLS_LDCALL":                          "debug/elf",
+	"elf.R_390_TLS_LDM32":                           "debug/elf",
+	"elf.R_390_TLS_LDM64":                           "debug/elf",
+	"elf.R_390_TLS_LDO32":                           "debug/elf",
+	"elf.R_390_TLS_LDO64":                           "debug/elf",
+	"elf.R_390_TLS_LE32":                            "debug/elf",
+	"elf.R_390_TLS_LE64":                            "debug/elf",
+	"elf.R_390_TLS_LOAD":                            "debug/elf",
+	"elf.R_390_TLS_TPOFF":                           "debug/elf",
+	"elf.R_AARCH64":                                 "debug/elf",
+	"elf.R_AARCH64_ABS16":                           "debug/elf",
+	"elf.R_AARCH64_ABS32":                           "debug/elf",
+	"elf.R_AARCH64_ABS64":                           "debug/elf",
+	"elf.R_AARCH64_ADD_ABS_LO12_NC":                 "debug/elf",
+	"elf.R_AARCH64_ADR_GOT_PAGE":                    "debug/elf",
+	"elf.R_AARCH64_ADR_PREL_LO21":                   "debug/elf",
+	"elf.R_AARCH64_ADR_PREL_PG_HI21":                "debug/elf",
+	"elf.R_AARCH64_ADR_PREL_PG_HI21_NC":             "debug/elf",
+	"elf.R_AARCH64_CALL26":                          "debug/elf",
+	"elf.R_AARCH64_CONDBR19":                        "debug/elf",
+	"elf.R_AARCH64_COPY":                            "debug/elf",
+	"elf.R_AARCH64_GLOB_DAT":                        "debug/elf",
+	"elf.R_AARCH64_GOT_LD_PREL19":                   "debug/elf",
+	"elf.R_AARCH64_IRELATIVE":                       "debug/elf",
+	"elf.R_AARCH64_JUMP26":                          "debug/elf",
+	"elf.R_AARCH64_JUMP_SLOT":                       "debug/elf",
+	"elf.R_AARCH64_LD64_GOT_LO12_NC":                "debug/elf",
+	"elf.R_AARCH64_LDST128_ABS_LO12_NC":             "debug/elf",
+	"elf.R_AARCH64_LDST16_ABS_LO12_NC":              "debug/elf",
+	"elf.R_AARCH64_LDST32_ABS_LO12_NC":              "debug/elf",
+	"elf.R_AARCH64_LDST64_ABS_LO12_NC":              "debug/elf",
+	"elf.R_AARCH64_LDST8_ABS_LO12_NC":               "debug/elf",
+	"elf.R_AARCH64_LD_PREL_LO19":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_SABS_G0":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_SABS_G1":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_SABS_G2":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G0":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G0_NC":                 "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G1":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G1_NC":                 "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G2":                    "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G2_NC":                 "debug/elf",
+	"elf.R_AARCH64_MOVW_UABS_G3":                    "debug/elf",
+	"elf.R_AARCH64_NONE":                            "debug/elf",
+	"elf.R_AARCH64_NULL":                            "debug/elf",
+	"elf.R_AARCH64_P32_ABS16":                       "debug/elf",
+	"elf.R_AARCH64_P32_ABS32":                       "debug/elf",
+	"elf.R_AARCH64_P32_ADD_ABS_LO12_NC":             "debug/elf",
+	"elf.R_AARCH64_P32_ADR_GOT_PAGE":                "debug/elf",
+	"elf.R_AARCH64_P32_ADR_PREL_LO21":               "debug/elf",
+	"elf.R_AARCH64_P32_ADR_PREL_PG_HI21":            "debug/elf",
+	"elf.R_AARCH64_P32_CALL26":                      "debug/elf",
+	"elf.R_AARCH64_P32_CONDBR19":                    "debug/elf",
+	"elf.R_AARCH64_P32_COPY":                        "debug/elf",
+	"elf.R_AARCH64_P32_GLOB_DAT":                    "debug/elf",
+	"elf.R_AARCH64_P32_GOT_LD_PREL19":               "debug/elf",
+	"elf.R_AARCH64_P32_IRELATIVE":                   "debug/elf",
+	"elf.R_AARCH64_P32_JUMP26":                      "debug/elf",
+	"elf.R_AARCH64_P32_JUMP_SLOT":                   "debug/elf",
+	"elf.R_AARCH64_P32_LD32_GOT_LO12_NC":            "debug/elf",
+	"elf.R_AARCH64_P32_LDST128_ABS_LO12_NC":         "debug/elf",
+	"elf.R_AARCH64_P32_LDST16_ABS_LO12_NC":          "debug/elf",
+	"elf.R_AARCH64_P32_LDST32_ABS_LO12_NC":          "debug/elf",
+	"elf.R_AARCH64_P32_LDST64_ABS_LO12_NC":          "debug/elf",
+	"elf.R_AARCH64_P32_LDST8_ABS_LO12_NC":           "debug/elf",
+	"elf.R_AARCH64_P32_LD_PREL_LO19":                "debug/elf",
+	"elf.R_AARCH64_P32_MOVW_SABS_G0":                "debug/elf",
+	"elf.R_AARCH64_P32_MOVW_UABS_G0":                "debug/elf",
+	"elf.R_AARCH64_P32_MOVW_UABS_G0_NC":             "debug/elf",
+	"elf.R_AARCH64_P32_MOVW_UABS_G1":                "debug/elf",
+	"elf.R_AARCH64_P32_PREL16":                      "debug/elf",
+	"elf.R_AARCH64_P32_PREL32":                      "debug/elf",
+	"elf.R_AARCH64_P32_RELATIVE":                    "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC":                     "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_ADD_LO12_NC":         "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_ADR_PAGE21":          "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_ADR_PREL21":          "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_CALL":                "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_LD32_LO12_NC":        "debug/elf",
+	"elf.R_AARCH64_P32_TLSDESC_LD_PREL19":           "debug/elf",
+	"elf.R_AARCH64_P32_TLSGD_ADD_LO12_NC":           "debug/elf",
+	"elf.R_AARCH64_P32_TLSGD_ADR_PAGE21":            "debug/elf",
+	"elf.R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21":   "debug/elf",
+	"elf.R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC": "debug/elf",
+	"elf.R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19":    "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_ADD_TPREL_HI12":        "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12":        "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC":     "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0":         "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC":      "debug/elf",
+	"elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G1":         "debug/elf",
+	"elf.R_AARCH64_P32_TLS_DTPMOD":                  "debug/elf",
+	"elf.R_AARCH64_P32_TLS_DTPREL":                  "debug/elf",
+	"elf.R_AARCH64_P32_TLS_TPREL":                   "debug/elf",
+	"elf.R_AARCH64_P32_TSTBR14":                     "debug/elf",
+	"elf.R_AARCH64_PREL16":                          "debug/elf",
+	"elf.R_AARCH64_PREL32":                          "debug/elf",
+	"elf.R_AARCH64_PREL64":                          "debug/elf",
+	"elf.R_AARCH64_RELATIVE":                        "debug/elf",
+	"elf.R_AARCH64_TLSDESC":                         "debug/elf",
+	"elf.R_AARCH64_TLSDESC_ADD":                     "debug/elf",
+	"elf.R_AARCH64_TLSDESC_ADD_LO12_NC":             "debug/elf",
+	"elf.R_AARCH64_TLSDESC_ADR_PAGE21":              "debug/elf",
+	"elf.R_AARCH64_TLSDESC_ADR_PREL21":              "debug/elf",
+	"elf.R_AARCH64_TLSDESC_CALL":                    "debug/elf",
+	"elf.R_AARCH64_TLSDESC_LD64_LO12_NC":            "debug/elf",
+	"elf.R_AARCH64_TLSDESC_LDR":                     "debug/elf",
+	"elf.R_AARCH64_TLSDESC_LD_PREL19":               "debug/elf",
+	"elf.R_AARCH64_TLSDESC_OFF_G0_NC":               "debug/elf",
+	"elf.R_AARCH64_TLSDESC_OFF_G1":                  "debug/elf",
+	"elf.R_AARCH64_TLSGD_ADD_LO12_NC":               "debug/elf",
+	"elf.R_AARCH64_TLSGD_ADR_PAGE21":                "debug/elf",
+	"elf.R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21":       "debug/elf",
+	"elf.R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC":     "debug/elf",
+	"elf.R_AARCH64_TLSIE_LD_GOTTPREL_PREL19":        "debug/elf",
+	"elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC":       "debug/elf",
+	"elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G1":          "debug/elf",
+	"elf.R_AARCH64_TLSLE_ADD_TPREL_HI12":            "debug/elf",
+	"elf.R_AARCH64_TLSLE_ADD_TPREL_LO12":            "debug/elf",
+	"elf.R_AARCH64_TLSLE_ADD_TPREL_LO12_NC":         "debug/elf",
+	"elf.R_AARCH64_TLSLE_MOVW_TPREL_G0":             "debug/elf",
+	"elf.R_AARCH64_TLSLE_MOVW_TPREL_G0_NC":          "debug/elf",
+	"elf.R_AARCH64_TLSLE_MOVW_TPREL_G1":             "debug/elf",
+	"elf.R_AARCH64_TLSLE_MOVW_TPREL_G1_NC":          "debug/elf",
+	"elf.R_AARCH64_TLSLE_MOVW_TPREL_G2":             "debug/elf",
+	"elf.R_AARCH64_TLS_DTPMOD64":                    "debug/elf",
+	"elf.R_AARCH64_TLS_DTPREL64":                    "debug/elf",
+	"elf.R_AARCH64_TLS_TPREL64":                     "debug/elf",
+	"elf.R_AARCH64_TSTBR14":                         "debug/elf",
+	"elf.R_ALPHA":                                   "debug/elf",
+	"elf.R_ALPHA_BRADDR":                            "debug/elf",
+	"elf.R_ALPHA_COPY":                              "debug/elf",
+	"elf.R_ALPHA_GLOB_DAT":                          "debug/elf",
+	"elf.R_ALPHA_GPDISP":                            "debug/elf",
+	"elf.R_ALPHA_GPREL32":                           "debug/elf",
+	"elf.R_ALPHA_GPRELHIGH":                         "debug/elf",
+	"elf.R_ALPHA_GPRELLOW":                          "debug/elf",
+	"elf.R_ALPHA_GPVALUE":                           "debug/elf",
+	"elf.R_ALPHA_HINT":                              "debug/elf",
+	"elf.R_ALPHA_IMMED_BR_HI32":                     "debug/elf",
+	"elf.R_ALPHA_IMMED_GP_16":                       "debug/elf",
+	"elf.R_ALPHA_IMMED_GP_HI32":                     "debug/elf",
+	"elf.R_ALPHA_IMMED_LO32":                        "debug/elf",
+	"elf.R_ALPHA_IMMED_SCN_HI32":                    "debug/elf",
+	"elf.R_ALPHA_JMP_SLOT":                          "debug/elf",
+	"elf.R_ALPHA_LITERAL":                           "debug/elf",
+	"elf.R_ALPHA_LITUSE":                            "debug/elf",
+	"elf.R_ALPHA_NONE":                              "debug/elf",
+	"elf.R_ALPHA_OP_PRSHIFT":                        "debug/elf",
+	"elf.R_ALPHA_OP_PSUB":                           "debug/elf",
+	"elf.R_ALPHA_OP_PUSH":                           "debug/elf",
+	"elf.R_ALPHA_OP_STORE":                          "debug/elf",
+	"elf.R_ALPHA_REFLONG":                           "debug/elf",
+	"elf.R_ALPHA_REFQUAD":                           "debug/elf",
+	"elf.R_ALPHA_RELATIVE":                          "debug/elf",
+	"elf.R_ALPHA_SREL16":                            "debug/elf",
+	"elf.R_ALPHA_SREL32":                            "debug/elf",
+	"elf.R_ALPHA_SREL64":                            "debug/elf",
+	"elf.R_ARM":                                     "debug/elf",
+	"elf.R_ARM_ABS12":                               "debug/elf",
+	"elf.R_ARM_ABS16":                               "debug/elf",
+	"elf.R_ARM_ABS32":                               "debug/elf",
+	"elf.R_ARM_ABS8":                                "debug/elf",
+	"elf.R_ARM_AMP_VCALL9":                          "debug/elf",
+	"elf.R_ARM_COPY":                                "debug/elf",
+	"elf.R_ARM_GLOB_DAT":                            "debug/elf",
+	"elf.R_ARM_GNU_VTENTRY":                         "debug/elf",
+	"elf.R_ARM_GNU_VTINHERIT":                       "debug/elf",
+	"elf.R_ARM_GOT32":                               "debug/elf",
+	"elf.R_ARM_GOTOFF":                              "debug/elf",
+	"elf.R_ARM_GOTPC":                               "debug/elf",
+	"elf.R_ARM_JUMP_SLOT":                           "debug/elf",
+	"elf.R_ARM_NONE":                                "debug/elf",
+	"elf.R_ARM_PC13":                                "debug/elf",
+	"elf.R_ARM_PC24":                                "debug/elf",
+	"elf.R_ARM_PLT32":                               "debug/elf",
+	"elf.R_ARM_RABS32":                              "debug/elf",
+	"elf.R_ARM_RBASE":                               "debug/elf",
+	"elf.R_ARM_REL32":                               "debug/elf",
+	"elf.R_ARM_RELATIVE":                            "debug/elf",
+	"elf.R_ARM_RPC24":                               "debug/elf",
+	"elf.R_ARM_RREL32":                              "debug/elf",
+	"elf.R_ARM_RSBREL32":                            "debug/elf",
+	"elf.R_ARM_SBREL32":                             "debug/elf",
+	"elf.R_ARM_SWI24":                               "debug/elf",
+	"elf.R_ARM_THM_ABS5":                            "debug/elf",
+	"elf.R_ARM_THM_PC22":                            "debug/elf",
+	"elf.R_ARM_THM_PC8":                             "debug/elf",
+	"elf.R_ARM_THM_RPC22":                           "debug/elf",
+	"elf.R_ARM_THM_SWI8":                            "debug/elf",
+	"elf.R_ARM_THM_XPC22":                           "debug/elf",
+	"elf.R_ARM_XPC25":                               "debug/elf",
+	"elf.R_INFO":                                    "debug/elf",
+	"elf.R_INFO32":                                  "debug/elf",
+	"elf.R_MIPS":                                    "debug/elf",
+	"elf.R_MIPS_16":                                 "debug/elf",
+	"elf.R_MIPS_26":                                 "debug/elf",
+	"elf.R_MIPS_32":                                 "debug/elf",
+	"elf.R_MIPS_64":                                 "debug/elf",
+	"elf.R_MIPS_ADD_IMMEDIATE":                      "debug/elf",
+	"elf.R_MIPS_CALL16":                             "debug/elf",
+	"elf.R_MIPS_CALL_HI16":                          "debug/elf",
+	"elf.R_MIPS_CALL_LO16":                          "debug/elf",
+	"elf.R_MIPS_DELETE":                             "debug/elf",
+	"elf.R_MIPS_GOT16":                              "debug/elf",
+	"elf.R_MIPS_GOT_DISP":                           "debug/elf",
+	"elf.R_MIPS_GOT_HI16":                           "debug/elf",
+	"elf.R_MIPS_GOT_LO16":                           "debug/elf",
+	"elf.R_MIPS_GOT_OFST":                           "debug/elf",
+	"elf.R_MIPS_GOT_PAGE":                           "debug/elf",
+	"elf.R_MIPS_GPREL16":                            "debug/elf",
+	"elf.R_MIPS_GPREL32":                            "debug/elf",
+	"elf.R_MIPS_HI16":                               "debug/elf",
+	"elf.R_MIPS_HIGHER":                             "debug/elf",
+	"elf.R_MIPS_HIGHEST":                            "debug/elf",
+	"elf.R_MIPS_INSERT_A":                           "debug/elf",
+	"elf.R_MIPS_INSERT_B":                           "debug/elf",
+	"elf.R_MIPS_JALR":                               "debug/elf",
+	"elf.R_MIPS_LITERAL":                            "debug/elf",
+	"elf.R_MIPS_LO16":                               "debug/elf",
+	"elf.R_MIPS_NONE":                               "debug/elf",
+	"elf.R_MIPS_PC16":                               "debug/elf",
+	"elf.R_MIPS_PJUMP":                              "debug/elf",
+	"elf.R_MIPS_REL16":                              "debug/elf",
+	"elf.R_MIPS_REL32":                              "debug/elf",
+	"elf.R_MIPS_RELGOT":                             "debug/elf",
+	"elf.R_MIPS_SCN_DISP":                           "debug/elf",
+	"elf.R_MIPS_SHIFT5":                             "debug/elf",
+	"elf.R_MIPS_SHIFT6":                             "debug/elf",
+	"elf.R_MIPS_SUB":                                "debug/elf",
+	"elf.R_MIPS_TLS_DTPMOD32":                       "debug/elf",
+	"elf.R_MIPS_TLS_DTPMOD64":                       "debug/elf",
+	"elf.R_MIPS_TLS_DTPREL32":                       "debug/elf",
+	"elf.R_MIPS_TLS_DTPREL64":                       "debug/elf",
+	"elf.R_MIPS_TLS_DTPREL_HI16":                    "debug/elf",
+	"elf.R_MIPS_TLS_DTPREL_LO16":                    "debug/elf",
+	"elf.R_MIPS_TLS_GD":                             "debug/elf",
+	"elf.R_MIPS_TLS_GOTTPREL":                       "debug/elf",
+	"elf.R_MIPS_TLS_LDM":                            "debug/elf",
+	"elf.R_MIPS_TLS_TPREL32":                        "debug/elf",
+	"elf.R_MIPS_TLS_TPREL64":                        "debug/elf",
+	"elf.R_MIPS_TLS_TPREL_HI16":                     "debug/elf",
+	"elf.R_MIPS_TLS_TPREL_LO16":                     "debug/elf",
+	"elf.R_PPC":                                     "debug/elf",
+	"elf.R_PPC64":                                   "debug/elf",
+	"elf.R_PPC64_ADDR14":                            "debug/elf",
+	"elf.R_PPC64_ADDR14_BRNTAKEN":                   "debug/elf",
+	"elf.R_PPC64_ADDR14_BRTAKEN":                    "debug/elf",
+	"elf.R_PPC64_ADDR16":                            "debug/elf",
+	"elf.R_PPC64_ADDR16_DS":                         "debug/elf",
+	"elf.R_PPC64_ADDR16_HA":                         "debug/elf",
+	"elf.R_PPC64_ADDR16_HI":                         "debug/elf",
+	"elf.R_PPC64_ADDR16_HIGHER":                     "debug/elf",
+	"elf.R_PPC64_ADDR16_HIGHERA":                    "debug/elf",
+	"elf.R_PPC64_ADDR16_HIGHEST":                    "debug/elf",
+	"elf.R_PPC64_ADDR16_HIGHESTA":                   "debug/elf",
+	"elf.R_PPC64_ADDR16_LO":                         "debug/elf",
+	"elf.R_PPC64_ADDR16_LO_DS":                      "debug/elf",
+	"elf.R_PPC64_ADDR24":                            "debug/elf",
+	"elf.R_PPC64_ADDR32":                            "debug/elf",
+	"elf.R_PPC64_ADDR64":                            "debug/elf",
+	"elf.R_PPC64_DTPMOD64":                          "debug/elf",
+	"elf.R_PPC64_DTPREL16":                          "debug/elf",
+	"elf.R_PPC64_DTPREL16_DS":                       "debug/elf",
+	"elf.R_PPC64_DTPREL16_HA":                       "debug/elf",
+	"elf.R_PPC64_DTPREL16_HI":                       "debug/elf",
+	"elf.R_PPC64_DTPREL16_HIGHER":                   "debug/elf",
+	"elf.R_PPC64_DTPREL16_HIGHERA":                  "debug/elf",
+	"elf.R_PPC64_DTPREL16_HIGHEST":                  "debug/elf",
+	"elf.R_PPC64_DTPREL16_HIGHESTA":                 "debug/elf",
+	"elf.R_PPC64_DTPREL16_LO":                       "debug/elf",
+	"elf.R_PPC64_DTPREL16_LO_DS":                    "debug/elf",
+	"elf.R_PPC64_DTPREL64":                          "debug/elf",
+	"elf.R_PPC64_GOT16":                             "debug/elf",
+	"elf.R_PPC64_GOT16_DS":                          "debug/elf",
+	"elf.R_PPC64_GOT16_HA":                          "debug/elf",
+	"elf.R_PPC64_GOT16_HI":                          "debug/elf",
+	"elf.R_PPC64_GOT16_LO":                          "debug/elf",
+	"elf.R_PPC64_GOT16_LO_DS":                       "debug/elf",
+	"elf.R_PPC64_GOT_DTPREL16_DS":                   "debug/elf",
+	"elf.R_PPC64_GOT_DTPREL16_HA":                   "debug/elf",
+	"elf.R_PPC64_GOT_DTPREL16_HI":                   "debug/elf",
+	"elf.R_PPC64_GOT_DTPREL16_LO_DS":                "debug/elf",
+	"elf.R_PPC64_GOT_TLSGD16":                       "debug/elf",
+	"elf.R_PPC64_GOT_TLSGD16_HA":                    "debug/elf",
+	"elf.R_PPC64_GOT_TLSGD16_HI":                    "debug/elf",
+	"elf.R_PPC64_GOT_TLSGD16_LO":                    "debug/elf",
+	"elf.R_PPC64_GOT_TLSLD16":                       "debug/elf",
+	"elf.R_PPC64_GOT_TLSLD16_HA":                    "debug/elf",
+	"elf.R_PPC64_GOT_TLSLD16_HI":                    "debug/elf",
+	"elf.R_PPC64_GOT_TLSLD16_LO":                    "debug/elf",
+	"elf.R_PPC64_GOT_TPREL16_DS":                    "debug/elf",
+	"elf.R_PPC64_GOT_TPREL16_HA":                    "debug/elf",
+	"elf.R_PPC64_GOT_TPREL16_HI":                    "debug/elf",
+	"elf.R_PPC64_GOT_TPREL16_LO_DS":                 "debug/elf",
+	"elf.R_PPC64_JMP_SLOT":                          "debug/elf",
+	"elf.R_PPC64_NONE":                              "debug/elf",
+	"elf.R_PPC64_REL14":                             "debug/elf",
+	"elf.R_PPC64_REL14_BRNTAKEN":                    "debug/elf",
+	"elf.R_PPC64_REL14_BRTAKEN":                     "debug/elf",
+	"elf.R_PPC64_REL16":                             "debug/elf",
+	"elf.R_PPC64_REL16_HA":                          "debug/elf",
+	"elf.R_PPC64_REL16_HI":                          "debug/elf",
+	"elf.R_PPC64_REL16_LO":                          "debug/elf",
+	"elf.R_PPC64_REL24":                             "debug/elf",
+	"elf.R_PPC64_REL32":                             "debug/elf",
+	"elf.R_PPC64_REL64":                             "debug/elf",
+	"elf.R_PPC64_TLS":                               "debug/elf",
+	"elf.R_PPC64_TLSGD":                             "debug/elf",
+	"elf.R_PPC64_TLSLD":                             "debug/elf",
+	"elf.R_PPC64_TOC":                               "debug/elf",
+	"elf.R_PPC64_TOC16":                             "debug/elf",
+	"elf.R_PPC64_TOC16_DS":                          "debug/elf",
+	"elf.R_PPC64_TOC16_HA":                          "debug/elf",
+	"elf.R_PPC64_TOC16_HI":                          "debug/elf",
+	"elf.R_PPC64_TOC16_LO":                          "debug/elf",
+	"elf.R_PPC64_TOC16_LO_DS":                       "debug/elf",
+	"elf.R_PPC64_TPREL16":                           "debug/elf",
+	"elf.R_PPC64_TPREL16_DS":                        "debug/elf",
+	"elf.R_PPC64_TPREL16_HA":                        "debug/elf",
+	"elf.R_PPC64_TPREL16_HI":                        "debug/elf",
+	"elf.R_PPC64_TPREL16_HIGHER":                    "debug/elf",
+	"elf.R_PPC64_TPREL16_HIGHERA":                   "debug/elf",
+	"elf.R_PPC64_TPREL16_HIGHEST":                   "debug/elf",
+	"elf.R_PPC64_TPREL16_HIGHESTA":                  "debug/elf",
+	"elf.R_PPC64_TPREL16_LO":                        "debug/elf",
+	"elf.R_PPC64_TPREL16_LO_DS":                     "debug/elf",
+	"elf.R_PPC64_TPREL64":                           "debug/elf",
+	"elf.R_PPC_ADDR14":                              "debug/elf",
+	"elf.R_PPC_ADDR14_BRNTAKEN":                     "debug/elf",
+	"elf.R_PPC_ADDR14_BRTAKEN":                      "debug/elf",
+	"elf.R_PPC_ADDR16":                              "debug/elf",
+	"elf.R_PPC_ADDR16_HA":                           "debug/elf",
+	"elf.R_PPC_ADDR16_HI":                           "debug/elf",
+	"elf.R_PPC_ADDR16_LO":                           "debug/elf",
+	"elf.R_PPC_ADDR24":                              "debug/elf",
+	"elf.R_PPC_ADDR32":                              "debug/elf",
+	"elf.R_PPC_COPY":                                "debug/elf",
+	"elf.R_PPC_DTPMOD32":                            "debug/elf",
+	"elf.R_PPC_DTPREL16":                            "debug/elf",
+	"elf.R_PPC_DTPREL16_HA":                         "debug/elf",
+	"elf.R_PPC_DTPREL16_HI":                         "debug/elf",
+	"elf.R_PPC_DTPREL16_LO":                         "debug/elf",
+	"elf.R_PPC_DTPREL32":                            "debug/elf",
+	"elf.R_PPC_EMB_BIT_FLD":                         "debug/elf",
+	"elf.R_PPC_EMB_MRKREF":                          "debug/elf",
+	"elf.R_PPC_EMB_NADDR16":                         "debug/elf",
+	"elf.R_PPC_EMB_NADDR16_HA":                      "debug/elf",
+	"elf.R_PPC_EMB_NADDR16_HI":                      "debug/elf",
+	"elf.R_PPC_EMB_NADDR16_LO":                      "debug/elf",
+	"elf.R_PPC_EMB_NADDR32":                         "debug/elf",
+	"elf.R_PPC_EMB_RELSDA":                          "debug/elf",
+	"elf.R_PPC_EMB_RELSEC16":                        "debug/elf",
+	"elf.R_PPC_EMB_RELST_HA":                        "debug/elf",
+	"elf.R_PPC_EMB_RELST_HI":                        "debug/elf",
+	"elf.R_PPC_EMB_RELST_LO":                        "debug/elf",
+	"elf.R_PPC_EMB_SDA21":                           "debug/elf",
+	"elf.R_PPC_EMB_SDA2I16":                         "debug/elf",
+	"elf.R_PPC_EMB_SDA2REL":                         "debug/elf",
+	"elf.R_PPC_EMB_SDAI16":                          "debug/elf",
+	"elf.R_PPC_GLOB_DAT":                            "debug/elf",
+	"elf.R_PPC_GOT16":                               "debug/elf",
+	"elf.R_PPC_GOT16_HA":                            "debug/elf",
+	"elf.R_PPC_GOT16_HI":                            "debug/elf",
+	"elf.R_PPC_GOT16_LO":                            "debug/elf",
+	"elf.R_PPC_GOT_TLSGD16":                         "debug/elf",
+	"elf.R_PPC_GOT_TLSGD16_HA":                      "debug/elf",
+	"elf.R_PPC_GOT_TLSGD16_HI":                      "debug/elf",
+	"elf.R_PPC_GOT_TLSGD16_LO":                      "debug/elf",
+	"elf.R_PPC_GOT_TLSLD16":                         "debug/elf",
+	"elf.R_PPC_GOT_TLSLD16_HA":                      "debug/elf",
+	"elf.R_PPC_GOT_TLSLD16_HI":                      "debug/elf",
+	"elf.R_PPC_GOT_TLSLD16_LO":                      "debug/elf",
+	"elf.R_PPC_GOT_TPREL16":                         "debug/elf",
+	"elf.R_PPC_GOT_TPREL16_HA":                      "debug/elf",
+	"elf.R_PPC_GOT_TPREL16_HI":                      "debug/elf",
+	"elf.R_PPC_GOT_TPREL16_LO":                      "debug/elf",
+	"elf.R_PPC_JMP_SLOT":                            "debug/elf",
+	"elf.R_PPC_LOCAL24PC":                           "debug/elf",
+	"elf.R_PPC_NONE":                                "debug/elf",
+	"elf.R_PPC_PLT16_HA":                            "debug/elf",
+	"elf.R_PPC_PLT16_HI":                            "debug/elf",
+	"elf.R_PPC_PLT16_LO":                            "debug/elf",
+	"elf.R_PPC_PLT32":                               "debug/elf",
+	"elf.R_PPC_PLTREL24":                            "debug/elf",
+	"elf.R_PPC_PLTREL32":                            "debug/elf",
+	"elf.R_PPC_REL14":                               "debug/elf",
+	"elf.R_PPC_REL14_BRNTAKEN":                      "debug/elf",
+	"elf.R_PPC_REL14_BRTAKEN":                       "debug/elf",
+	"elf.R_PPC_REL24":                               "debug/elf",
+	"elf.R_PPC_REL32":                               "debug/elf",
+	"elf.R_PPC_RELATIVE":                            "debug/elf",
+	"elf.R_PPC_SDAREL16":                            "debug/elf",
+	"elf.R_PPC_SECTOFF":                             "debug/elf",
+	"elf.R_PPC_SECTOFF_HA":                          "debug/elf",
+	"elf.R_PPC_SECTOFF_HI":                          "debug/elf",
+	"elf.R_PPC_SECTOFF_LO":                          "debug/elf",
+	"elf.R_PPC_TLS":                                 "debug/elf",
+	"elf.R_PPC_TPREL16":                             "debug/elf",
+	"elf.R_PPC_TPREL16_HA":                          "debug/elf",
+	"elf.R_PPC_TPREL16_HI":                          "debug/elf",
+	"elf.R_PPC_TPREL16_LO":                          "debug/elf",
+	"elf.R_PPC_TPREL32":                             "debug/elf",
+	"elf.R_PPC_UADDR16":                             "debug/elf",
+	"elf.R_PPC_UADDR32":                             "debug/elf",
+	"elf.R_SPARC":                                   "debug/elf",
+	"elf.R_SPARC_10":                                "debug/elf",
+	"elf.R_SPARC_11":                                "debug/elf",
+	"elf.R_SPARC_13":                                "debug/elf",
+	"elf.R_SPARC_16":                                "debug/elf",
+	"elf.R_SPARC_22":                                "debug/elf",
+	"elf.R_SPARC_32":                                "debug/elf",
+	"elf.R_SPARC_5":                                 "debug/elf",
+	"elf.R_SPARC_6":                                 "debug/elf",
+	"elf.R_SPARC_64":                                "debug/elf",
+	"elf.R_SPARC_7":                                 "debug/elf",
+	"elf.R_SPARC_8":                                 "debug/elf",
+	"elf.R_SPARC_COPY":                              "debug/elf",
+	"elf.R_SPARC_DISP16":                            "debug/elf",
+	"elf.R_SPARC_DISP32":                            "debug/elf",
+	"elf.R_SPARC_DISP64":                            "debug/elf",
+	"elf.R_SPARC_DISP8":                             "debug/elf",
+	"elf.R_SPARC_GLOB_DAT":                          "debug/elf",
+	"elf.R_SPARC_GLOB_JMP":                          "debug/elf",
+	"elf.R_SPARC_GOT10":                             "debug/elf",
+	"elf.R_SPARC_GOT13":                             "debug/elf",
+	"elf.R_SPARC_GOT22":                             "debug/elf",
+	"elf.R_SPARC_H44":                               "debug/elf",
+	"elf.R_SPARC_HH22":                              "debug/elf",
+	"elf.R_SPARC_HI22":                              "debug/elf",
+	"elf.R_SPARC_HIPLT22":                           "debug/elf",
+	"elf.R_SPARC_HIX22":                             "debug/elf",
+	"elf.R_SPARC_HM10":                              "debug/elf",
+	"elf.R_SPARC_JMP_SLOT":                          "debug/elf",
+	"elf.R_SPARC_L44":                               "debug/elf",
+	"elf.R_SPARC_LM22":                              "debug/elf",
+	"elf.R_SPARC_LO10":                              "debug/elf",
+	"elf.R_SPARC_LOPLT10":                           "debug/elf",
+	"elf.R_SPARC_LOX10":                             "debug/elf",
+	"elf.R_SPARC_M44":                               "debug/elf",
+	"elf.R_SPARC_NONE":                              "debug/elf",
+	"elf.R_SPARC_OLO10":                             "debug/elf",
+	"elf.R_SPARC_PC10":                              "debug/elf",
+	"elf.R_SPARC_PC22":                              "debug/elf",
+	"elf.R_SPARC_PCPLT10":                           "debug/elf",
+	"elf.R_SPARC_PCPLT22":                           "debug/elf",
+	"elf.R_SPARC_PCPLT32":                           "debug/elf",
+	"elf.R_SPARC_PC_HH22":                           "debug/elf",
+	"elf.R_SPARC_PC_HM10":                           "debug/elf",
+	"elf.R_SPARC_PC_LM22":                           "debug/elf",
+	"elf.R_SPARC_PLT32":                             "debug/elf",
+	"elf.R_SPARC_PLT64":                             "debug/elf",
+	"elf.R_SPARC_REGISTER":                          "debug/elf",
+	"elf.R_SPARC_RELATIVE":                          "debug/elf",
+	"elf.R_SPARC_UA16":                              "debug/elf",
+	"elf.R_SPARC_UA32":                              "debug/elf",
+	"elf.R_SPARC_UA64":                              "debug/elf",
+	"elf.R_SPARC_WDISP16":                           "debug/elf",
+	"elf.R_SPARC_WDISP19":                           "debug/elf",
+	"elf.R_SPARC_WDISP22":                           "debug/elf",
+	"elf.R_SPARC_WDISP30":                           "debug/elf",
+	"elf.R_SPARC_WPLT30":                            "debug/elf",
+	"elf.R_SYM32":                                   "debug/elf",
+	"elf.R_SYM64":                                   "debug/elf",
+	"elf.R_TYPE32":                                  "debug/elf",
+	"elf.R_TYPE64":                                  "debug/elf",
+	"elf.R_X86_64":                                  "debug/elf",
+	"elf.R_X86_64_16":                               "debug/elf",
+	"elf.R_X86_64_32":                               "debug/elf",
+	"elf.R_X86_64_32S":                              "debug/elf",
+	"elf.R_X86_64_64":                               "debug/elf",
+	"elf.R_X86_64_8":                                "debug/elf",
+	"elf.R_X86_64_COPY":                             "debug/elf",
+	"elf.R_X86_64_DTPMOD64":                         "debug/elf",
+	"elf.R_X86_64_DTPOFF32":                         "debug/elf",
+	"elf.R_X86_64_DTPOFF64":                         "debug/elf",
+	"elf.R_X86_64_GLOB_DAT":                         "debug/elf",
+	"elf.R_X86_64_GOT32":                            "debug/elf",
+	"elf.R_X86_64_GOTPCREL":                         "debug/elf",
+	"elf.R_X86_64_GOTTPOFF":                         "debug/elf",
+	"elf.R_X86_64_JMP_SLOT":                         "debug/elf",
+	"elf.R_X86_64_NONE":                             "debug/elf",
+	"elf.R_X86_64_PC16":                             "debug/elf",
+	"elf.R_X86_64_PC32":                             "debug/elf",
+	"elf.R_X86_64_PC8":                              "debug/elf",
+	"elf.R_X86_64_PLT32":                            "debug/elf",
+	"elf.R_X86_64_RELATIVE":                         "debug/elf",
+	"elf.R_X86_64_TLSGD":                            "debug/elf",
+	"elf.R_X86_64_TLSLD":                            "debug/elf",
+	"elf.R_X86_64_TPOFF32":                          "debug/elf",
+	"elf.R_X86_64_TPOFF64":                          "debug/elf",
+	"elf.Rel32":                                     "debug/elf",
+	"elf.Rel64":                                     "debug/elf",
+	"elf.Rela32":                                    "debug/elf",
+	"elf.Rela64":                                    "debug/elf",
+	"elf.SHF_ALLOC":                                 "debug/elf",
+	"elf.SHF_COMPRESSED":                            "debug/elf",
+	"elf.SHF_EXECINSTR":                             "debug/elf",
+	"elf.SHF_GROUP":                                 "debug/elf",
+	"elf.SHF_INFO_LINK":                             "debug/elf",
+	"elf.SHF_LINK_ORDER":                            "debug/elf",
+	"elf.SHF_MASKOS":                                "debug/elf",
+	"elf.SHF_MASKPROC":                              "debug/elf",
+	"elf.SHF_MERGE":                                 "debug/elf",
+	"elf.SHF_OS_NONCONFORMING":                      "debug/elf",
+	"elf.SHF_STRINGS":                               "debug/elf",
+	"elf.SHF_TLS":                                   "debug/elf",
+	"elf.SHF_WRITE":                                 "debug/elf",
+	"elf.SHN_ABS":                                   "debug/elf",
+	"elf.SHN_COMMON":                                "debug/elf",
+	"elf.SHN_HIOS":                                  "debug/elf",
+	"elf.SHN_HIPROC":                                "debug/elf",
+	"elf.SHN_HIRESERVE":                             "debug/elf",
+	"elf.SHN_LOOS":                                  "debug/elf",
+	"elf.SHN_LOPROC":                                "debug/elf",
+	"elf.SHN_LORESERVE":                             "debug/elf",
+	"elf.SHN_UNDEF":                                 "debug/elf",
+	"elf.SHN_XINDEX":                                "debug/elf",
+	"elf.SHT_DYNAMIC":                               "debug/elf",
+	"elf.SHT_DYNSYM":                                "debug/elf",
+	"elf.SHT_FINI_ARRAY":                            "debug/elf",
+	"elf.SHT_GNU_ATTRIBUTES":                        "debug/elf",
+	"elf.SHT_GNU_HASH":                              "debug/elf",
+	"elf.SHT_GNU_LIBLIST":                           "debug/elf",
+	"elf.SHT_GNU_VERDEF":                            "debug/elf",
+	"elf.SHT_GNU_VERNEED":                           "debug/elf",
+	"elf.SHT_GNU_VERSYM":                            "debug/elf",
+	"elf.SHT_GROUP":                                 "debug/elf",
+	"elf.SHT_HASH":                                  "debug/elf",
+	"elf.SHT_HIOS":                                  "debug/elf",
+	"elf.SHT_HIPROC":                                "debug/elf",
+	"elf.SHT_HIUSER":                                "debug/elf",
+	"elf.SHT_INIT_ARRAY":                            "debug/elf",
+	"elf.SHT_LOOS":                                  "debug/elf",
+	"elf.SHT_LOPROC":                                "debug/elf",
+	"elf.SHT_LOUSER":                                "debug/elf",
+	"elf.SHT_NOBITS":                                "debug/elf",
+	"elf.SHT_NOTE":                                  "debug/elf",
+	"elf.SHT_NULL":                                  "debug/elf",
+	"elf.SHT_PREINIT_ARRAY":                         "debug/elf",
+	"elf.SHT_PROGBITS":                              "debug/elf",
+	"elf.SHT_REL":                                   "debug/elf",
+	"elf.SHT_RELA":                                  "debug/elf",
+	"elf.SHT_SHLIB":                                 "debug/elf",
+	"elf.SHT_STRTAB":                                "debug/elf",
+	"elf.SHT_SYMTAB":                                "debug/elf",
+	"elf.SHT_SYMTAB_SHNDX":                          "debug/elf",
+	"elf.STB_GLOBAL":                                "debug/elf",
+	"elf.STB_HIOS":                                  "debug/elf",
+	"elf.STB_HIPROC":                                "debug/elf",
+	"elf.STB_LOCAL":                                 "debug/elf",
+	"elf.STB_LOOS":                                  "debug/elf",
+	"elf.STB_LOPROC":                                "debug/elf",
+	"elf.STB_WEAK":                                  "debug/elf",
+	"elf.STT_COMMON":                                "debug/elf",
+	"elf.STT_FILE":                                  "debug/elf",
+	"elf.STT_FUNC":                                  "debug/elf",
+	"elf.STT_HIOS":                                  "debug/elf",
+	"elf.STT_HIPROC":                                "debug/elf",
+	"elf.STT_LOOS":                                  "debug/elf",
+	"elf.STT_LOPROC":                                "debug/elf",
+	"elf.STT_NOTYPE":                                "debug/elf",
+	"elf.STT_OBJECT":                                "debug/elf",
+	"elf.STT_SECTION":                               "debug/elf",
+	"elf.STT_TLS":                                   "debug/elf",
+	"elf.STV_DEFAULT":                               "debug/elf",
+	"elf.STV_HIDDEN":                                "debug/elf",
+	"elf.STV_INTERNAL":                              "debug/elf",
+	"elf.STV_PROTECTED":                             "debug/elf",
+	"elf.ST_BIND":                                   "debug/elf",
+	"elf.ST_INFO":                                   "debug/elf",
+	"elf.ST_TYPE":                                   "debug/elf",
+	"elf.ST_VISIBILITY":                             "debug/elf",
+	"elf.Section":                                   "debug/elf",
+	"elf.Section32":                                 "debug/elf",
+	"elf.Section64":                                 "debug/elf",
+	"elf.SectionFlag":                               "debug/elf",
+	"elf.SectionHeader":                             "debug/elf",
+	"elf.SectionIndex":                              "debug/elf",
+	"elf.SectionType":                               "debug/elf",
+	"elf.Sym32":                                     "debug/elf",
+	"elf.Sym32Size":                                 "debug/elf",
+	"elf.Sym64":                                     "debug/elf",
+	"elf.Sym64Size":                                 "debug/elf",
+	"elf.SymBind":                                   "debug/elf",
+	"elf.SymType":                                   "debug/elf",
+	"elf.SymVis":                                    "debug/elf",
+	"elf.Symbol":                                    "debug/elf",
+	"elf.Type":                                      "debug/elf",
+	"elf.Version":                                   "debug/elf",
+	"elliptic.Curve":                                "crypto/elliptic",
+	"elliptic.CurveParams":                          "crypto/elliptic",
+	"elliptic.GenerateKey":                          "crypto/elliptic",
+	"elliptic.Marshal":                              "crypto/elliptic",
+	"elliptic.P224":                                 "crypto/elliptic",
+	"elliptic.P256":                                 "crypto/elliptic",
+	"elliptic.P384":                                 "crypto/elliptic",
+	"elliptic.P521":                                 "crypto/elliptic",
+	"elliptic.Unmarshal":                            "crypto/elliptic",
+	"encoding.BinaryMarshaler":                      "encoding",
+	"encoding.BinaryUnmarshaler":                    "encoding",
+	"encoding.TextMarshaler":                        "encoding",
+	"encoding.TextUnmarshaler":                      "encoding",
+	"errors.New":                                    "errors",
+	"exec.Cmd":                                      "os/exec",
+	"exec.Command":                                  "os/exec",
+	"exec.CommandContext":                           "os/exec",
+	"exec.ErrNotFound":                              "os/exec",
+	"exec.Error":                                    "os/exec",
+	"exec.ExitError":                                "os/exec",
+	"exec.LookPath":                                 "os/exec",
+	"expvar.Do":                                     "expvar",
+	"expvar.Float":                                  "expvar",
+	"expvar.Func":                                   "expvar",
+	"expvar.Get":                                    "expvar",
+	"expvar.Handler":                                "expvar",
+	"expvar.Int":                                    "expvar",
+	"expvar.KeyValue":                               "expvar",
+	"expvar.Map":                                    "expvar",
+	"expvar.NewFloat":                               "expvar",
+	"expvar.NewInt":                                 "expvar",
+	"expvar.NewMap":                                 "expvar",
+	"expvar.NewString":                              "expvar",
+	"expvar.Publish":                                "expvar",
+	"expvar.String":                                 "expvar",
+	"expvar.Var":                                    "expvar",
+	"fcgi.ErrConnClosed":                            "net/http/fcgi",
+	"fcgi.ErrRequestAborted":                        "net/http/fcgi",
+	"fcgi.ProcessEnv":                               "net/http/fcgi",
+	"fcgi.Serve":                                    "net/http/fcgi",
+	"filepath.Abs":                                  "path/filepath",
+	"filepath.Base":                                 "path/filepath",
+	"filepath.Clean":                                "path/filepath",
+	"filepath.Dir":                                  "path/filepath",
+	"filepath.ErrBadPattern":                        "path/filepath",
+	"filepath.EvalSymlinks":                         "path/filepath",
+	"filepath.Ext":                                  "path/filepath",
+	"filepath.FromSlash":                            "path/filepath",
+	"filepath.Glob":                                 "path/filepath",
+	"filepath.HasPrefix":                            "path/filepath",
+	"filepath.IsAbs":                                "path/filepath",
+	"filepath.Join":                                 "path/filepath",
+	"filepath.ListSeparator":                        "path/filepath",
+	"filepath.Match":                                "path/filepath",
+	"filepath.Rel":                                  "path/filepath",
+	"filepath.Separator":                            "path/filepath",
+	"filepath.SkipDir":                              "path/filepath",
+	"filepath.Split":                                "path/filepath",
+	"filepath.SplitList":                            "path/filepath",
+	"filepath.ToSlash":                              "path/filepath",
+	"filepath.VolumeName":                           "path/filepath",
+	"filepath.Walk":                                 "path/filepath",
+	"filepath.WalkFunc":                             "path/filepath",
+	"flag.Arg":                                      "flag",
+	"flag.Args":                                     "flag",
+	"flag.Bool":                                     "flag",
+	"flag.BoolVar":                                  "flag",
+	"flag.CommandLine":                              "flag",
+	"flag.ContinueOnError":                          "flag",
+	"flag.Duration":                                 "flag",
+	"flag.DurationVar":                              "flag",
+	"flag.ErrHelp":                                  "flag",
+	"flag.ErrorHandling":                            "flag",
+	"flag.ExitOnError":                              "flag",
+	"flag.Flag":                                     "flag",
+	"flag.FlagSet":                                  "flag",
+	"flag.Float64":                                  "flag",
+	"flag.Float64Var":                               "flag",
+	"flag.Getter":                                   "flag",
+	"flag.Int":                                      "flag",
+	"flag.Int64":                                    "flag",
+	"flag.Int64Var":                                 "flag",
+	"flag.IntVar":                                   "flag",
+	"flag.Lookup":                                   "flag",
+	"flag.NArg":                                     "flag",
+	"flag.NFlag":                                    "flag",
+	"flag.NewFlagSet":                               "flag",
+	"flag.PanicOnError":                             "flag",
+	"flag.Parse":                                    "flag",
+	"flag.Parsed":                                   "flag",
+	"flag.PrintDefaults":                            "flag",
+	"flag.Set":                                      "flag",
+	"flag.String":                                   "flag",
+	"flag.StringVar":                                "flag",
+	"flag.Uint":                                     "flag",
+	"flag.Uint64":                                   "flag",
+	"flag.Uint64Var":                                "flag",
+	"flag.UintVar":                                  "flag",
+	"flag.UnquoteUsage":                             "flag",
+	"flag.Usage":                                    "flag",
+	"flag.Value":                                    "flag",
+	"flag.Var":                                      "flag",
+	"flag.Visit":                                    "flag",
+	"flag.VisitAll":                                 "flag",
+	"flate.BestCompression":                         "compress/flate",
+	"flate.BestSpeed":                               "compress/flate",
+	"flate.CorruptInputError":                       "compress/flate",
+	"flate.DefaultCompression":                      "compress/flate",
+	"flate.HuffmanOnly":                             "compress/flate",
+	"flate.InternalError":                           "compress/flate",
+	"flate.NewReader":                               "compress/flate",
+	"flate.NewReaderDict":                           "compress/flate",
+	"flate.NewWriter":                               "compress/flate",
+	"flate.NewWriterDict":                           "compress/flate",
+	"flate.NoCompression":                           "compress/flate",
+	"flate.ReadError":                               "compress/flate",
+	"flate.Reader":                                  "compress/flate",
+	"flate.Resetter":                                "compress/flate",
+	"flate.WriteError":                              "compress/flate",
+	"flate.Writer":                                  "compress/flate",
+	"fmt.Errorf":                                    "fmt",
+	"fmt.Formatter":                                 "fmt",
+	"fmt.Fprint":                                    "fmt",
+	"fmt.Fprintf":                                   "fmt",
+	"fmt.Fprintln":                                  "fmt",
+	"fmt.Fscan":                                     "fmt",
+	"fmt.Fscanf":                                    "fmt",
+	"fmt.Fscanln":                                   "fmt",
+	"fmt.GoStringer":                                "fmt",
+	"fmt.Print":                                     "fmt",
+	"fmt.Printf":                                    "fmt",
+	"fmt.Println":                                   "fmt",
+	"fmt.Scan":                                      "fmt",
+	"fmt.ScanState":                                 "fmt",
+	"fmt.Scanf":                                     "fmt",
+	"fmt.Scanln":                                    "fmt",
+	"fmt.Scanner":                                   "fmt",
+	"fmt.Sprint":                                    "fmt",
+	"fmt.Sprintf":                                   "fmt",
+	"fmt.Sprintln":                                  "fmt",
+	"fmt.Sscan":                                     "fmt",
+	"fmt.Sscanf":                                    "fmt",
+	"fmt.Sscanln":                                   "fmt",
+	"fmt.State":                                     "fmt",
+	"fmt.Stringer":                                  "fmt",
+	"fnv.New128":                                    "hash/fnv",
+	"fnv.New128a":                                   "hash/fnv",
+	"fnv.New32":                                     "hash/fnv",
+	"fnv.New32a":                                    "hash/fnv",
+	"fnv.New64":                                     "hash/fnv",
+	"fnv.New64a":                                    "hash/fnv",
+	"format.Node":                                   "go/format",
+	"format.Source":                                 "go/format",
+	"gif.Decode":                                    "image/gif",
+	"gif.DecodeAll":                                 "image/gif",
+	"gif.DecodeConfig":                              "image/gif",
+	"gif.DisposalBackground":                        "image/gif",
+	"gif.DisposalNone":                              "image/gif",
+	"gif.DisposalPrevious":                          "image/gif",
+	"gif.Encode":                                    "image/gif",
+	"gif.EncodeAll":                                 "image/gif",
+	"gif.GIF":                                       "image/gif",
+	"gif.Options":                                   "image/gif",
+	"gob.CommonType":                                "encoding/gob",
+	"gob.Decoder":                                   "encoding/gob",
+	"gob.Encoder":                                   "encoding/gob",
+	"gob.GobDecoder":                                "encoding/gob",
+	"gob.GobEncoder":                                "encoding/gob",
+	"gob.NewDecoder":                                "encoding/gob",
+	"gob.NewEncoder":                                "encoding/gob",
+	"gob.Register":                                  "encoding/gob",
+	"gob.RegisterName":                              "encoding/gob",
+	"gosym.DecodingError":                           "debug/gosym",
+	"gosym.Func":                                    "debug/gosym",
+	"gosym.LineTable":                               "debug/gosym",
+	"gosym.NewLineTable":                            "debug/gosym",
+	"gosym.NewTable":                                "debug/gosym",
+	"gosym.Obj":                                     "debug/gosym",
+	"gosym.Sym":                                     "debug/gosym",
+	"gosym.Table":                                   "debug/gosym",
+	"gosym.UnknownFileError":                        "debug/gosym",
+	"gosym.UnknownLineError":                        "debug/gosym",
+	"gzip.BestCompression":                          "compress/gzip",
+	"gzip.BestSpeed":                                "compress/gzip",
+	"gzip.DefaultCompression":                       "compress/gzip",
+	"gzip.ErrChecksum":                              "compress/gzip",
+	"gzip.ErrHeader":                                "compress/gzip",
+	"gzip.Header":                                   "compress/gzip",
+	"gzip.HuffmanOnly":                              "compress/gzip",
+	"gzip.NewReader":                                "compress/gzip",
+	"gzip.NewWriter":                                "compress/gzip",
+	"gzip.NewWriterLevel":                           "compress/gzip",
+	"gzip.NoCompression":                            "compress/gzip",
+	"gzip.Reader":                                   "compress/gzip",
+	"gzip.Writer":                                   "compress/gzip",
+	"hash.Hash":                                     "hash",
+	"hash.Hash32":                                   "hash",
+	"hash.Hash64":                                   "hash",
+	"heap.Fix":                                      "container/heap",
+	"heap.Init":                                     "container/heap",
+	"heap.Interface":                                "container/heap",
+	"heap.Pop":                                      "container/heap",
+	"heap.Push":                                     "container/heap",
+	"heap.Remove":                                   "container/heap",
+	"hex.Decode":                                    "encoding/hex",
+	"hex.DecodeString":                              "encoding/hex",
+	"hex.DecodedLen":                                "encoding/hex",
+	"hex.Dump":                                      "encoding/hex",
+	"hex.Dumper":                                    "encoding/hex",
+	"hex.Encode":                                    "encoding/hex",
+	"hex.EncodeToString":                            "encoding/hex",
+	"hex.EncodedLen":                                "encoding/hex",
+	"hex.ErrLength":                                 "encoding/hex",
+	"hex.InvalidByteError":                          "encoding/hex",
+	"hmac.Equal":                                    "crypto/hmac",
+	"hmac.New":                                      "crypto/hmac",
+	"html.EscapeString":                             "html",
+	"html.UnescapeString":                           "html",
+	"http.CanonicalHeaderKey":                       "net/http",
+	"http.Client":                                   "net/http",
+	"http.CloseNotifier":                            "net/http",
+	"http.ConnState":                                "net/http",
+	"http.Cookie":                                   "net/http",
+	"http.CookieJar":                                "net/http",
+	"http.DefaultClient":                            "net/http",
+	"http.DefaultMaxHeaderBytes":                    "net/http",
+	"http.DefaultMaxIdleConnsPerHost":               "net/http",
+	"http.DefaultServeMux":                          "net/http",
+	"http.DefaultTransport":                         "net/http",
+	"http.DetectContentType":                        "net/http",
+	"http.Dir":                                      "net/http",
+	"http.ErrAbortHandler":                          "net/http",
+	"http.ErrBodyNotAllowed":                        "net/http",
+	"http.ErrBodyReadAfterClose":                    "net/http",
+	"http.ErrContentLength":                         "net/http",
+	"http.ErrHandlerTimeout":                        "net/http",
+	"http.ErrHeaderTooLong":                         "net/http",
+	"http.ErrHijacked":                              "net/http",
+	"http.ErrLineTooLong":                           "net/http",
+	"http.ErrMissingBoundary":                       "net/http",
+	"http.ErrMissingContentLength":                  "net/http",
+	"http.ErrMissingFile":                           "net/http",
+	"http.ErrNoCookie":                              "net/http",
+	"http.ErrNoLocation":                            "net/http",
+	"http.ErrNotMultipart":                          "net/http",
+	"http.ErrNotSupported":                          "net/http",
+	"http.ErrServerClosed":                          "net/http",
+	"http.ErrShortBody":                             "net/http",
+	"http.ErrSkipAltProtocol":                       "net/http",
+	"http.ErrUnexpectedTrailer":                     "net/http",
+	"http.ErrUseLastResponse":                       "net/http",
+	"http.ErrWriteAfterFlush":                       "net/http",
+	"http.Error":                                    "net/http",
+	"http.File":                                     "net/http",
+	"http.FileServer":                               "net/http",
+	"http.FileSystem":                               "net/http",
+	"http.Flusher":                                  "net/http",
+	"http.Get":                                      "net/http",
+	"http.Handle":                                   "net/http",
+	"http.HandleFunc":                               "net/http",
+	"http.Handler":                                  "net/http",
+	"http.HandlerFunc":                              "net/http",
+	"http.Head":                                     "net/http",
+	"http.Header":                                   "net/http",
+	"http.Hijacker":                                 "net/http",
+	"http.ListenAndServe":                           "net/http",
+	"http.ListenAndServeTLS":                        "net/http",
+	"http.LocalAddrContextKey":                      "net/http",
+	"http.MaxBytesReader":                           "net/http",
+	"http.MethodConnect":                            "net/http",
+	"http.MethodDelete":                             "net/http",
+	"http.MethodGet":                                "net/http",
+	"http.MethodHead":                               "net/http",
+	"http.MethodOptions":                            "net/http",
+	"http.MethodPatch":                              "net/http",
+	"http.MethodPost":                               "net/http",
+	"http.MethodPut":                                "net/http",
+	"http.MethodTrace":                              "net/http",
+	"http.NewFileTransport":                         "net/http",
+	"http.NewRequest":                               "net/http",
+	"http.NewServeMux":                              "net/http",
+	"http.NoBody":                                   "net/http",
+	"http.NotFound":                                 "net/http",
+	"http.NotFoundHandler":                          "net/http",
+	"http.ParseHTTPVersion":                         "net/http",
+	"http.ParseTime":                                "net/http",
+	"http.Post":                                     "net/http",
+	"http.PostForm":                                 "net/http",
+	"http.ProtocolError":                            "net/http",
+	"http.ProxyFromEnvironment":                     "net/http",
+	"http.ProxyURL":                                 "net/http",
+	"http.PushOptions":                              "net/http",
+	"http.Pusher":                                   "net/http",
+	"http.ReadRequest":                              "net/http",
+	"http.ReadResponse":                             "net/http",
+	"http.Redirect":                                 "net/http",
+	"http.RedirectHandler":                          "net/http",
+	"http.Request":                                  "net/http",
+	"http.Response":                                 "net/http",
+	"http.ResponseWriter":                           "net/http",
+	"http.RoundTripper":                             "net/http",
+	"http.Serve":                                    "net/http",
+	"http.ServeContent":                             "net/http",
+	"http.ServeFile":                                "net/http",
+	"http.ServeMux":                                 "net/http",
+	"http.ServeTLS":                                 "net/http",
+	"http.Server":                                   "net/http",
+	"http.ServerContextKey":                         "net/http",
+	"http.SetCookie":                                "net/http",
+	"http.StateActive":                              "net/http",
+	"http.StateClosed":                              "net/http",
+	"http.StateHijacked":                            "net/http",
+	"http.StateIdle":                                "net/http",
+	"http.StateNew":                                 "net/http",
+	"http.StatusAccepted":                           "net/http",
+	"http.StatusAlreadyReported":                    "net/http",
+	"http.StatusBadGateway":                         "net/http",
+	"http.StatusBadRequest":                         "net/http",
+	"http.StatusConflict":                           "net/http",
+	"http.StatusContinue":                           "net/http",
+	"http.StatusCreated":                            "net/http",
+	"http.StatusExpectationFailed":                  "net/http",
+	"http.StatusFailedDependency":                   "net/http",
+	"http.StatusForbidden":                          "net/http",
+	"http.StatusFound":                              "net/http",
+	"http.StatusGatewayTimeout":                     "net/http",
+	"http.StatusGone":                               "net/http",
+	"http.StatusHTTPVersionNotSupported":            "net/http",
+	"http.StatusIMUsed":                             "net/http",
+	"http.StatusInsufficientStorage":                "net/http",
+	"http.StatusInternalServerError":                "net/http",
+	"http.StatusLengthRequired":                     "net/http",
+	"http.StatusLocked":                             "net/http",
+	"http.StatusLoopDetected":                       "net/http",
+	"http.StatusMethodNotAllowed":                   "net/http",
+	"http.StatusMovedPermanently":                   "net/http",
+	"http.StatusMultiStatus":                        "net/http",
+	"http.StatusMultipleChoices":                    "net/http",
+	"http.StatusNetworkAuthenticationRequired":      "net/http",
+	"http.StatusNoContent":                          "net/http",
+	"http.StatusNonAuthoritativeInfo":               "net/http",
+	"http.StatusNotAcceptable":                      "net/http",
+	"http.StatusNotExtended":                        "net/http",
+	"http.StatusNotFound":                           "net/http",
+	"http.StatusNotImplemented":                     "net/http",
+	"http.StatusNotModified":                        "net/http",
+	"http.StatusOK":                                 "net/http",
+	"http.StatusPartialContent":                     "net/http",
+	"http.StatusPaymentRequired":                    "net/http",
+	"http.StatusPermanentRedirect":                  "net/http",
+	"http.StatusPreconditionFailed":                 "net/http",
+	"http.StatusPreconditionRequired":               "net/http",
+	"http.StatusProcessing":                         "net/http",
+	"http.StatusProxyAuthRequired":                  "net/http",
+	"http.StatusRequestEntityTooLarge":              "net/http",
+	"http.StatusRequestHeaderFieldsTooLarge":        "net/http",
+	"http.StatusRequestTimeout":                     "net/http",
+	"http.StatusRequestURITooLong":                  "net/http",
+	"http.StatusRequestedRangeNotSatisfiable":       "net/http",
+	"http.StatusResetContent":                       "net/http",
+	"http.StatusSeeOther":                           "net/http",
+	"http.StatusServiceUnavailable":                 "net/http",
+	"http.StatusSwitchingProtocols":                 "net/http",
+	"http.StatusTeapot":                             "net/http",
+	"http.StatusTemporaryRedirect":                  "net/http",
+	"http.StatusText":                               "net/http",
+	"http.StatusTooManyRequests":                    "net/http",
+	"http.StatusUnauthorized":                       "net/http",
+	"http.StatusUnavailableForLegalReasons":         "net/http",
+	"http.StatusUnprocessableEntity":                "net/http",
+	"http.StatusUnsupportedMediaType":               "net/http",
+	"http.StatusUpgradeRequired":                    "net/http",
+	"http.StatusUseProxy":                           "net/http",
+	"http.StatusVariantAlsoNegotiates":              "net/http",
+	"http.StripPrefix":                              "net/http",
+	"http.TimeFormat":                               "net/http",
+	"http.TimeoutHandler":                           "net/http",
+	"http.TrailerPrefix":                            "net/http",
+	"http.Transport":                                "net/http",
+	"httptest.DefaultRemoteAddr":                    "net/http/httptest",
+	"httptest.NewRecorder":                          "net/http/httptest",
+	"httptest.NewRequest":                           "net/http/httptest",
+	"httptest.NewServer":                            "net/http/httptest",
+	"httptest.NewTLSServer":                         "net/http/httptest",
+	"httptest.NewUnstartedServer":                   "net/http/httptest",
+	"httptest.ResponseRecorder":                     "net/http/httptest",
+	"httptest.Server":                               "net/http/httptest",
+	"httptrace.ClientTrace":                         "net/http/httptrace",
+	"httptrace.ContextClientTrace":                  "net/http/httptrace",
+	"httptrace.DNSDoneInfo":                         "net/http/httptrace",
+	"httptrace.DNSStartInfo":                        "net/http/httptrace",
+	"httptrace.GotConnInfo":                         "net/http/httptrace",
+	"httptrace.WithClientTrace":                     "net/http/httptrace",
+	"httptrace.WroteRequestInfo":                    "net/http/httptrace",
+	"httputil.BufferPool":                           "net/http/httputil",
+	"httputil.ClientConn":                           "net/http/httputil",
+	"httputil.DumpRequest":                          "net/http/httputil",
+	"httputil.DumpRequestOut":                       "net/http/httputil",
+	"httputil.DumpResponse":                         "net/http/httputil",
+	"httputil.ErrClosed":                            "net/http/httputil",
+	"httputil.ErrLineTooLong":                       "net/http/httputil",
+	"httputil.ErrPersistEOF":                        "net/http/httputil",
+	"httputil.ErrPipeline":                          "net/http/httputil",
+	"httputil.NewChunkedReader":                     "net/http/httputil",
+	"httputil.NewChunkedWriter":                     "net/http/httputil",
+	"httputil.NewClientConn":                        "net/http/httputil",
+	"httputil.NewProxyClientConn":                   "net/http/httputil",
+	"httputil.NewServerConn":                        "net/http/httputil",
+	"httputil.NewSingleHostReverseProxy":            "net/http/httputil",
+	"httputil.ReverseProxy":                         "net/http/httputil",
+	"httputil.ServerConn":                           "net/http/httputil",
+	"image.Alpha":                                   "image",
+	"image.Alpha16":                                 "image",
+	"image.Black":                                   "image",
+	"image.CMYK":                                    "image",
+	"image.Config":                                  "image",
+	"image.Decode":                                  "image",
+	"image.DecodeConfig":                            "image",
+	"image.ErrFormat":                               "image",
+	"image.Gray":                                    "image",
+	"image.Gray16":                                  "image",
+	"image.Image":                                   "image",
+	"image.NRGBA":                                   "image",
+	"image.NRGBA64":                                 "image",
+	"image.NYCbCrA":                                 "image",
+	"image.NewAlpha":                                "image",
+	"image.NewAlpha16":                              "image",
+	"image.NewCMYK":                                 "image",
+	"image.NewGray":                                 "image",
+	"image.NewGray16":                               "image",
+	"image.NewNRGBA":                                "image",
+	"image.NewNRGBA64":                              "image",
+	"image.NewNYCbCrA":                              "image",
+	"image.NewPaletted":                             "image",
+	"image.NewRGBA":                                 "image",
+	"image.NewRGBA64":                               "image",
+	"image.NewUniform":                              "image",
+	"image.NewYCbCr":                                "image",
+	"image.Opaque":                                  "image",
+	"image.Paletted":                                "image",
+	"image.PalettedImage":                           "image",
+	"image.Point":                                   "image",
+	"image.Pt":                                      "image",
+	"image.RGBA":                                    "image",
+	"image.RGBA64":                                  "image",
+	"image.Rect":                                    "image",
+	"image.Rectangle":                               "image",
+	"image.RegisterFormat":                          "image",
+	"image.Transparent":                             "image",
+	"image.Uniform":                                 "image",
+	"image.White":                                   "image",
+	"image.YCbCr":                                   "image",
+	"image.YCbCrSubsampleRatio":                     "image",
+	"image.YCbCrSubsampleRatio410":                  "image",
+	"image.YCbCrSubsampleRatio411":                  "image",
+	"image.YCbCrSubsampleRatio420":                  "image",
+	"image.YCbCrSubsampleRatio422":                  "image",
+	"image.YCbCrSubsampleRatio440":                  "image",
+	"image.YCbCrSubsampleRatio444":                  "image",
+	"image.ZP":                                      "image",
+	"image.ZR":                                      "image",
+	"importer.Default":                              "go/importer",
+	"importer.For":                                  "go/importer",
+	"importer.Lookup":                               "go/importer",
+	"io.ByteReader":                                 "io",
+	"io.ByteScanner":                                "io",
+	"io.ByteWriter":                                 "io",
+	"io.Closer":                                     "io",
+	"io.Copy":                                       "io",
+	"io.CopyBuffer":                                 "io",
+	"io.CopyN":                                      "io",
+	"io.EOF":                                        "io",
+	"io.ErrClosedPipe":                              "io",
+	"io.ErrNoProgress":                              "io",
+	"io.ErrShortBuffer":                             "io",
+	"io.ErrShortWrite":                              "io",
+	"io.ErrUnexpectedEOF":                           "io",
+	"io.LimitReader":                                "io",
+	"io.LimitedReader":                              "io",
+	"io.MultiReader":                                "io",
+	"io.MultiWriter":                                "io",
+	"io.NewSectionReader":                           "io",
+	"io.Pipe":                                       "io",
+	"io.PipeReader":                                 "io",
+	"io.PipeWriter":                                 "io",
+	"io.ReadAtLeast":                                "io",
+	"io.ReadCloser":                                 "io",
+	"io.ReadFull":                                   "io",
+	"io.ReadSeeker":                                 "io",
+	"io.ReadWriteCloser":                            "io",
+	"io.ReadWriteSeeker":                            "io",
+	"io.ReadWriter":                                 "io",
+	"io.Reader":                                     "io",
+	"io.ReaderAt":                                   "io",
+	"io.ReaderFrom":                                 "io",
+	"io.RuneReader":                                 "io",
+	"io.RuneScanner":                                "io",
+	"io.SectionReader":                              "io",
+	"io.SeekCurrent":                                "io",
+	"io.SeekEnd":                                    "io",
+	"io.SeekStart":                                  "io",
+	"io.Seeker":                                     "io",
+	"io.TeeReader":                                  "io",
+	"io.WriteCloser":                                "io",
+	"io.WriteSeeker":                                "io",
+	"io.WriteString":                                "io",
+	"io.Writer":                                     "io",
+	"io.WriterAt":                                   "io",
+	"io.WriterTo":                                   "io",
+	"iotest.DataErrReader":                          "testing/iotest",
+	"iotest.ErrTimeout":                             "testing/iotest",
+	"iotest.HalfReader":                             "testing/iotest",
+	"iotest.NewReadLogger":                          "testing/iotest",
+	"iotest.NewWriteLogger":                         "testing/iotest",
+	"iotest.OneByteReader":                          "testing/iotest",
+	"iotest.TimeoutReader":                          "testing/iotest",
+	"iotest.TruncateWriter":                         "testing/iotest",
+	"ioutil.Discard":                                "io/ioutil",
+	"ioutil.NopCloser":                              "io/ioutil",
+	"ioutil.ReadAll":                                "io/ioutil",
+	"ioutil.ReadDir":                                "io/ioutil",
+	"ioutil.ReadFile":                               "io/ioutil",
+	"ioutil.TempDir":                                "io/ioutil",
+	"ioutil.TempFile":                               "io/ioutil",
+	"ioutil.WriteFile":                              "io/ioutil",
+	"jpeg.Decode":                                   "image/jpeg",
+	"jpeg.DecodeConfig":                             "image/jpeg",
+	"jpeg.DefaultQuality":                           "image/jpeg",
+	"jpeg.Encode":                                   "image/jpeg",
+	"jpeg.FormatError":                              "image/jpeg",
+	"jpeg.Options":                                  "image/jpeg",
+	"jpeg.Reader":                                   "image/jpeg",
+	"jpeg.UnsupportedError":                         "image/jpeg",
+	"json.Compact":                                  "encoding/json",
+	"json.Decoder":                                  "encoding/json",
+	"json.Delim":                                    "encoding/json",
+	"json.Encoder":                                  "encoding/json",
+	"json.HTMLEscape":                               "encoding/json",
+	"json.Indent":                                   "encoding/json",
+	"json.InvalidUTF8Error":                         "encoding/json",
+	"json.InvalidUnmarshalError":                    "encoding/json",
+	"json.Marshal":                                  "encoding/json",
+	"json.MarshalIndent":                            "encoding/json",
+	"json.Marshaler":                                "encoding/json",
+	"json.MarshalerError":                           "encoding/json",
+	"json.NewDecoder":                               "encoding/json",
+	"json.NewEncoder":                               "encoding/json",
+	"json.Number":                                   "encoding/json",
+	"json.RawMessage":                               "encoding/json",
+	"json.SyntaxError":                              "encoding/json",
+	"json.Token":                                    "encoding/json",
+	"json.Unmarshal":                                "encoding/json",
+	"json.UnmarshalFieldError":                      "encoding/json",
+	"json.UnmarshalTypeError":                       "encoding/json",
+	"json.Unmarshaler":                              "encoding/json",
+	"json.UnsupportedTypeError":                     "encoding/json",
+	"json.UnsupportedValueError":                    "encoding/json",
+	"json.Valid":                                    "encoding/json",
+	"jsonrpc.Dial":                                  "net/rpc/jsonrpc",
+	"jsonrpc.NewClient":                             "net/rpc/jsonrpc",
+	"jsonrpc.NewClientCodec":                        "net/rpc/jsonrpc",
+	"jsonrpc.NewServerCodec":                        "net/rpc/jsonrpc",
+	"jsonrpc.ServeConn":                             "net/rpc/jsonrpc",
+	"list.Element":                                  "container/list",
+	"list.List":                                     "container/list",
+	"list.New":                                      "container/list",
+	"log.Fatal":                                     "log",
+	"log.Fatalf":                                    "log",
+	"log.Fatalln":                                   "log",
+	"log.Flags":                                     "log",
+	"log.LUTC":                                      "log",
+	"log.Ldate":                                     "log",
+	"log.Llongfile":                                 "log",
+	"log.Lmicroseconds":                             "log",
+	"log.Logger":                                    "log",
+	"log.Lshortfile":                                "log",
+	"log.LstdFlags":                                 "log",
+	"log.Ltime":                                     "log",
+	"log.New":                                       "log",
+	"log.Output":                                    "log",
+	"log.Panic":                                     "log",
+	"log.Panicf":                                    "log",
+	"log.Panicln":                                   "log",
+	"log.Prefix":                                    "log",
+	"log.Print":                                     "log",
+	"log.Printf":                                    "log",
+	"log.Println":                                   "log",
+	"log.SetFlags":                                  "log",
+	"log.SetOutput":                                 "log",
+	"log.SetPrefix":                                 "log",
+	"lzw.LSB":                                       "compress/lzw",
+	"lzw.MSB":                                       "compress/lzw",
+	"lzw.NewReader":                                 "compress/lzw",
+	"lzw.NewWriter":                                 "compress/lzw",
+	"lzw.Order":                                     "compress/lzw",
+	"macho.Cpu":                                     "debug/macho",
+	"macho.Cpu386":                                  "debug/macho",
+	"macho.CpuAmd64":                                "debug/macho",
+	"macho.CpuArm":                                  "debug/macho",
+	"macho.CpuPpc":                                  "debug/macho",
+	"macho.CpuPpc64":                                "debug/macho",
+	"macho.Dylib":                                   "debug/macho",
+	"macho.DylibCmd":                                "debug/macho",
+	"macho.Dysymtab":                                "debug/macho",
+	"macho.DysymtabCmd":                             "debug/macho",
+	"macho.ErrNotFat":                               "debug/macho",
+	"macho.FatArch":                                 "debug/macho",
+	"macho.FatArchHeader":                           "debug/macho",
+	"macho.FatFile":                                 "debug/macho",
+	"macho.File":                                    "debug/macho",
+	"macho.FileHeader":                              "debug/macho",
+	"macho.FormatError":                             "debug/macho",
+	"macho.Load":                                    "debug/macho",
+	"macho.LoadBytes":                               "debug/macho",
+	"macho.LoadCmd":                                 "debug/macho",
+	"macho.LoadCmdDylib":                            "debug/macho",
+	"macho.LoadCmdDylinker":                         "debug/macho",
+	"macho.LoadCmdDysymtab":                         "debug/macho",
+	"macho.LoadCmdSegment":                          "debug/macho",
+	"macho.LoadCmdSegment64":                        "debug/macho",
+	"macho.LoadCmdSymtab":                           "debug/macho",
+	"macho.LoadCmdThread":                           "debug/macho",
+	"macho.LoadCmdUnixThread":                       "debug/macho",
+	"macho.Magic32":                                 "debug/macho",
+	"macho.Magic64":                                 "debug/macho",
+	"macho.MagicFat":                                "debug/macho",
+	"macho.NewFatFile":                              "debug/macho",
+	"macho.NewFile":                                 "debug/macho",
+	"macho.Nlist32":                                 "debug/macho",
+	"macho.Nlist64":                                 "debug/macho",
+	"macho.Open":                                    "debug/macho",
+	"macho.OpenFat":                                 "debug/macho",
+	"macho.Regs386":                                 "debug/macho",
+	"macho.RegsAMD64":                               "debug/macho",
+	"macho.Section":                                 "debug/macho",
+	"macho.Section32":                               "debug/macho",
+	"macho.Section64":                               "debug/macho",
+	"macho.SectionHeader":                           "debug/macho",
+	"macho.Segment":                                 "debug/macho",
+	"macho.Segment32":                               "debug/macho",
+	"macho.Segment64":                               "debug/macho",
+	"macho.SegmentHeader":                           "debug/macho",
+	"macho.Symbol":                                  "debug/macho",
+	"macho.Symtab":                                  "debug/macho",
+	"macho.SymtabCmd":                               "debug/macho",
+	"macho.Thread":                                  "debug/macho",
+	"macho.Type":                                    "debug/macho",
+	"macho.TypeBundle":                              "debug/macho",
+	"macho.TypeDylib":                               "debug/macho",
+	"macho.TypeExec":                                "debug/macho",
+	"macho.TypeObj":                                 "debug/macho",
+	"mail.Address":                                  "net/mail",
+	"mail.AddressParser":                            "net/mail",
+	"mail.ErrHeaderNotPresent":                      "net/mail",
+	"mail.Header":                                   "net/mail",
+	"mail.Message":                                  "net/mail",
+	"mail.ParseAddress":                             "net/mail",
+	"mail.ParseAddressList":                         "net/mail",
+	"mail.ParseDate":                                "net/mail",
+	"mail.ReadMessage":                              "net/mail",
+	"math.Abs":                                      "math",
+	"math.Acos":                                     "math",
+	"math.Acosh":                                    "math",
+	"math.Asin":                                     "math",
+	"math.Asinh":                                    "math",
+	"math.Atan":                                     "math",
+	"math.Atan2":                                    "math",
+	"math.Atanh":                                    "math",
+	"math.Cbrt":                                     "math",
+	"math.Ceil":                                     "math",
+	"math.Copysign":                                 "math",
+	"math.Cos":                                      "math",
+	"math.Cosh":                                     "math",
+	"math.Dim":                                      "math",
+	"math.E":                                        "math",
+	"math.Erf":                                      "math",
+	"math.Erfc":                                     "math",
+	"math.Exp":                                      "math",
+	"math.Exp2":                                     "math",
+	"math.Expm1":                                    "math",
+	"math.Float32bits":                              "math",
+	"math.Float32frombits":                          "math",
+	"math.Float64bits":                              "math",
+	"math.Float64frombits":                          "math",
+	"math.Floor":                                    "math",
+	"math.Frexp":                                    "math",
+	"math.Gamma":                                    "math",
+	"math.Hypot":                                    "math",
+	"math.Ilogb":                                    "math",
+	"math.Inf":                                      "math",
+	"math.IsInf":                                    "math",
+	"math.IsNaN":                                    "math",
+	"math.J0":                                       "math",
+	"math.J1":                                       "math",
+	"math.Jn":                                       "math",
+	"math.Ldexp":                                    "math",
+	"math.Lgamma":                                   "math",
+	"math.Ln10":                                     "math",
+	"math.Ln2":                                      "math",
+	"math.Log":                                      "math",
+	"math.Log10":                                    "math",
+	"math.Log10E":                                   "math",
+	"math.Log1p":                                    "math",
+	"math.Log2":                                     "math",
+	"math.Log2E":                                    "math",
+	"math.Logb":                                     "math",
+	"math.Max":                                      "math",
+	"math.MaxFloat32":                               "math",
+	"math.MaxFloat64":                               "math",
+	"math.MaxInt16":                                 "math",
+	"math.MaxInt32":                                 "math",
+	"math.MaxInt64":                                 "math",
+	"math.MaxInt8":                                  "math",
+	"math.MaxUint16":                                "math",
+	"math.MaxUint32":                                "math",
+	"math.MaxUint64":                                "math",
+	"math.MaxUint8":                                 "math",
+	"math.Min":                                      "math",
+	"math.MinInt16":                                 "math",
+	"math.MinInt32":                                 "math",
+	"math.MinInt64":                                 "math",
+	"math.MinInt8":                                  "math",
+	"math.Mod":                                      "math",
+	"math.Modf":                                     "math",
+	"math.NaN":                                      "math",
+	"math.Nextafter":                                "math",
+	"math.Nextafter32":                              "math",
+	"math.Phi":                                      "math",
+	"math.Pi":                                       "math",
+	"math.Pow":                                      "math",
+	"math.Pow10":                                    "math",
+	"math.Remainder":                                "math",
+	"math.Signbit":                                  "math",
+	"math.Sin":                                      "math",
+	"math.Sincos":                                   "math",
+	"math.Sinh":                                     "math",
+	"math.SmallestNonzeroFloat32":                   "math",
+	"math.SmallestNonzeroFloat64":                   "math",
+	"math.Sqrt":                                     "math",
+	"math.Sqrt2":                                    "math",
+	"math.SqrtE":                                    "math",
+	"math.SqrtPhi":                                  "math",
+	"math.SqrtPi":                                   "math",
+	"math.Tan":                                      "math",
+	"math.Tanh":                                     "math",
+	"math.Trunc":                                    "math",
+	"math.Y0":                                       "math",
+	"math.Y1":                                       "math",
+	"math.Yn":                                       "math",
+	"md5.BlockSize":                                 "crypto/md5",
+	"md5.New":                                       "crypto/md5",
+	"md5.Size":                                      "crypto/md5",
+	"md5.Sum":                                       "crypto/md5",
+	"mime.AddExtensionType":                         "mime",
+	"mime.BEncoding":                                "mime",
+	"mime.ErrInvalidMediaParameter":                 "mime",
+	"mime.ExtensionsByType":                         "mime",
+	"mime.FormatMediaType":                          "mime",
+	"mime.ParseMediaType":                           "mime",
+	"mime.QEncoding":                                "mime",
+	"mime.TypeByExtension":                          "mime",
+	"mime.WordDecoder":                              "mime",
+	"mime.WordEncoder":                              "mime",
+	"multipart.ErrMessageTooLarge":                  "mime/multipart",
+	"multipart.File":                                "mime/multipart",
+	"multipart.FileHeader":                          "mime/multipart",
+	"multipart.Form":                                "mime/multipart",
+	"multipart.NewReader":                           "mime/multipart",
+	"multipart.NewWriter":                           "mime/multipart",
+	"multipart.Part":                                "mime/multipart",
+	"multipart.Reader":                              "mime/multipart",
+	"multipart.Writer":                              "mime/multipart",
+	"net.Addr":                                      "net",
+	"net.AddrError":                                 "net",
+	"net.Buffers":                                   "net",
+	"net.CIDRMask":                                  "net",
+	"net.Conn":                                      "net",
+	"net.DNSConfigError":                            "net",
+	"net.DNSError":                                  "net",
+	"net.DefaultResolver":                           "net",
+	"net.Dial":                                      "net",
+	"net.DialIP":                                    "net",
+	"net.DialTCP":                                   "net",
+	"net.DialTimeout":                               "net",
+	"net.DialUDP":                                   "net",
+	"net.DialUnix":                                  "net",
+	"net.Dialer":                                    "net",
+	"net.ErrWriteToConnected":                       "net",
+	"net.Error":                                     "net",
+	"net.FileConn":                                  "net",
+	"net.FileListener":                              "net",
+	"net.FilePacketConn":                            "net",
+	"net.FlagBroadcast":                             "net",
+	"net.FlagLoopback":                              "net",
+	"net.FlagMulticast":                             "net",
+	"net.FlagPointToPoint":                          "net",
+	"net.FlagUp":                                    "net",
+	"net.Flags":                                     "net",
+	"net.HardwareAddr":                              "net",
+	"net.IP":                                        "net",
+	"net.IPAddr":                                    "net",
+	"net.IPConn":                                    "net",
+	"net.IPMask":                                    "net",
+	"net.IPNet":                                     "net",
+	"net.IPv4":                                      "net",
+	"net.IPv4Mask":                                  "net",
+	"net.IPv4allrouter":                             "net",
+	"net.IPv4allsys":                                "net",
+	"net.IPv4bcast":                                 "net",
+	"net.IPv4len":                                   "net",
+	"net.IPv4zero":                                  "net",
+	"net.IPv6interfacelocalallnodes":                "net",
+	"net.IPv6len":                                   "net",
+	"net.IPv6linklocalallnodes":                     "net",
+	"net.IPv6linklocalallrouters":                   "net",
+	"net.IPv6loopback":                              "net",
+	"net.IPv6unspecified":                           "net",
+	"net.IPv6zero":                                  "net",
+	"net.Interface":                                 "net",
+	"net.InterfaceAddrs":                            "net",
+	"net.InterfaceByIndex":                          "net",
+	"net.InterfaceByName":                           "net",
+	"net.Interfaces":                                "net",
+	"net.InvalidAddrError":                          "net",
+	"net.JoinHostPort":                              "net",
+	"net.Listen":                                    "net",
+	"net.ListenIP":                                  "net",
+	"net.ListenMulticastUDP":                        "net",
+	"net.ListenPacket":                              "net",
+	"net.ListenTCP":                                 "net",
+	"net.ListenUDP":                                 "net",
+	"net.ListenUnix":                                "net",
+	"net.ListenUnixgram":                            "net",
+	"net.Listener":                                  "net",
+	"net.LookupAddr":                                "net",
+	"net.LookupCNAME":                               "net",
+	"net.LookupHost":                                "net",
+	"net.LookupIP":                                  "net",
+	"net.LookupMX":                                  "net",
+	"net.LookupNS":                                  "net",
+	"net.LookupPort":                                "net",
+	"net.LookupSRV":                                 "net",
+	"net.LookupTXT":                                 "net",
+	"net.MX":                                        "net",
+	"net.NS":                                        "net",
+	"net.OpError":                                   "net",
+	"net.PacketConn":                                "net",
+	"net.ParseCIDR":                                 "net",
+	"net.ParseError":                                "net",
+	"net.ParseIP":                                   "net",
+	"net.ParseMAC":                                  "net",
+	"net.Pipe":                                      "net",
+	"net.ResolveIPAddr":                             "net",
+	"net.ResolveTCPAddr":                            "net",
+	"net.ResolveUDPAddr":                            "net",
+	"net.ResolveUnixAddr":                           "net",
+	"net.Resolver":                                  "net",
+	"net.SRV":                                       "net",
+	"net.SplitHostPort":                             "net",
+	"net.TCPAddr":                                   "net",
+	"net.TCPConn":                                   "net",
+	"net.TCPListener":                               "net",
+	"net.UDPAddr":                                   "net",
+	"net.UDPConn":                                   "net",
+	"net.UnixAddr":                                  "net",
+	"net.UnixConn":                                  "net",
+	"net.UnixListener":                              "net",
+	"net.UnknownNetworkError":                       "net",
+	"os.Args":                                       "os",
+	"os.Chdir":                                      "os",
+	"os.Chmod":                                      "os",
+	"os.Chown":                                      "os",
+	"os.Chtimes":                                    "os",
+	"os.Clearenv":                                   "os",
+	"os.Create":                                     "os",
+	"os.DevNull":                                    "os",
+	"os.Environ":                                    "os",
+	"os.ErrClosed":                                  "os",
+	"os.ErrExist":                                   "os",
+	"os.ErrInvalid":                                 "os",
+	"os.ErrNotExist":                                "os",
+	"os.ErrPermission":                              "os",
+	"os.Executable":                                 "os",
+	"os.Exit":                                       "os",
+	"os.Expand":                                     "os",
+	"os.ExpandEnv":                                  "os",
+	"os.File":                                       "os",
+	"os.FileInfo":                                   "os",
+	"os.FileMode":                                   "os",
+	"os.FindProcess":                                "os",
+	"os.Getegid":                                    "os",
+	"os.Getenv":                                     "os",
+	"os.Geteuid":                                    "os",
+	"os.Getgid":                                     "os",
+	"os.Getgroups":                                  "os",
+	"os.Getpagesize":                                "os",
+	"os.Getpid":                                     "os",
+	"os.Getppid":                                    "os",
+	"os.Getuid":                                     "os",
+	"os.Getwd":                                      "os",
+	"os.Hostname":                                   "os",
+	"os.Interrupt":                                  "os",
+	"os.IsExist":                                    "os",
+	"os.IsNotExist":                                 "os",
+	"os.IsPathSeparator":                            "os",
+	"os.IsPermission":                               "os",
+	"os.Kill":                                       "os",
+	"os.Lchown":                                     "os",
+	"os.Link":                                       "os",
+	"os.LinkError":                                  "os",
+	"os.LookupEnv":                                  "os",
+	"os.Lstat":                                      "os",
+	"os.Mkdir":                                      "os",
+	"os.MkdirAll":                                   "os",
+	"os.ModeAppend":                                 "os",
+	"os.ModeCharDevice":                             "os",
+	"os.ModeDevice":                                 "os",
+	"os.ModeDir":                                    "os",
+	"os.ModeExclusive":                              "os",
+	"os.ModeNamedPipe":                              "os",
+	"os.ModePerm":                                   "os",
+	"os.ModeSetgid":                                 "os",
+	"os.ModeSetuid":                                 "os",
+	"os.ModeSocket":                                 "os",
+	"os.ModeSticky":                                 "os",
+	"os.ModeSymlink":                                "os",
+	"os.ModeTemporary":                              "os",
+	"os.ModeType":                                   "os",
+	"os.NewFile":                                    "os",
+	"os.NewSyscallError":                            "os",
+	"os.O_APPEND":                                   "os",
+	"os.O_CREATE":                                   "os",
+	"os.O_EXCL":                                     "os",
+	"os.O_RDONLY":                                   "os",
+	"os.O_RDWR":                                     "os",
+	"os.O_SYNC":                                     "os",
+	"os.O_TRUNC":                                    "os",
+	"os.O_WRONLY":                                   "os",
+	"os.Open":                                       "os",
+	"os.OpenFile":                                   "os",
+	"os.PathError":                                  "os",
+	"os.PathListSeparator":                          "os",
+	"os.PathSeparator":                              "os",
+	"os.Pipe":                                       "os",
+	"os.ProcAttr":                                   "os",
+	"os.Process":                                    "os",
+	"os.ProcessState":                               "os",
+	"os.Readlink":                                   "os",
+	"os.Remove":                                     "os",
+	"os.RemoveAll":                                  "os",
+	"os.Rename":                                     "os",
+	"os.SEEK_CUR":                                   "os",
+	"os.SEEK_END":                                   "os",
+	"os.SEEK_SET":                                   "os",
+	"os.SameFile":                                   "os",
+	"os.Setenv":                                     "os",
+	"os.Signal":                                     "os",
+	"os.StartProcess":                               "os",
+	"os.Stat":                                       "os",
+	"os.Stderr":                                     "os",
+	"os.Stdin":                                      "os",
+	"os.Stdout":                                     "os",
+	"os.Symlink":                                    "os",
+	"os.SyscallError":                               "os",
+	"os.TempDir":                                    "os",
+	"os.Truncate":                                   "os",
+	"os.Unsetenv":                                   "os",
+	"palette.Plan9":                                 "image/color/palette",
+	"palette.WebSafe":                               "image/color/palette",
+	"parse.ActionNode":                              "text/template/parse",
+	"parse.BoolNode":                                "text/template/parse",
+	"parse.BranchNode":                              "text/template/parse",
+	"parse.ChainNode":                               "text/template/parse",
+	"parse.CommandNode":                             "text/template/parse",
+	"parse.DotNode":                                 "text/template/parse",
+	"parse.FieldNode":                               "text/template/parse",
+	"parse.IdentifierNode":                          "text/template/parse",
+	"parse.IfNode":                                  "text/template/parse",
+	"parse.IsEmptyTree":                             "text/template/parse",
+	"parse.ListNode":                                "text/template/parse",
+	"parse.New":                                     "text/template/parse",
+	"parse.NewIdentifier":                           "text/template/parse",
+	"parse.NilNode":                                 "text/template/parse",
+	"parse.Node":                                    "text/template/parse",
+	"parse.NodeAction":                              "text/template/parse",
+	"parse.NodeBool":                                "text/template/parse",
+	"parse.NodeChain":                               "text/template/parse",
+	"parse.NodeCommand":                             "text/template/parse",
+	"parse.NodeDot":                                 "text/template/parse",
+	"parse.NodeField":                               "text/template/parse",
+	"parse.NodeIdentifier":                          "text/template/parse",
+	"parse.NodeIf":                                  "text/template/parse",
+	"parse.NodeList":                                "text/template/parse",
+	"parse.NodeNil":                                 "text/template/parse",
+	"parse.NodeNumber":                              "text/template/parse",
+	"parse.NodePipe":                                "text/template/parse",
+	"parse.NodeRange":                               "text/template/parse",
+	"parse.NodeString":                              "text/template/parse",
+	"parse.NodeTemplate":                            "text/template/parse",
+	"parse.NodeText":                                "text/template/parse",
+	"parse.NodeType":                                "text/template/parse",
+	"parse.NodeVariable":                            "text/template/parse",
+	"parse.NodeWith":                                "text/template/parse",
+	"parse.NumberNode":                              "text/template/parse",
+	"parse.Parse":                                   "text/template/parse",
+	"parse.PipeNode":                                "text/template/parse",
+	"parse.Pos":                                     "text/template/parse",
+	"parse.RangeNode":                               "text/template/parse",
+	"parse.StringNode":                              "text/template/parse",
+	"parse.TemplateNode":                            "text/template/parse",
+	"parse.TextNode":                                "text/template/parse",
+	"parse.Tree":                                    "text/template/parse",
+	"parse.VariableNode":                            "text/template/parse",
+	"parse.WithNode":                                "text/template/parse",
+	"parser.AllErrors":                              "go/parser",
+	"parser.DeclarationErrors":                      "go/parser",
+	"parser.ImportsOnly":                            "go/parser",
+	"parser.Mode":                                   "go/parser",
+	"parser.PackageClauseOnly":                      "go/parser",
+	"parser.ParseComments":                          "go/parser",
+	"parser.ParseDir":                               "go/parser",
+	"parser.ParseExpr":                              "go/parser",
+	"parser.ParseExprFrom":                          "go/parser",
+	"parser.ParseFile":                              "go/parser",
+	"parser.SpuriousErrors":                         "go/parser",
+	"parser.Trace":                                  "go/parser",
+	"path.Base":                                     "path",
+	"path.Clean":                                    "path",
+	"path.Dir":                                      "path",
+	"path.ErrBadPattern":                            "path",
+	"path.Ext":                                      "path",
+	"path.IsAbs":                                    "path",
+	"path.Join":                                     "path",
+	"path.Match":                                    "path",
+	"path.Split":                                    "path",
+	"pe.COFFSymbol":                                 "debug/pe",
+	"pe.COFFSymbolSize":                             "debug/pe",
+	"pe.DataDirectory":                              "debug/pe",
+	"pe.File":                                       "debug/pe",
+	"pe.FileHeader":                                 "debug/pe",
+	"pe.FormatError":                                "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_AM33":                    "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_AMD64":                   "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_ARM":                     "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_EBC":                     "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_I386":                    "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_IA64":                    "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_M32R":                    "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_MIPS16":                  "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_MIPSFPU":                 "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_MIPSFPU16":               "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_POWERPC":                 "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_POWERPCFP":               "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_R4000":                   "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_SH3":                     "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_SH3DSP":                  "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_SH4":                     "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_SH5":                     "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_THUMB":                   "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_UNKNOWN":                 "debug/pe",
+	"pe.IMAGE_FILE_MACHINE_WCEMIPSV2":               "debug/pe",
+	"pe.ImportDirectory":                            "debug/pe",
+	"pe.NewFile":                                    "debug/pe",
+	"pe.Open":                                       "debug/pe",
+	"pe.OptionalHeader32":                           "debug/pe",
+	"pe.OptionalHeader64":                           "debug/pe",
+	"pe.Reloc":                                      "debug/pe",
+	"pe.Section":                                    "debug/pe",
+	"pe.SectionHeader":                              "debug/pe",
+	"pe.SectionHeader32":                            "debug/pe",
+	"pe.StringTable":                                "debug/pe",
+	"pe.Symbol":                                     "debug/pe",
+	"pem.Block":                                     "encoding/pem",
+	"pem.Decode":                                    "encoding/pem",
+	"pem.Encode":                                    "encoding/pem",
+	"pem.EncodeToMemory":                            "encoding/pem",
+	"pkix.AlgorithmIdentifier":                      "crypto/x509/pkix",
+	"pkix.AttributeTypeAndValue":                    "crypto/x509/pkix",
+	"pkix.AttributeTypeAndValueSET":                 "crypto/x509/pkix",
+	"pkix.CertificateList":                          "crypto/x509/pkix",
+	"pkix.Extension":                                "crypto/x509/pkix",
+	"pkix.Name":                                     "crypto/x509/pkix",
+	"pkix.RDNSequence":                              "crypto/x509/pkix",
+	"pkix.RelativeDistinguishedNameSET":             "crypto/x509/pkix",
+	"pkix.RevokedCertificate":                       "crypto/x509/pkix",
+	"pkix.TBSCertificateList":                       "crypto/x509/pkix",
+	"plan9obj.File":                                 "debug/plan9obj",
+	"plan9obj.FileHeader":                           "debug/plan9obj",
+	"plan9obj.Magic386":                             "debug/plan9obj",
+	"plan9obj.Magic64":                              "debug/plan9obj",
+	"plan9obj.MagicAMD64":                           "debug/plan9obj",
+	"plan9obj.MagicARM":                             "debug/plan9obj",
+	"plan9obj.NewFile":                              "debug/plan9obj",
+	"plan9obj.Open":                                 "debug/plan9obj",
+	"plan9obj.Section":                              "debug/plan9obj",
+	"plan9obj.SectionHeader":                        "debug/plan9obj",
+	"plan9obj.Sym":                                  "debug/plan9obj",
+	"plugin.Open":                                   "plugin",
+	"plugin.Plugin":                                 "plugin",
+	"plugin.Symbol":                                 "plugin",
+	"png.BestCompression":                           "image/png",
+	"png.BestSpeed":                                 "image/png",
+	"png.CompressionLevel":                          "image/png",
+	"png.Decode":                                    "image/png",
+	"png.DecodeConfig":                              "image/png",
+	"png.DefaultCompression":                        "image/png",
+	"png.Encode":                                    "image/png",
+	"png.Encoder":                                   "image/png",
+	"png.EncoderBuffer":                             "image/png",
+	"png.EncoderBufferPool":                         "image/png",
+	"png.FormatError":                               "image/png",
+	"png.NoCompression":                             "image/png",
+	"png.UnsupportedError":                          "image/png",
+	"pprof.Cmdline":                                 "net/http/pprof",
+	"pprof.Do":                                      "runtime/pprof",
+	"pprof.ForLabels":                               "runtime/pprof",
+	"pprof.Handler":                                 "net/http/pprof",
+	"pprof.Index":                                   "net/http/pprof",
+	"pprof.Label":                                   "runtime/pprof",
+	"pprof.LabelSet":                                "runtime/pprof",
+	"pprof.Labels":                                  "runtime/pprof",
+	"pprof.Lookup":                                  "runtime/pprof",
+	"pprof.NewProfile":                              "runtime/pprof",
+	// "pprof.Profile" is ambiguous
+	"pprof.Profiles":            "runtime/pprof",
+	"pprof.SetGoroutineLabels":  "runtime/pprof",
+	"pprof.StartCPUProfile":     "runtime/pprof",
+	"pprof.StopCPUProfile":      "runtime/pprof",
+	"pprof.Symbol":              "net/http/pprof",
+	"pprof.Trace":               "net/http/pprof",
+	"pprof.WithLabels":          "runtime/pprof",
+	"pprof.WriteHeapProfile":    "runtime/pprof",
+	"printer.CommentedNode":     "go/printer",
+	"printer.Config":            "go/printer",
+	"printer.Fprint":            "go/printer",
+	"printer.Mode":              "go/printer",
+	"printer.RawFormat":         "go/printer",
+	"printer.SourcePos":         "go/printer",
+	"printer.TabIndent":         "go/printer",
+	"printer.UseSpaces":         "go/printer",
+	"quick.Check":               "testing/quick",
+	"quick.CheckEqual":          "testing/quick",
+	"quick.CheckEqualError":     "testing/quick",
+	"quick.CheckError":          "testing/quick",
+	"quick.Config":              "testing/quick",
+	"quick.Generator":           "testing/quick",
+	"quick.SetupError":          "testing/quick",
+	"quick.Value":               "testing/quick",
+	"quotedprintable.NewReader": "mime/quotedprintable",
+	"quotedprintable.NewWriter": "mime/quotedprintable",
+	"quotedprintable.Reader":    "mime/quotedprintable",
+	"quotedprintable.Writer":    "mime/quotedprintable",
+	"rand.ExpFloat64":           "math/rand",
+	"rand.Float32":              "math/rand",
+	"rand.Float64":              "math/rand",
+	// "rand.Int" is ambiguous
+	"rand.Int31":       "math/rand",
+	"rand.Int31n":      "math/rand",
+	"rand.Int63":       "math/rand",
+	"rand.Int63n":      "math/rand",
+	"rand.Intn":        "math/rand",
+	"rand.New":         "math/rand",
+	"rand.NewSource":   "math/rand",
+	"rand.NewZipf":     "math/rand",
+	"rand.NormFloat64": "math/rand",
+	"rand.Perm":        "math/rand",
+	"rand.Prime":       "crypto/rand",
+	"rand.Rand":        "math/rand",
+	// "rand.Read" is ambiguous
+	"rand.Reader":                     "crypto/rand",
+	"rand.Seed":                       "math/rand",
+	"rand.Source":                     "math/rand",
+	"rand.Source64":                   "math/rand",
+	"rand.Uint32":                     "math/rand",
+	"rand.Uint64":                     "math/rand",
+	"rand.Zipf":                       "math/rand",
+	"rc4.Cipher":                      "crypto/rc4",
+	"rc4.KeySizeError":                "crypto/rc4",
+	"rc4.NewCipher":                   "crypto/rc4",
+	"reflect.Append":                  "reflect",
+	"reflect.AppendSlice":             "reflect",
+	"reflect.Array":                   "reflect",
+	"reflect.ArrayOf":                 "reflect",
+	"reflect.Bool":                    "reflect",
+	"reflect.BothDir":                 "reflect",
+	"reflect.Chan":                    "reflect",
+	"reflect.ChanDir":                 "reflect",
+	"reflect.ChanOf":                  "reflect",
+	"reflect.Complex128":              "reflect",
+	"reflect.Complex64":               "reflect",
+	"reflect.Copy":                    "reflect",
+	"reflect.DeepEqual":               "reflect",
+	"reflect.Float32":                 "reflect",
+	"reflect.Float64":                 "reflect",
+	"reflect.Func":                    "reflect",
+	"reflect.FuncOf":                  "reflect",
+	"reflect.Indirect":                "reflect",
+	"reflect.Int":                     "reflect",
+	"reflect.Int16":                   "reflect",
+	"reflect.Int32":                   "reflect",
+	"reflect.Int64":                   "reflect",
+	"reflect.Int8":                    "reflect",
+	"reflect.Interface":               "reflect",
+	"reflect.Invalid":                 "reflect",
+	"reflect.Kind":                    "reflect",
+	"reflect.MakeChan":                "reflect",
+	"reflect.MakeFunc":                "reflect",
+	"reflect.MakeMap":                 "reflect",
+	"reflect.MakeMapWithSize":         "reflect",
+	"reflect.MakeSlice":               "reflect",
+	"reflect.Map":                     "reflect",
+	"reflect.MapOf":                   "reflect",
+	"reflect.Method":                  "reflect",
+	"reflect.New":                     "reflect",
+	"reflect.NewAt":                   "reflect",
+	"reflect.Ptr":                     "reflect",
+	"reflect.PtrTo":                   "reflect",
+	"reflect.RecvDir":                 "reflect",
+	"reflect.Select":                  "reflect",
+	"reflect.SelectCase":              "reflect",
+	"reflect.SelectDefault":           "reflect",
+	"reflect.SelectDir":               "reflect",
+	"reflect.SelectRecv":              "reflect",
+	"reflect.SelectSend":              "reflect",
+	"reflect.SendDir":                 "reflect",
+	"reflect.Slice":                   "reflect",
+	"reflect.SliceHeader":             "reflect",
+	"reflect.SliceOf":                 "reflect",
+	"reflect.String":                  "reflect",
+	"reflect.StringHeader":            "reflect",
+	"reflect.Struct":                  "reflect",
+	"reflect.StructField":             "reflect",
+	"reflect.StructOf":                "reflect",
+	"reflect.StructTag":               "reflect",
+	"reflect.Swapper":                 "reflect",
+	"reflect.TypeOf":                  "reflect",
+	"reflect.Uint":                    "reflect",
+	"reflect.Uint16":                  "reflect",
+	"reflect.Uint32":                  "reflect",
+	"reflect.Uint64":                  "reflect",
+	"reflect.Uint8":                   "reflect",
+	"reflect.Uintptr":                 "reflect",
+	"reflect.UnsafePointer":           "reflect",
+	"reflect.Value":                   "reflect",
+	"reflect.ValueError":              "reflect",
+	"reflect.ValueOf":                 "reflect",
+	"reflect.Zero":                    "reflect",
+	"regexp.Compile":                  "regexp",
+	"regexp.CompilePOSIX":             "regexp",
+	"regexp.Match":                    "regexp",
+	"regexp.MatchReader":              "regexp",
+	"regexp.MatchString":              "regexp",
+	"regexp.MustCompile":              "regexp",
+	"regexp.MustCompilePOSIX":         "regexp",
+	"regexp.QuoteMeta":                "regexp",
+	"regexp.Regexp":                   "regexp",
+	"ring.New":                        "container/ring",
+	"ring.Ring":                       "container/ring",
+	"rpc.Accept":                      "net/rpc",
+	"rpc.Call":                        "net/rpc",
+	"rpc.Client":                      "net/rpc",
+	"rpc.ClientCodec":                 "net/rpc",
+	"rpc.DefaultDebugPath":            "net/rpc",
+	"rpc.DefaultRPCPath":              "net/rpc",
+	"rpc.DefaultServer":               "net/rpc",
+	"rpc.Dial":                        "net/rpc",
+	"rpc.DialHTTP":                    "net/rpc",
+	"rpc.DialHTTPPath":                "net/rpc",
+	"rpc.ErrShutdown":                 "net/rpc",
+	"rpc.HandleHTTP":                  "net/rpc",
+	"rpc.NewClient":                   "net/rpc",
+	"rpc.NewClientWithCodec":          "net/rpc",
+	"rpc.NewServer":                   "net/rpc",
+	"rpc.Register":                    "net/rpc",
+	"rpc.RegisterName":                "net/rpc",
+	"rpc.Request":                     "net/rpc",
+	"rpc.Response":                    "net/rpc",
+	"rpc.ServeCodec":                  "net/rpc",
+	"rpc.ServeConn":                   "net/rpc",
+	"rpc.ServeRequest":                "net/rpc",
+	"rpc.Server":                      "net/rpc",
+	"rpc.ServerCodec":                 "net/rpc",
+	"rpc.ServerError":                 "net/rpc",
+	"rsa.CRTValue":                    "crypto/rsa",
+	"rsa.DecryptOAEP":                 "crypto/rsa",
+	"rsa.DecryptPKCS1v15":             "crypto/rsa",
+	"rsa.DecryptPKCS1v15SessionKey":   "crypto/rsa",
+	"rsa.EncryptOAEP":                 "crypto/rsa",
+	"rsa.EncryptPKCS1v15":             "crypto/rsa",
+	"rsa.ErrDecryption":               "crypto/rsa",
+	"rsa.ErrMessageTooLong":           "crypto/rsa",
+	"rsa.ErrVerification":             "crypto/rsa",
+	"rsa.GenerateKey":                 "crypto/rsa",
+	"rsa.GenerateMultiPrimeKey":       "crypto/rsa",
+	"rsa.OAEPOptions":                 "crypto/rsa",
+	"rsa.PKCS1v15DecryptOptions":      "crypto/rsa",
+	"rsa.PSSOptions":                  "crypto/rsa",
+	"rsa.PSSSaltLengthAuto":           "crypto/rsa",
+	"rsa.PSSSaltLengthEqualsHash":     "crypto/rsa",
+	"rsa.PrecomputedValues":           "crypto/rsa",
+	"rsa.PrivateKey":                  "crypto/rsa",
+	"rsa.PublicKey":                   "crypto/rsa",
+	"rsa.SignPKCS1v15":                "crypto/rsa",
+	"rsa.SignPSS":                     "crypto/rsa",
+	"rsa.VerifyPKCS1v15":              "crypto/rsa",
+	"rsa.VerifyPSS":                   "crypto/rsa",
+	"runtime.BlockProfile":            "runtime",
+	"runtime.BlockProfileRecord":      "runtime",
+	"runtime.Breakpoint":              "runtime",
+	"runtime.CPUProfile":              "runtime",
+	"runtime.Caller":                  "runtime",
+	"runtime.Callers":                 "runtime",
+	"runtime.CallersFrames":           "runtime",
+	"runtime.Compiler":                "runtime",
+	"runtime.Error":                   "runtime",
+	"runtime.Frame":                   "runtime",
+	"runtime.Frames":                  "runtime",
+	"runtime.Func":                    "runtime",
+	"runtime.FuncForPC":               "runtime",
+	"runtime.GC":                      "runtime",
+	"runtime.GOARCH":                  "runtime",
+	"runtime.GOMAXPROCS":              "runtime",
+	"runtime.GOOS":                    "runtime",
+	"runtime.GOROOT":                  "runtime",
+	"runtime.Goexit":                  "runtime",
+	"runtime.GoroutineProfile":        "runtime",
+	"runtime.Gosched":                 "runtime",
+	"runtime.KeepAlive":               "runtime",
+	"runtime.LockOSThread":            "runtime",
+	"runtime.MemProfile":              "runtime",
+	"runtime.MemProfileRate":          "runtime",
+	"runtime.MemProfileRecord":        "runtime",
+	"runtime.MemStats":                "runtime",
+	"runtime.MutexProfile":            "runtime",
+	"runtime.NumCPU":                  "runtime",
+	"runtime.NumCgoCall":              "runtime",
+	"runtime.NumGoroutine":            "runtime",
+	"runtime.ReadMemStats":            "runtime",
+	"runtime.ReadTrace":               "runtime",
+	"runtime.SetBlockProfileRate":     "runtime",
+	"runtime.SetCPUProfileRate":       "runtime",
+	"runtime.SetCgoTraceback":         "runtime",
+	"runtime.SetFinalizer":            "runtime",
+	"runtime.SetMutexProfileFraction": "runtime",
+	"runtime.Stack":                   "runtime",
+	"runtime.StackRecord":             "runtime",
+	"runtime.StartTrace":              "runtime",
+	"runtime.StopTrace":               "runtime",
+	"runtime.ThreadCreateProfile":     "runtime",
+	"runtime.TypeAssertionError":      "runtime",
+	"runtime.UnlockOSThread":          "runtime",
+	"runtime.Version":                 "runtime",
+	"scanner.Char":                    "text/scanner",
+	"scanner.Comment":                 "text/scanner",
+	"scanner.EOF":                     "text/scanner",
+	"scanner.Error":                   "go/scanner",
+	"scanner.ErrorHandler":            "go/scanner",
+	"scanner.ErrorList":               "go/scanner",
+	"scanner.Float":                   "text/scanner",
+	"scanner.GoTokens":                "text/scanner",
+	"scanner.GoWhitespace":            "text/scanner",
+	"scanner.Ident":                   "text/scanner",
+	"scanner.Int":                     "text/scanner",
+	"scanner.Mode":                    "go/scanner",
+	"scanner.Position":                "text/scanner",
+	"scanner.PrintError":              "go/scanner",
+	"scanner.RawString":               "text/scanner",
+	"scanner.ScanChars":               "text/scanner",
+	// "scanner.ScanComments" is ambiguous
+	"scanner.ScanFloats":     "text/scanner",
+	"scanner.ScanIdents":     "text/scanner",
+	"scanner.ScanInts":       "text/scanner",
+	"scanner.ScanRawStrings": "text/scanner",
+	"scanner.ScanStrings":    "text/scanner",
+	// "scanner.Scanner" is ambiguous
+	"scanner.SkipComments":                                 "text/scanner",
+	"scanner.String":                                       "text/scanner",
+	"scanner.TokenString":                                  "text/scanner",
+	"sha1.BlockSize":                                       "crypto/sha1",
+	"sha1.New":                                             "crypto/sha1",
+	"sha1.Size":                                            "crypto/sha1",
+	"sha1.Sum":                                             "crypto/sha1",
+	"sha256.BlockSize":                                     "crypto/sha256",
+	"sha256.New":                                           "crypto/sha256",
+	"sha256.New224":                                        "crypto/sha256",
+	"sha256.Size":                                          "crypto/sha256",
+	"sha256.Size224":                                       "crypto/sha256",
+	"sha256.Sum224":                                        "crypto/sha256",
+	"sha256.Sum256":                                        "crypto/sha256",
+	"sha512.BlockSize":                                     "crypto/sha512",
+	"sha512.New":                                           "crypto/sha512",
+	"sha512.New384":                                        "crypto/sha512",
+	"sha512.New512_224":                                    "crypto/sha512",
+	"sha512.New512_256":                                    "crypto/sha512",
+	"sha512.Size":                                          "crypto/sha512",
+	"sha512.Size224":                                       "crypto/sha512",
+	"sha512.Size256":                                       "crypto/sha512",
+	"sha512.Size384":                                       "crypto/sha512",
+	"sha512.Sum384":                                        "crypto/sha512",
+	"sha512.Sum512":                                        "crypto/sha512",
+	"sha512.Sum512_224":                                    "crypto/sha512",
+	"sha512.Sum512_256":                                    "crypto/sha512",
+	"signal.Ignore":                                        "os/signal",
+	"signal.Notify":                                        "os/signal",
+	"signal.Reset":                                         "os/signal",
+	"signal.Stop":                                          "os/signal",
+	"smtp.Auth":                                            "net/smtp",
+	"smtp.CRAMMD5Auth":                                     "net/smtp",
+	"smtp.Client":                                          "net/smtp",
+	"smtp.Dial":                                            "net/smtp",
+	"smtp.NewClient":                                       "net/smtp",
+	"smtp.PlainAuth":                                       "net/smtp",
+	"smtp.SendMail":                                        "net/smtp",
+	"smtp.ServerInfo":                                      "net/smtp",
+	"sort.Float64Slice":                                    "sort",
+	"sort.Float64s":                                        "sort",
+	"sort.Float64sAreSorted":                               "sort",
+	"sort.IntSlice":                                        "sort",
+	"sort.Interface":                                       "sort",
+	"sort.Ints":                                            "sort",
+	"sort.IntsAreSorted":                                   "sort",
+	"sort.IsSorted":                                        "sort",
+	"sort.Reverse":                                         "sort",
+	"sort.Search":                                          "sort",
+	"sort.SearchFloat64s":                                  "sort",
+	"sort.SearchInts":                                      "sort",
+	"sort.SearchStrings":                                   "sort",
+	"sort.Slice":                                           "sort",
+	"sort.SliceIsSorted":                                   "sort",
+	"sort.SliceStable":                                     "sort",
+	"sort.Sort":                                            "sort",
+	"sort.Stable":                                          "sort",
+	"sort.StringSlice":                                     "sort",
+	"sort.Strings":                                         "sort",
+	"sort.StringsAreSorted":                                "sort",
+	"sql.ColumnType":                                       "database/sql",
+	"sql.Conn":                                             "database/sql",
+	"sql.DB":                                               "database/sql",
+	"sql.DBStats":                                          "database/sql",
+	"sql.Drivers":                                          "database/sql",
+	"sql.ErrConnDone":                                      "database/sql",
+	"sql.ErrNoRows":                                        "database/sql",
+	"sql.ErrTxDone":                                        "database/sql",
+	"sql.IsolationLevel":                                   "database/sql",
+	"sql.LevelDefault":                                     "database/sql",
+	"sql.LevelLinearizable":                                "database/sql",
+	"sql.LevelReadCommitted":                               "database/sql",
+	"sql.LevelReadUncommitted":                             "database/sql",
+	"sql.LevelRepeatableRead":                              "database/sql",
+	"sql.LevelSerializable":                                "database/sql",
+	"sql.LevelSnapshot":                                    "database/sql",
+	"sql.LevelWriteCommitted":                              "database/sql",
+	"sql.Named":                                            "database/sql",
+	"sql.NamedArg":                                         "database/sql",
+	"sql.NullBool":                                         "database/sql",
+	"sql.NullFloat64":                                      "database/sql",
+	"sql.NullInt64":                                        "database/sql",
+	"sql.NullString":                                       "database/sql",
+	"sql.Open":                                             "database/sql",
+	"sql.Out":                                              "database/sql",
+	"sql.RawBytes":                                         "database/sql",
+	"sql.Register":                                         "database/sql",
+	"sql.Result":                                           "database/sql",
+	"sql.Row":                                              "database/sql",
+	"sql.Rows":                                             "database/sql",
+	"sql.Scanner":                                          "database/sql",
+	"sql.Stmt":                                             "database/sql",
+	"sql.Tx":                                               "database/sql",
+	"sql.TxOptions":                                        "database/sql",
+	"strconv.AppendBool":                                   "strconv",
+	"strconv.AppendFloat":                                  "strconv",
+	"strconv.AppendInt":                                    "strconv",
+	"strconv.AppendQuote":                                  "strconv",
+	"strconv.AppendQuoteRune":                              "strconv",
+	"strconv.AppendQuoteRuneToASCII":                       "strconv",
+	"strconv.AppendQuoteRuneToGraphic":                     "strconv",
+	"strconv.AppendQuoteToASCII":                           "strconv",
+	"strconv.AppendQuoteToGraphic":                         "strconv",
+	"strconv.AppendUint":                                   "strconv",
+	"strconv.Atoi":                                         "strconv",
+	"strconv.CanBackquote":                                 "strconv",
+	"strconv.ErrRange":                                     "strconv",
+	"strconv.ErrSyntax":                                    "strconv",
+	"strconv.FormatBool":                                   "strconv",
+	"strconv.FormatFloat":                                  "strconv",
+	"strconv.FormatInt":                                    "strconv",
+	"strconv.FormatUint":                                   "strconv",
+	"strconv.IntSize":                                      "strconv",
+	"strconv.IsGraphic":                                    "strconv",
+	"strconv.IsPrint":                                      "strconv",
+	"strconv.Itoa":                                         "strconv",
+	"strconv.NumError":                                     "strconv",
+	"strconv.ParseBool":                                    "strconv",
+	"strconv.ParseFloat":                                   "strconv",
+	"strconv.ParseInt":                                     "strconv",
+	"strconv.ParseUint":                                    "strconv",
+	"strconv.Quote":                                        "strconv",
+	"strconv.QuoteRune":                                    "strconv",
+	"strconv.QuoteRuneToASCII":                             "strconv",
+	"strconv.QuoteRuneToGraphic":                           "strconv",
+	"strconv.QuoteToASCII":                                 "strconv",
+	"strconv.QuoteToGraphic":                               "strconv",
+	"strconv.Unquote":                                      "strconv",
+	"strconv.UnquoteChar":                                  "strconv",
+	"strings.Compare":                                      "strings",
+	"strings.Contains":                                     "strings",
+	"strings.ContainsAny":                                  "strings",
+	"strings.ContainsRune":                                 "strings",
+	"strings.Count":                                        "strings",
+	"strings.EqualFold":                                    "strings",
+	"strings.Fields":                                       "strings",
+	"strings.FieldsFunc":                                   "strings",
+	"strings.HasPrefix":                                    "strings",
+	"strings.HasSuffix":                                    "strings",
+	"strings.Index":                                        "strings",
+	"strings.IndexAny":                                     "strings",
+	"strings.IndexByte":                                    "strings",
+	"strings.IndexFunc":                                    "strings",
+	"strings.IndexRune":                                    "strings",
+	"strings.Join":                                         "strings",
+	"strings.LastIndex":                                    "strings",
+	"strings.LastIndexAny":                                 "strings",
+	"strings.LastIndexByte":                                "strings",
+	"strings.LastIndexFunc":                                "strings",
+	"strings.Map":                                          "strings",
+	"strings.NewReader":                                    "strings",
+	"strings.NewReplacer":                                  "strings",
+	"strings.Reader":                                       "strings",
+	"strings.Repeat":                                       "strings",
+	"strings.Replace":                                      "strings",
+	"strings.Replacer":                                     "strings",
+	"strings.Split":                                        "strings",
+	"strings.SplitAfter":                                   "strings",
+	"strings.SplitAfterN":                                  "strings",
+	"strings.SplitN":                                       "strings",
+	"strings.Title":                                        "strings",
+	"strings.ToLower":                                      "strings",
+	"strings.ToLowerSpecial":                               "strings",
+	"strings.ToTitle":                                      "strings",
+	"strings.ToTitleSpecial":                               "strings",
+	"strings.ToUpper":                                      "strings",
+	"strings.ToUpperSpecial":                               "strings",
+	"strings.Trim":                                         "strings",
+	"strings.TrimFunc":                                     "strings",
+	"strings.TrimLeft":                                     "strings",
+	"strings.TrimLeftFunc":                                 "strings",
+	"strings.TrimPrefix":                                   "strings",
+	"strings.TrimRight":                                    "strings",
+	"strings.TrimRightFunc":                                "strings",
+	"strings.TrimSpace":                                    "strings",
+	"strings.TrimSuffix":                                   "strings",
+	"subtle.ConstantTimeByteEq":                            "crypto/subtle",
+	"subtle.ConstantTimeCompare":                           "crypto/subtle",
+	"subtle.ConstantTimeCopy":                              "crypto/subtle",
+	"subtle.ConstantTimeEq":                                "crypto/subtle",
+	"subtle.ConstantTimeLessOrEq":                          "crypto/subtle",
+	"subtle.ConstantTimeSelect":                            "crypto/subtle",
+	"suffixarray.Index":                                    "index/suffixarray",
+	"suffixarray.New":                                      "index/suffixarray",
+	"sync.Cond":                                            "sync",
+	"sync.Locker":                                          "sync",
+	"sync.Map":                                             "sync",
+	"sync.Mutex":                                           "sync",
+	"sync.NewCond":                                         "sync",
+	"sync.Once":                                            "sync",
+	"sync.Pool":                                            "sync",
+	"sync.RWMutex":                                         "sync",
+	"sync.WaitGroup":                                       "sync",
+	"syntax.ClassNL":                                       "regexp/syntax",
+	"syntax.Compile":                                       "regexp/syntax",
+	"syntax.DotNL":                                         "regexp/syntax",
+	"syntax.EmptyBeginLine":                                "regexp/syntax",
+	"syntax.EmptyBeginText":                                "regexp/syntax",
+	"syntax.EmptyEndLine":                                  "regexp/syntax",
+	"syntax.EmptyEndText":                                  "regexp/syntax",
+	"syntax.EmptyNoWordBoundary":                           "regexp/syntax",
+	"syntax.EmptyOp":                                       "regexp/syntax",
+	"syntax.EmptyOpContext":                                "regexp/syntax",
+	"syntax.EmptyWordBoundary":                             "regexp/syntax",
+	"syntax.ErrInternalError":                              "regexp/syntax",
+	"syntax.ErrInvalidCharClass":                           "regexp/syntax",
+	"syntax.ErrInvalidCharRange":                           "regexp/syntax",
+	"syntax.ErrInvalidEscape":                              "regexp/syntax",
+	"syntax.ErrInvalidNamedCapture":                        "regexp/syntax",
+	"syntax.ErrInvalidPerlOp":                              "regexp/syntax",
+	"syntax.ErrInvalidRepeatOp":                            "regexp/syntax",
+	"syntax.ErrInvalidRepeatSize":                          "regexp/syntax",
+	"syntax.ErrInvalidUTF8":                                "regexp/syntax",
+	"syntax.ErrMissingBracket":                             "regexp/syntax",
+	"syntax.ErrMissingParen":                               "regexp/syntax",
+	"syntax.ErrMissingRepeatArgument":                      "regexp/syntax",
+	"syntax.ErrTrailingBackslash":                          "regexp/syntax",
+	"syntax.ErrUnexpectedParen":                            "regexp/syntax",
+	"syntax.Error":                                         "regexp/syntax",
+	"syntax.ErrorCode":                                     "regexp/syntax",
+	"syntax.Flags":                                         "regexp/syntax",
+	"syntax.FoldCase":                                      "regexp/syntax",
+	"syntax.Inst":                                          "regexp/syntax",
+	"syntax.InstAlt":                                       "regexp/syntax",
+	"syntax.InstAltMatch":                                  "regexp/syntax",
+	"syntax.InstCapture":                                   "regexp/syntax",
+	"syntax.InstEmptyWidth":                                "regexp/syntax",
+	"syntax.InstFail":                                      "regexp/syntax",
+	"syntax.InstMatch":                                     "regexp/syntax",
+	"syntax.InstNop":                                       "regexp/syntax",
+	"syntax.InstOp":                                        "regexp/syntax",
+	"syntax.InstRune":                                      "regexp/syntax",
+	"syntax.InstRune1":                                     "regexp/syntax",
+	"syntax.InstRuneAny":                                   "regexp/syntax",
+	"syntax.InstRuneAnyNotNL":                              "regexp/syntax",
+	"syntax.IsWordChar":                                    "regexp/syntax",
+	"syntax.Literal":                                       "regexp/syntax",
+	"syntax.MatchNL":                                       "regexp/syntax",
+	"syntax.NonGreedy":                                     "regexp/syntax",
+	"syntax.OneLine":                                       "regexp/syntax",
+	"syntax.Op":                                            "regexp/syntax",
+	"syntax.OpAlternate":                                   "regexp/syntax",
+	"syntax.OpAnyChar":                                     "regexp/syntax",
+	"syntax.OpAnyCharNotNL":                                "regexp/syntax",
+	"syntax.OpBeginLine":                                   "regexp/syntax",
+	"syntax.OpBeginText":                                   "regexp/syntax",
+	"syntax.OpCapture":                                     "regexp/syntax",
+	"syntax.OpCharClass":                                   "regexp/syntax",
+	"syntax.OpConcat":                                      "regexp/syntax",
+	"syntax.OpEmptyMatch":                                  "regexp/syntax",
+	"syntax.OpEndLine":                                     "regexp/syntax",
+	"syntax.OpEndText":                                     "regexp/syntax",
+	"syntax.OpLiteral":                                     "regexp/syntax",
+	"syntax.OpNoMatch":                                     "regexp/syntax",
+	"syntax.OpNoWordBoundary":                              "regexp/syntax",
+	"syntax.OpPlus":                                        "regexp/syntax",
+	"syntax.OpQuest":                                       "regexp/syntax",
+	"syntax.OpRepeat":                                      "regexp/syntax",
+	"syntax.OpStar":                                        "regexp/syntax",
+	"syntax.OpWordBoundary":                                "regexp/syntax",
+	"syntax.POSIX":                                         "regexp/syntax",
+	"syntax.Parse":                                         "regexp/syntax",
+	"syntax.Perl":                                          "regexp/syntax",
+	"syntax.PerlX":                                         "regexp/syntax",
+	"syntax.Prog":                                          "regexp/syntax",
+	"syntax.Regexp":                                        "regexp/syntax",
+	"syntax.Simple":                                        "regexp/syntax",
+	"syntax.UnicodeGroups":                                 "regexp/syntax",
+	"syntax.WasDollar":                                     "regexp/syntax",
+	"syscall.AF_ALG":                                       "syscall",
+	"syscall.AF_APPLETALK":                                 "syscall",
+	"syscall.AF_ARP":                                       "syscall",
+	"syscall.AF_ASH":                                       "syscall",
+	"syscall.AF_ATM":                                       "syscall",
+	"syscall.AF_ATMPVC":                                    "syscall",
+	"syscall.AF_ATMSVC":                                    "syscall",
+	"syscall.AF_AX25":                                      "syscall",
+	"syscall.AF_BLUETOOTH":                                 "syscall",
+	"syscall.AF_BRIDGE":                                    "syscall",
+	"syscall.AF_CAIF":                                      "syscall",
+	"syscall.AF_CAN":                                       "syscall",
+	"syscall.AF_CCITT":                                     "syscall",
+	"syscall.AF_CHAOS":                                     "syscall",
+	"syscall.AF_CNT":                                       "syscall",
+	"syscall.AF_COIP":                                      "syscall",
+	"syscall.AF_DATAKIT":                                   "syscall",
+	"syscall.AF_DECnet":                                    "syscall",
+	"syscall.AF_DLI":                                       "syscall",
+	"syscall.AF_E164":                                      "syscall",
+	"syscall.AF_ECMA":                                      "syscall",
+	"syscall.AF_ECONET":                                    "syscall",
+	"syscall.AF_ENCAP":                                     "syscall",
+	"syscall.AF_FILE":                                      "syscall",
+	"syscall.AF_HYLINK":                                    "syscall",
+	"syscall.AF_IEEE80211":                                 "syscall",
+	"syscall.AF_IEEE802154":                                "syscall",
+	"syscall.AF_IMPLINK":                                   "syscall",
+	"syscall.AF_INET":                                      "syscall",
+	"syscall.AF_INET6":                                     "syscall",
+	"syscall.AF_INET6_SDP":                                 "syscall",
+	"syscall.AF_INET_SDP":                                  "syscall",
+	"syscall.AF_IPX":                                       "syscall",
+	"syscall.AF_IRDA":                                      "syscall",
+	"syscall.AF_ISDN":                                      "syscall",
+	"syscall.AF_ISO":                                       "syscall",
+	"syscall.AF_IUCV":                                      "syscall",
+	"syscall.AF_KEY":                                       "syscall",
+	"syscall.AF_LAT":                                       "syscall",
+	"syscall.AF_LINK":                                      "syscall",
+	"syscall.AF_LLC":                                       "syscall",
+	"syscall.AF_LOCAL":                                     "syscall",
+	"syscall.AF_MAX":                                       "syscall",
+	"syscall.AF_MPLS":                                      "syscall",
+	"syscall.AF_NATM":                                      "syscall",
+	"syscall.AF_NDRV":                                      "syscall",
+	"syscall.AF_NETBEUI":                                   "syscall",
+	"syscall.AF_NETBIOS":                                   "syscall",
+	"syscall.AF_NETGRAPH":                                  "syscall",
+	"syscall.AF_NETLINK":                                   "syscall",
+	"syscall.AF_NETROM":                                    "syscall",
+	"syscall.AF_NS":                                        "syscall",
+	"syscall.AF_OROUTE":                                    "syscall",
+	"syscall.AF_OSI":                                       "syscall",
+	"syscall.AF_PACKET":                                    "syscall",
+	"syscall.AF_PHONET":                                    "syscall",
+	"syscall.AF_PPP":                                       "syscall",
+	"syscall.AF_PPPOX":                                     "syscall",
+	"syscall.AF_PUP":                                       "syscall",
+	"syscall.AF_RDS":                                       "syscall",
+	"syscall.AF_RESERVED_36":                               "syscall",
+	"syscall.AF_ROSE":                                      "syscall",
+	"syscall.AF_ROUTE":                                     "syscall",
+	"syscall.AF_RXRPC":                                     "syscall",
+	"syscall.AF_SCLUSTER":                                  "syscall",
+	"syscall.AF_SECURITY":                                  "syscall",
+	"syscall.AF_SIP":                                       "syscall",
+	"syscall.AF_SLOW":                                      "syscall",
+	"syscall.AF_SNA":                                       "syscall",
+	"syscall.AF_SYSTEM":                                    "syscall",
+	"syscall.AF_TIPC":                                      "syscall",
+	"syscall.AF_UNIX":                                      "syscall",
+	"syscall.AF_UNSPEC":                                    "syscall",
+	"syscall.AF_VENDOR00":                                  "syscall",
+	"syscall.AF_VENDOR01":                                  "syscall",
+	"syscall.AF_VENDOR02":                                  "syscall",
+	"syscall.AF_VENDOR03":                                  "syscall",
+	"syscall.AF_VENDOR04":                                  "syscall",
+	"syscall.AF_VENDOR05":                                  "syscall",
+	"syscall.AF_VENDOR06":                                  "syscall",
+	"syscall.AF_VENDOR07":                                  "syscall",
+	"syscall.AF_VENDOR08":                                  "syscall",
+	"syscall.AF_VENDOR09":                                  "syscall",
+	"syscall.AF_VENDOR10":                                  "syscall",
+	"syscall.AF_VENDOR11":                                  "syscall",
+	"syscall.AF_VENDOR12":                                  "syscall",
+	"syscall.AF_VENDOR13":                                  "syscall",
+	"syscall.AF_VENDOR14":                                  "syscall",
+	"syscall.AF_VENDOR15":                                  "syscall",
+	"syscall.AF_VENDOR16":                                  "syscall",
+	"syscall.AF_VENDOR17":                                  "syscall",
+	"syscall.AF_VENDOR18":                                  "syscall",
+	"syscall.AF_VENDOR19":                                  "syscall",
+	"syscall.AF_VENDOR20":                                  "syscall",
+	"syscall.AF_VENDOR21":                                  "syscall",
+	"syscall.AF_VENDOR22":                                  "syscall",
+	"syscall.AF_VENDOR23":                                  "syscall",
+	"syscall.AF_VENDOR24":                                  "syscall",
+	"syscall.AF_VENDOR25":                                  "syscall",
+	"syscall.AF_VENDOR26":                                  "syscall",
+	"syscall.AF_VENDOR27":                                  "syscall",
+	"syscall.AF_VENDOR28":                                  "syscall",
+	"syscall.AF_VENDOR29":                                  "syscall",
+	"syscall.AF_VENDOR30":                                  "syscall",
+	"syscall.AF_VENDOR31":                                  "syscall",
+	"syscall.AF_VENDOR32":                                  "syscall",
+	"syscall.AF_VENDOR33":                                  "syscall",
+	"syscall.AF_VENDOR34":                                  "syscall",
+	"syscall.AF_VENDOR35":                                  "syscall",
+	"syscall.AF_VENDOR36":                                  "syscall",
+	"syscall.AF_VENDOR37":                                  "syscall",
+	"syscall.AF_VENDOR38":                                  "syscall",
+	"syscall.AF_VENDOR39":                                  "syscall",
+	"syscall.AF_VENDOR40":                                  "syscall",
+	"syscall.AF_VENDOR41":                                  "syscall",
+	"syscall.AF_VENDOR42":                                  "syscall",
+	"syscall.AF_VENDOR43":                                  "syscall",
+	"syscall.AF_VENDOR44":                                  "syscall",
+	"syscall.AF_VENDOR45":                                  "syscall",
+	"syscall.AF_VENDOR46":                                  "syscall",
+	"syscall.AF_VENDOR47":                                  "syscall",
+	"syscall.AF_WANPIPE":                                   "syscall",
+	"syscall.AF_X25":                                       "syscall",
+	"syscall.AI_CANONNAME":                                 "syscall",
+	"syscall.AI_NUMERICHOST":                               "syscall",
+	"syscall.AI_PASSIVE":                                   "syscall",
+	"syscall.APPLICATION_ERROR":                            "syscall",
+	"syscall.ARPHRD_ADAPT":                                 "syscall",
+	"syscall.ARPHRD_APPLETLK":                              "syscall",
+	"syscall.ARPHRD_ARCNET":                                "syscall",
+	"syscall.ARPHRD_ASH":                                   "syscall",
+	"syscall.ARPHRD_ATM":                                   "syscall",
+	"syscall.ARPHRD_AX25":                                  "syscall",
+	"syscall.ARPHRD_BIF":                                   "syscall",
+	"syscall.ARPHRD_CHAOS":                                 "syscall",
+	"syscall.ARPHRD_CISCO":                                 "syscall",
+	"syscall.ARPHRD_CSLIP":                                 "syscall",
+	"syscall.ARPHRD_CSLIP6":                                "syscall",
+	"syscall.ARPHRD_DDCMP":                                 "syscall",
+	"syscall.ARPHRD_DLCI":                                  "syscall",
+	"syscall.ARPHRD_ECONET":                                "syscall",
+	"syscall.ARPHRD_EETHER":                                "syscall",
+	"syscall.ARPHRD_ETHER":                                 "syscall",
+	"syscall.ARPHRD_EUI64":                                 "syscall",
+	"syscall.ARPHRD_FCAL":                                  "syscall",
+	"syscall.ARPHRD_FCFABRIC":                              "syscall",
+	"syscall.ARPHRD_FCPL":                                  "syscall",
+	"syscall.ARPHRD_FCPP":                                  "syscall",
+	"syscall.ARPHRD_FDDI":                                  "syscall",
+	"syscall.ARPHRD_FRAD":                                  "syscall",
+	"syscall.ARPHRD_FRELAY":                                "syscall",
+	"syscall.ARPHRD_HDLC":                                  "syscall",
+	"syscall.ARPHRD_HIPPI":                                 "syscall",
+	"syscall.ARPHRD_HWX25":                                 "syscall",
+	"syscall.ARPHRD_IEEE1394":                              "syscall",
+	"syscall.ARPHRD_IEEE802":                               "syscall",
+	"syscall.ARPHRD_IEEE80211":                             "syscall",
+	"syscall.ARPHRD_IEEE80211_PRISM":                       "syscall",
+	"syscall.ARPHRD_IEEE80211_RADIOTAP":                    "syscall",
+	"syscall.ARPHRD_IEEE802154":                            "syscall",
+	"syscall.ARPHRD_IEEE802154_PHY":                        "syscall",
+	"syscall.ARPHRD_IEEE802_TR":                            "syscall",
+	"syscall.ARPHRD_INFINIBAND":                            "syscall",
+	"syscall.ARPHRD_IPDDP":                                 "syscall",
+	"syscall.ARPHRD_IPGRE":                                 "syscall",
+	"syscall.ARPHRD_IRDA":                                  "syscall",
+	"syscall.ARPHRD_LAPB":                                  "syscall",
+	"syscall.ARPHRD_LOCALTLK":                              "syscall",
+	"syscall.ARPHRD_LOOPBACK":                              "syscall",
+	"syscall.ARPHRD_METRICOM":                              "syscall",
+	"syscall.ARPHRD_NETROM":                                "syscall",
+	"syscall.ARPHRD_NONE":                                  "syscall",
+	"syscall.ARPHRD_PIMREG":                                "syscall",
+	"syscall.ARPHRD_PPP":                                   "syscall",
+	"syscall.ARPHRD_PRONET":                                "syscall",
+	"syscall.ARPHRD_RAWHDLC":                               "syscall",
+	"syscall.ARPHRD_ROSE":                                  "syscall",
+	"syscall.ARPHRD_RSRVD":                                 "syscall",
+	"syscall.ARPHRD_SIT":                                   "syscall",
+	"syscall.ARPHRD_SKIP":                                  "syscall",
+	"syscall.ARPHRD_SLIP":                                  "syscall",
+	"syscall.ARPHRD_SLIP6":                                 "syscall",
+	"syscall.ARPHRD_STRIP":                                 "syscall",
+	"syscall.ARPHRD_TUNNEL":                                "syscall",
+	"syscall.ARPHRD_TUNNEL6":                               "syscall",
+	"syscall.ARPHRD_VOID":                                  "syscall",
+	"syscall.ARPHRD_X25":                                   "syscall",
+	"syscall.AUTHTYPE_CLIENT":                              "syscall",
+	"syscall.AUTHTYPE_SERVER":                              "syscall",
+	"syscall.Accept":                                       "syscall",
+	"syscall.Accept4":                                      "syscall",
+	"syscall.AcceptEx":                                     "syscall",
+	"syscall.Access":                                       "syscall",
+	"syscall.Acct":                                         "syscall",
+	"syscall.AddrinfoW":                                    "syscall",
+	"syscall.Adjtime":                                      "syscall",
+	"syscall.Adjtimex":                                     "syscall",
+	"syscall.AttachLsf":                                    "syscall",
+	"syscall.B0":                                           "syscall",
+	"syscall.B1000000":                                     "syscall",
+	"syscall.B110":                                         "syscall",
+	"syscall.B115200":                                      "syscall",
+	"syscall.B1152000":                                     "syscall",
+	"syscall.B1200":                                        "syscall",
+	"syscall.B134":                                         "syscall",
+	"syscall.B14400":                                       "syscall",
+	"syscall.B150":                                         "syscall",
+	"syscall.B1500000":                                     "syscall",
+	"syscall.B1800":                                        "syscall",
+	"syscall.B19200":                                       "syscall",
+	"syscall.B200":                                         "syscall",
+	"syscall.B2000000":                                     "syscall",
+	"syscall.B230400":                                      "syscall",
+	"syscall.B2400":                                        "syscall",
+	"syscall.B2500000":                                     "syscall",
+	"syscall.B28800":                                       "syscall",
+	"syscall.B300":                                         "syscall",
+	"syscall.B3000000":                                     "syscall",
+	"syscall.B3500000":                                     "syscall",
+	"syscall.B38400":                                       "syscall",
+	"syscall.B4000000":                                     "syscall",
+	"syscall.B460800":                                      "syscall",
+	"syscall.B4800":                                        "syscall",
+	"syscall.B50":                                          "syscall",
+	"syscall.B500000":                                      "syscall",
+	"syscall.B57600":                                       "syscall",
+	"syscall.B576000":                                      "syscall",
+	"syscall.B600":                                         "syscall",
+	"syscall.B7200":                                        "syscall",
+	"syscall.B75":                                          "syscall",
+	"syscall.B76800":                                       "syscall",
+	"syscall.B921600":                                      "syscall",
+	"syscall.B9600":                                        "syscall",
+	"syscall.BASE_PROTOCOL":                                "syscall",
+	"syscall.BIOCFEEDBACK":                                 "syscall",
+	"syscall.BIOCFLUSH":                                    "syscall",
+	"syscall.BIOCGBLEN":                                    "syscall",
+	"syscall.BIOCGDIRECTION":                               "syscall",
+	"syscall.BIOCGDIRFILT":                                 "syscall",
+	"syscall.BIOCGDLT":                                     "syscall",
+	"syscall.BIOCGDLTLIST":                                 "syscall",
+	"syscall.BIOCGETBUFMODE":                               "syscall",
+	"syscall.BIOCGETIF":                                    "syscall",
+	"syscall.BIOCGETZMAX":                                  "syscall",
+	"syscall.BIOCGFEEDBACK":                                "syscall",
+	"syscall.BIOCGFILDROP":                                 "syscall",
+	"syscall.BIOCGHDRCMPLT":                                "syscall",
+	"syscall.BIOCGRSIG":                                    "syscall",
+	"syscall.BIOCGRTIMEOUT":                                "syscall",
+	"syscall.BIOCGSEESENT":                                 "syscall",
+	"syscall.BIOCGSTATS":                                   "syscall",
+	"syscall.BIOCGSTATSOLD":                                "syscall",
+	"syscall.BIOCGTSTAMP":                                  "syscall",
+	"syscall.BIOCIMMEDIATE":                                "syscall",
+	"syscall.BIOCLOCK":                                     "syscall",
+	"syscall.BIOCPROMISC":                                  "syscall",
+	"syscall.BIOCROTZBUF":                                  "syscall",
+	"syscall.BIOCSBLEN":                                    "syscall",
+	"syscall.BIOCSDIRECTION":                               "syscall",
+	"syscall.BIOCSDIRFILT":                                 "syscall",
+	"syscall.BIOCSDLT":                                     "syscall",
+	"syscall.BIOCSETBUFMODE":                               "syscall",
+	"syscall.BIOCSETF":                                     "syscall",
+	"syscall.BIOCSETFNR":                                   "syscall",
+	"syscall.BIOCSETIF":                                    "syscall",
+	"syscall.BIOCSETWF":                                    "syscall",
+	"syscall.BIOCSETZBUF":                                  "syscall",
+	"syscall.BIOCSFEEDBACK":                                "syscall",
+	"syscall.BIOCSFILDROP":                                 "syscall",
+	"syscall.BIOCSHDRCMPLT":                                "syscall",
+	"syscall.BIOCSRSIG":                                    "syscall",
+	"syscall.BIOCSRTIMEOUT":                                "syscall",
+	"syscall.BIOCSSEESENT":                                 "syscall",
+	"syscall.BIOCSTCPF":                                    "syscall",
+	"syscall.BIOCSTSTAMP":                                  "syscall",
+	"syscall.BIOCSUDPF":                                    "syscall",
+	"syscall.BIOCVERSION":                                  "syscall",
+	"syscall.BPF_A":                                        "syscall",
+	"syscall.BPF_ABS":                                      "syscall",
+	"syscall.BPF_ADD":                                      "syscall",
+	"syscall.BPF_ALIGNMENT":                                "syscall",
+	"syscall.BPF_ALIGNMENT32":                              "syscall",
+	"syscall.BPF_ALU":                                      "syscall",
+	"syscall.BPF_AND":                                      "syscall",
+	"syscall.BPF_B":                                        "syscall",
+	"syscall.BPF_BUFMODE_BUFFER":                           "syscall",
+	"syscall.BPF_BUFMODE_ZBUF":                             "syscall",
+	"syscall.BPF_DFLTBUFSIZE":                              "syscall",
+	"syscall.BPF_DIRECTION_IN":                             "syscall",
+	"syscall.BPF_DIRECTION_OUT":                            "syscall",
+	"syscall.BPF_DIV":                                      "syscall",
+	"syscall.BPF_H":                                        "syscall",
+	"syscall.BPF_IMM":                                      "syscall",
+	"syscall.BPF_IND":                                      "syscall",
+	"syscall.BPF_JA":                                       "syscall",
+	"syscall.BPF_JEQ":                                      "syscall",
+	"syscall.BPF_JGE":                                      "syscall",
+	"syscall.BPF_JGT":                                      "syscall",
+	"syscall.BPF_JMP":                                      "syscall",
+	"syscall.BPF_JSET":                                     "syscall",
+	"syscall.BPF_K":                                        "syscall",
+	"syscall.BPF_LD":                                       "syscall",
+	"syscall.BPF_LDX":                                      "syscall",
+	"syscall.BPF_LEN":                                      "syscall",
+	"syscall.BPF_LSH":                                      "syscall",
+	"syscall.BPF_MAJOR_VERSION":                            "syscall",
+	"syscall.BPF_MAXBUFSIZE":                               "syscall",
+	"syscall.BPF_MAXINSNS":                                 "syscall",
+	"syscall.BPF_MEM":                                      "syscall",
+	"syscall.BPF_MEMWORDS":                                 "syscall",
+	"syscall.BPF_MINBUFSIZE":                               "syscall",
+	"syscall.BPF_MINOR_VERSION":                            "syscall",
+	"syscall.BPF_MISC":                                     "syscall",
+	"syscall.BPF_MSH":                                      "syscall",
+	"syscall.BPF_MUL":                                      "syscall",
+	"syscall.BPF_NEG":                                      "syscall",
+	"syscall.BPF_OR":                                       "syscall",
+	"syscall.BPF_RELEASE":                                  "syscall",
+	"syscall.BPF_RET":                                      "syscall",
+	"syscall.BPF_RSH":                                      "syscall",
+	"syscall.BPF_ST":                                       "syscall",
+	"syscall.BPF_STX":                                      "syscall",
+	"syscall.BPF_SUB":                                      "syscall",
+	"syscall.BPF_TAX":                                      "syscall",
+	"syscall.BPF_TXA":                                      "syscall",
+	"syscall.BPF_T_BINTIME":                                "syscall",
+	"syscall.BPF_T_BINTIME_FAST":                           "syscall",
+	"syscall.BPF_T_BINTIME_MONOTONIC":                      "syscall",
+	"syscall.BPF_T_BINTIME_MONOTONIC_FAST":                 "syscall",
+	"syscall.BPF_T_FAST":                                   "syscall",
+	"syscall.BPF_T_FLAG_MASK":                              "syscall",
+	"syscall.BPF_T_FORMAT_MASK":                            "syscall",
+	"syscall.BPF_T_MICROTIME":                              "syscall",
+	"syscall.BPF_T_MICROTIME_FAST":                         "syscall",
+	"syscall.BPF_T_MICROTIME_MONOTONIC":                    "syscall",
+	"syscall.BPF_T_MICROTIME_MONOTONIC_FAST":               "syscall",
+	"syscall.BPF_T_MONOTONIC":                              "syscall",
+	"syscall.BPF_T_MONOTONIC_FAST":                         "syscall",
+	"syscall.BPF_T_NANOTIME":                               "syscall",
+	"syscall.BPF_T_NANOTIME_FAST":                          "syscall",
+	"syscall.BPF_T_NANOTIME_MONOTONIC":                     "syscall",
+	"syscall.BPF_T_NANOTIME_MONOTONIC_FAST":                "syscall",
+	"syscall.BPF_T_NONE":                                   "syscall",
+	"syscall.BPF_T_NORMAL":                                 "syscall",
+	"syscall.BPF_W":                                        "syscall",
+	"syscall.BPF_X":                                        "syscall",
+	"syscall.BRKINT":                                       "syscall",
+	"syscall.Bind":                                         "syscall",
+	"syscall.BindToDevice":                                 "syscall",
+	"syscall.BpfBuflen":                                    "syscall",
+	"syscall.BpfDatalink":                                  "syscall",
+	"syscall.BpfHdr":                                       "syscall",
+	"syscall.BpfHeadercmpl":                                "syscall",
+	"syscall.BpfInsn":                                      "syscall",
+	"syscall.BpfInterface":                                 "syscall",
+	"syscall.BpfJump":                                      "syscall",
+	"syscall.BpfProgram":                                   "syscall",
+	"syscall.BpfStat":                                      "syscall",
+	"syscall.BpfStats":                                     "syscall",
+	"syscall.BpfStmt":                                      "syscall",
+	"syscall.BpfTimeout":                                   "syscall",
+	"syscall.BpfTimeval":                                   "syscall",
+	"syscall.BpfVersion":                                   "syscall",
+	"syscall.BpfZbuf":                                      "syscall",
+	"syscall.BpfZbufHeader":                                "syscall",
+	"syscall.ByHandleFileInformation":                      "syscall",
+	"syscall.BytePtrFromString":                            "syscall",
+	"syscall.ByteSliceFromString":                          "syscall",
+	"syscall.CCR0_FLUSH":                                   "syscall",
+	"syscall.CERT_CHAIN_POLICY_AUTHENTICODE":               "syscall",
+	"syscall.CERT_CHAIN_POLICY_AUTHENTICODE_TS":            "syscall",
+	"syscall.CERT_CHAIN_POLICY_BASE":                       "syscall",
+	"syscall.CERT_CHAIN_POLICY_BASIC_CONSTRAINTS":          "syscall",
+	"syscall.CERT_CHAIN_POLICY_EV":                         "syscall",
+	"syscall.CERT_CHAIN_POLICY_MICROSOFT_ROOT":             "syscall",
+	"syscall.CERT_CHAIN_POLICY_NT_AUTH":                    "syscall",
+	"syscall.CERT_CHAIN_POLICY_SSL":                        "syscall",
+	"syscall.CERT_E_CN_NO_MATCH":                           "syscall",
+	"syscall.CERT_E_EXPIRED":                               "syscall",
+	"syscall.CERT_E_PURPOSE":                               "syscall",
+	"syscall.CERT_E_ROLE":                                  "syscall",
+	"syscall.CERT_E_UNTRUSTEDROOT":                         "syscall",
+	"syscall.CERT_STORE_ADD_ALWAYS":                        "syscall",
+	"syscall.CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG":  "syscall",
+	"syscall.CERT_STORE_PROV_MEMORY":                       "syscall",
+	"syscall.CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT":      "syscall",
+	"syscall.CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT":   "syscall",
+	"syscall.CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT": "syscall",
+	"syscall.CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT":    "syscall",
+	"syscall.CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT": "syscall",
+	"syscall.CERT_TRUST_INVALID_BASIC_CONSTRAINTS":         "syscall",
+	"syscall.CERT_TRUST_INVALID_EXTENSION":                 "syscall",
+	"syscall.CERT_TRUST_INVALID_NAME_CONSTRAINTS":          "syscall",
+	"syscall.CERT_TRUST_INVALID_POLICY_CONSTRAINTS":        "syscall",
+	"syscall.CERT_TRUST_IS_CYCLIC":                         "syscall",
+	"syscall.CERT_TRUST_IS_EXPLICIT_DISTRUST":              "syscall",
+	"syscall.CERT_TRUST_IS_NOT_SIGNATURE_VALID":            "syscall",
+	"syscall.CERT_TRUST_IS_NOT_TIME_VALID":                 "syscall",
+	"syscall.CERT_TRUST_IS_NOT_VALID_FOR_USAGE":            "syscall",
+	"syscall.CERT_TRUST_IS_OFFLINE_REVOCATION":             "syscall",
+	"syscall.CERT_TRUST_IS_REVOKED":                        "syscall",
+	"syscall.CERT_TRUST_IS_UNTRUSTED_ROOT":                 "syscall",
+	"syscall.CERT_TRUST_NO_ERROR":                          "syscall",
+	"syscall.CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY":          "syscall",
+	"syscall.CERT_TRUST_REVOCATION_STATUS_UNKNOWN":         "syscall",
+	"syscall.CFLUSH":                                       "syscall",
+	"syscall.CLOCAL":                                       "syscall",
+	"syscall.CLONE_CHILD_CLEARTID":                         "syscall",
+	"syscall.CLONE_CHILD_SETTID":                           "syscall",
+	"syscall.CLONE_CSIGNAL":                                "syscall",
+	"syscall.CLONE_DETACHED":                               "syscall",
+	"syscall.CLONE_FILES":                                  "syscall",
+	"syscall.CLONE_FS":                                     "syscall",
+	"syscall.CLONE_IO":                                     "syscall",
+	"syscall.CLONE_NEWIPC":                                 "syscall",
+	"syscall.CLONE_NEWNET":                                 "syscall",
+	"syscall.CLONE_NEWNS":                                  "syscall",
+	"syscall.CLONE_NEWPID":                                 "syscall",
+	"syscall.CLONE_NEWUSER":                                "syscall",
+	"syscall.CLONE_NEWUTS":                                 "syscall",
+	"syscall.CLONE_PARENT":                                 "syscall",
+	"syscall.CLONE_PARENT_SETTID":                          "syscall",
+	"syscall.CLONE_PID":                                    "syscall",
+	"syscall.CLONE_PTRACE":                                 "syscall",
+	"syscall.CLONE_SETTLS":                                 "syscall",
+	"syscall.CLONE_SIGHAND":                                "syscall",
+	"syscall.CLONE_SYSVSEM":                                "syscall",
+	"syscall.CLONE_THREAD":                                 "syscall",
+	"syscall.CLONE_UNTRACED":                               "syscall",
+	"syscall.CLONE_VFORK":                                  "syscall",
+	"syscall.CLONE_VM":                                     "syscall",
+	"syscall.CPUID_CFLUSH":                                 "syscall",
+	"syscall.CREAD":                                        "syscall",
+	"syscall.CREATE_ALWAYS":                                "syscall",
+	"syscall.CREATE_NEW":                                   "syscall",
+	"syscall.CREATE_NEW_PROCESS_GROUP":                     "syscall",
+	"syscall.CREATE_UNICODE_ENVIRONMENT":                   "syscall",
+	"syscall.CRYPT_DEFAULT_CONTAINER_OPTIONAL":             "syscall",
+	"syscall.CRYPT_DELETEKEYSET":                           "syscall",
+	"syscall.CRYPT_MACHINE_KEYSET":                         "syscall",
+	"syscall.CRYPT_NEWKEYSET":                              "syscall",
+	"syscall.CRYPT_SILENT":                                 "syscall",
+	"syscall.CRYPT_VERIFYCONTEXT":                          "syscall",
+	"syscall.CS5":                                          "syscall",
+	"syscall.CS6":                                          "syscall",
+	"syscall.CS7":                                          "syscall",
+	"syscall.CS8":                                          "syscall",
+	"syscall.CSIZE":                                        "syscall",
+	"syscall.CSTART":                                       "syscall",
+	"syscall.CSTATUS":                                      "syscall",
+	"syscall.CSTOP":                                        "syscall",
+	"syscall.CSTOPB":                                       "syscall",
+	"syscall.CSUSP":                                        "syscall",
+	"syscall.CTL_MAXNAME":                                  "syscall",
+	"syscall.CTL_NET":                                      "syscall",
+	"syscall.CTL_QUERY":                                    "syscall",
+	"syscall.CTRL_BREAK_EVENT":                             "syscall",
+	"syscall.CTRL_C_EVENT":                                 "syscall",
+	"syscall.CancelIo":                                     "syscall",
+	"syscall.CancelIoEx":                                   "syscall",
+	"syscall.CertAddCertificateContextToStore":             "syscall",
+	"syscall.CertChainContext":                             "syscall",
+	"syscall.CertChainElement":                             "syscall",
+	"syscall.CertChainPara":                                "syscall",
+	"syscall.CertChainPolicyPara":                          "syscall",
+	"syscall.CertChainPolicyStatus":                        "syscall",
+	"syscall.CertCloseStore":                               "syscall",
+	"syscall.CertContext":                                  "syscall",
+	"syscall.CertCreateCertificateContext":                 "syscall",
+	"syscall.CertEnhKeyUsage":                              "syscall",
+	"syscall.CertEnumCertificatesInStore":                  "syscall",
+	"syscall.CertFreeCertificateChain":                     "syscall",
+	"syscall.CertFreeCertificateContext":                   "syscall",
+	"syscall.CertGetCertificateChain":                      "syscall",
+	"syscall.CertOpenStore":                                "syscall",
+	"syscall.CertOpenSystemStore":                          "syscall",
+	"syscall.CertRevocationInfo":                           "syscall",
+	"syscall.CertSimpleChain":                              "syscall",
+	"syscall.CertTrustStatus":                              "syscall",
+	"syscall.CertUsageMatch":                               "syscall",
+	"syscall.CertVerifyCertificateChainPolicy":             "syscall",
+	"syscall.Chdir":                                        "syscall",
+	"syscall.CheckBpfVersion":                              "syscall",
+	"syscall.Chflags":                                      "syscall",
+	"syscall.Chmod":                                        "syscall",
+	"syscall.Chown":                                        "syscall",
+	"syscall.Chroot":                                       "syscall",
+	"syscall.Clearenv":                                     "syscall",
+	"syscall.Close":                                        "syscall",
+	"syscall.CloseHandle":                                  "syscall",
+	"syscall.CloseOnExec":                                  "syscall",
+	"syscall.Closesocket":                                  "syscall",
+	"syscall.CmsgLen":                                      "syscall",
+	"syscall.CmsgSpace":                                    "syscall",
+	"syscall.Cmsghdr":                                      "syscall",
+	"syscall.CommandLineToArgv":                            "syscall",
+	"syscall.ComputerName":                                 "syscall",
+	"syscall.Conn":                                         "syscall",
+	"syscall.Connect":                                      "syscall",
+	"syscall.ConnectEx":                                    "syscall",
+	"syscall.ConvertSidToStringSid":                        "syscall",
+	"syscall.ConvertStringSidToSid":                        "syscall",
+	"syscall.CopySid":                                      "syscall",
+	"syscall.Creat":                                        "syscall",
+	"syscall.CreateDirectory":                              "syscall",
+	"syscall.CreateFile":                                   "syscall",
+	"syscall.CreateFileMapping":                            "syscall",
+	"syscall.CreateHardLink":                               "syscall",
+	"syscall.CreateIoCompletionPort":                       "syscall",
+	"syscall.CreatePipe":                                   "syscall",
+	"syscall.CreateProcess":                                "syscall",
+	"syscall.CreateSymbolicLink":                           "syscall",
+	"syscall.CreateToolhelp32Snapshot":                     "syscall",
+	"syscall.Credential":                                   "syscall",
+	"syscall.CryptAcquireContext":                          "syscall",
+	"syscall.CryptGenRandom":                               "syscall",
+	"syscall.CryptReleaseContext":                          "syscall",
+	"syscall.DIOCBSFLUSH":                                  "syscall",
+	"syscall.DIOCOSFPFLUSH":                                "syscall",
+	"syscall.DLL":                                          "syscall",
+	"syscall.DLLError":                                     "syscall",
+	"syscall.DLT_A429":                                     "syscall",
+	"syscall.DLT_A653_ICM":                                 "syscall",
+	"syscall.DLT_AIRONET_HEADER":                           "syscall",
+	"syscall.DLT_AOS":                                      "syscall",
+	"syscall.DLT_APPLE_IP_OVER_IEEE1394":                   "syscall",
+	"syscall.DLT_ARCNET":                                   "syscall",
+	"syscall.DLT_ARCNET_LINUX":                             "syscall",
+	"syscall.DLT_ATM_CLIP":                                 "syscall",
+	"syscall.DLT_ATM_RFC1483":                              "syscall",
+	"syscall.DLT_AURORA":                                   "syscall",
+	"syscall.DLT_AX25":                                     "syscall",
+	"syscall.DLT_AX25_KISS":                                "syscall",
+	"syscall.DLT_BACNET_MS_TP":                             "syscall",
+	"syscall.DLT_BLUETOOTH_HCI_H4":                         "syscall",
+	"syscall.DLT_BLUETOOTH_HCI_H4_WITH_PHDR":               "syscall",
+	"syscall.DLT_CAN20B":                                   "syscall",
+	"syscall.DLT_CAN_SOCKETCAN":                            "syscall",
+	"syscall.DLT_CHAOS":                                    "syscall",
+	"syscall.DLT_CHDLC":                                    "syscall",
+	"syscall.DLT_CISCO_IOS":                                "syscall",
+	"syscall.DLT_C_HDLC":                                   "syscall",
+	"syscall.DLT_C_HDLC_WITH_DIR":                          "syscall",
+	"syscall.DLT_DBUS":                                     "syscall",
+	"syscall.DLT_DECT":                                     "syscall",
+	"syscall.DLT_DOCSIS":                                   "syscall",
+	"syscall.DLT_DVB_CI":                                   "syscall",
+	"syscall.DLT_ECONET":                                   "syscall",
+	"syscall.DLT_EN10MB":                                   "syscall",
+	"syscall.DLT_EN3MB":                                    "syscall",
+	"syscall.DLT_ENC":                                      "syscall",
+	"syscall.DLT_ERF":                                      "syscall",
+	"syscall.DLT_ERF_ETH":                                  "syscall",
+	"syscall.DLT_ERF_POS":                                  "syscall",
+	"syscall.DLT_FC_2":                                     "syscall",
+	"syscall.DLT_FC_2_WITH_FRAME_DELIMS":                   "syscall",
+	"syscall.DLT_FDDI":                                     "syscall",
+	"syscall.DLT_FLEXRAY":                                  "syscall",
+	"syscall.DLT_FRELAY":                                   "syscall",
+	"syscall.DLT_FRELAY_WITH_DIR":                          "syscall",
+	"syscall.DLT_GCOM_SERIAL":                              "syscall",
+	"syscall.DLT_GCOM_T1E1":                                "syscall",
+	"syscall.DLT_GPF_F":                                    "syscall",
+	"syscall.DLT_GPF_T":                                    "syscall",
+	"syscall.DLT_GPRS_LLC":                                 "syscall",
+	"syscall.DLT_GSMTAP_ABIS":                              "syscall",
+	"syscall.DLT_GSMTAP_UM":                                "syscall",
+	"syscall.DLT_HDLC":                                     "syscall",
+	"syscall.DLT_HHDLC":                                    "syscall",
+	"syscall.DLT_HIPPI":                                    "syscall",
+	"syscall.DLT_IBM_SN":                                   "syscall",
+	"syscall.DLT_IBM_SP":                                   "syscall",
+	"syscall.DLT_IEEE802":                                  "syscall",
+	"syscall.DLT_IEEE802_11":                               "syscall",
+	"syscall.DLT_IEEE802_11_RADIO":                         "syscall",
+	"syscall.DLT_IEEE802_11_RADIO_AVS":                     "syscall",
+	"syscall.DLT_IEEE802_15_4":                             "syscall",
+	"syscall.DLT_IEEE802_15_4_LINUX":                       "syscall",
+	"syscall.DLT_IEEE802_15_4_NOFCS":                       "syscall",
+	"syscall.DLT_IEEE802_15_4_NONASK_PHY":                  "syscall",
+	"syscall.DLT_IEEE802_16_MAC_CPS":                       "syscall",
+	"syscall.DLT_IEEE802_16_MAC_CPS_RADIO":                 "syscall",
+	"syscall.DLT_IPFILTER":                                 "syscall",
+	"syscall.DLT_IPMB":                                     "syscall",
+	"syscall.DLT_IPMB_LINUX":                               "syscall",
+	"syscall.DLT_IPNET":                                    "syscall",
+	"syscall.DLT_IPOIB":                                    "syscall",
+	"syscall.DLT_IPV4":                                     "syscall",
+	"syscall.DLT_IPV6":                                     "syscall",
+	"syscall.DLT_IP_OVER_FC":                               "syscall",
+	"syscall.DLT_JUNIPER_ATM1":                             "syscall",
+	"syscall.DLT_JUNIPER_ATM2":                             "syscall",
+	"syscall.DLT_JUNIPER_ATM_CEMIC":                        "syscall",
+	"syscall.DLT_JUNIPER_CHDLC":                            "syscall",
+	"syscall.DLT_JUNIPER_ES":                               "syscall",
+	"syscall.DLT_JUNIPER_ETHER":                            "syscall",
+	"syscall.DLT_JUNIPER_FIBRECHANNEL":                     "syscall",
+	"syscall.DLT_JUNIPER_FRELAY":                           "syscall",
+	"syscall.DLT_JUNIPER_GGSN":                             "syscall",
+	"syscall.DLT_JUNIPER_ISM":                              "syscall",
+	"syscall.DLT_JUNIPER_MFR":                              "syscall",
+	"syscall.DLT_JUNIPER_MLFR":                             "syscall",
+	"syscall.DLT_JUNIPER_MLPPP":                            "syscall",
+	"syscall.DLT_JUNIPER_MONITOR":                          "syscall",
+	"syscall.DLT_JUNIPER_PIC_PEER":                         "syscall",
+	"syscall.DLT_JUNIPER_PPP":                              "syscall",
+	"syscall.DLT_JUNIPER_PPPOE":                            "syscall",
+	"syscall.DLT_JUNIPER_PPPOE_ATM":                        "syscall",
+	"syscall.DLT_JUNIPER_SERVICES":                         "syscall",
+	"syscall.DLT_JUNIPER_SRX_E2E":                          "syscall",
+	"syscall.DLT_JUNIPER_ST":                               "syscall",
+	"syscall.DLT_JUNIPER_VP":                               "syscall",
+	"syscall.DLT_JUNIPER_VS":                               "syscall",
+	"syscall.DLT_LAPB_WITH_DIR":                            "syscall",
+	"syscall.DLT_LAPD":                                     "syscall",
+	"syscall.DLT_LIN":                                      "syscall",
+	"syscall.DLT_LINUX_EVDEV":                              "syscall",
+	"syscall.DLT_LINUX_IRDA":                               "syscall",
+	"syscall.DLT_LINUX_LAPD":                               "syscall",
+	"syscall.DLT_LINUX_PPP_WITHDIRECTION":                  "syscall",
+	"syscall.DLT_LINUX_SLL":                                "syscall",
+	"syscall.DLT_LOOP":                                     "syscall",
+	"syscall.DLT_LTALK":                                    "syscall",
+	"syscall.DLT_MATCHING_MAX":                             "syscall",
+	"syscall.DLT_MATCHING_MIN":                             "syscall",
+	"syscall.DLT_MFR":                                      "syscall",
+	"syscall.DLT_MOST":                                     "syscall",
+	"syscall.DLT_MPEG_2_TS":                                "syscall",
+	"syscall.DLT_MPLS":                                     "syscall",
+	"syscall.DLT_MTP2":                                     "syscall",
+	"syscall.DLT_MTP2_WITH_PHDR":                           "syscall",
+	"syscall.DLT_MTP3":                                     "syscall",
+	"syscall.DLT_MUX27010":                                 "syscall",
+	"syscall.DLT_NETANALYZER":                              "syscall",
+	"syscall.DLT_NETANALYZER_TRANSPARENT":                  "syscall",
+	"syscall.DLT_NFC_LLCP":                                 "syscall",
+	"syscall.DLT_NFLOG":                                    "syscall",
+	"syscall.DLT_NG40":                                     "syscall",
+	"syscall.DLT_NULL":                                     "syscall",
+	"syscall.DLT_PCI_EXP":                                  "syscall",
+	"syscall.DLT_PFLOG":                                    "syscall",
+	"syscall.DLT_PFSYNC":                                   "syscall",
+	"syscall.DLT_PPI":                                      "syscall",
+	"syscall.DLT_PPP":                                      "syscall",
+	"syscall.DLT_PPP_BSDOS":                                "syscall",
+	"syscall.DLT_PPP_ETHER":                                "syscall",
+	"syscall.DLT_PPP_PPPD":                                 "syscall",
+	"syscall.DLT_PPP_SERIAL":                               "syscall",
+	"syscall.DLT_PPP_WITH_DIR":                             "syscall",
+	"syscall.DLT_PPP_WITH_DIRECTION":                       "syscall",
+	"syscall.DLT_PRISM_HEADER":                             "syscall",
+	"syscall.DLT_PRONET":                                   "syscall",
+	"syscall.DLT_RAIF1":                                    "syscall",
+	"syscall.DLT_RAW":                                      "syscall",
+	"syscall.DLT_RAWAF_MASK":                               "syscall",
+	"syscall.DLT_RIO":                                      "syscall",
+	"syscall.DLT_SCCP":                                     "syscall",
+	"syscall.DLT_SITA":                                     "syscall",
+	"syscall.DLT_SLIP":                                     "syscall",
+	"syscall.DLT_SLIP_BSDOS":                               "syscall",
+	"syscall.DLT_STANAG_5066_D_PDU":                        "syscall",
+	"syscall.DLT_SUNATM":                                   "syscall",
+	"syscall.DLT_SYMANTEC_FIREWALL":                        "syscall",
+	"syscall.DLT_TZSP":                                     "syscall",
+	"syscall.DLT_USB":                                      "syscall",
+	"syscall.DLT_USB_LINUX":                                "syscall",
+	"syscall.DLT_USB_LINUX_MMAPPED":                        "syscall",
+	"syscall.DLT_USER0":                                    "syscall",
+	"syscall.DLT_USER1":                                    "syscall",
+	"syscall.DLT_USER10":                                   "syscall",
+	"syscall.DLT_USER11":                                   "syscall",
+	"syscall.DLT_USER12":                                   "syscall",
+	"syscall.DLT_USER13":                                   "syscall",
+	"syscall.DLT_USER14":                                   "syscall",
+	"syscall.DLT_USER15":                                   "syscall",
+	"syscall.DLT_USER2":                                    "syscall",
+	"syscall.DLT_USER3":                                    "syscall",
+	"syscall.DLT_USER4":                                    "syscall",
+	"syscall.DLT_USER5":                                    "syscall",
+	"syscall.DLT_USER6":                                    "syscall",
+	"syscall.DLT_USER7":                                    "syscall",
+	"syscall.DLT_USER8":                                    "syscall",
+	"syscall.DLT_USER9":                                    "syscall",
+	"syscall.DLT_WIHART":                                   "syscall",
+	"syscall.DLT_X2E_SERIAL":                               "syscall",
+	"syscall.DLT_X2E_XORAYA":                               "syscall",
+	"syscall.DNSMXData":                                    "syscall",
+	"syscall.DNSPTRData":                                   "syscall",
+	"syscall.DNSRecord":                                    "syscall",
+	"syscall.DNSSRVData":                                   "syscall",
+	"syscall.DNSTXTData":                                   "syscall",
+	"syscall.DNS_INFO_NO_RECORDS":                          "syscall",
+	"syscall.DNS_TYPE_A":                                   "syscall",
+	"syscall.DNS_TYPE_A6":                                  "syscall",
+	"syscall.DNS_TYPE_AAAA":                                "syscall",
+	"syscall.DNS_TYPE_ADDRS":                               "syscall",
+	"syscall.DNS_TYPE_AFSDB":                               "syscall",
+	"syscall.DNS_TYPE_ALL":                                 "syscall",
+	"syscall.DNS_TYPE_ANY":                                 "syscall",
+	"syscall.DNS_TYPE_ATMA":                                "syscall",
+	"syscall.DNS_TYPE_AXFR":                                "syscall",
+	"syscall.DNS_TYPE_CERT":                                "syscall",
+	"syscall.DNS_TYPE_CNAME":                               "syscall",
+	"syscall.DNS_TYPE_DHCID":                               "syscall",
+	"syscall.DNS_TYPE_DNAME":                               "syscall",
+	"syscall.DNS_TYPE_DNSKEY":                              "syscall",
+	"syscall.DNS_TYPE_DS":                                  "syscall",
+	"syscall.DNS_TYPE_EID":                                 "syscall",
+	"syscall.DNS_TYPE_GID":                                 "syscall",
+	"syscall.DNS_TYPE_GPOS":                                "syscall",
+	"syscall.DNS_TYPE_HINFO":                               "syscall",
+	"syscall.DNS_TYPE_ISDN":                                "syscall",
+	"syscall.DNS_TYPE_IXFR":                                "syscall",
+	"syscall.DNS_TYPE_KEY":                                 "syscall",
+	"syscall.DNS_TYPE_KX":                                  "syscall",
+	"syscall.DNS_TYPE_LOC":                                 "syscall",
+	"syscall.DNS_TYPE_MAILA":                               "syscall",
+	"syscall.DNS_TYPE_MAILB":                               "syscall",
+	"syscall.DNS_TYPE_MB":                                  "syscall",
+	"syscall.DNS_TYPE_MD":                                  "syscall",
+	"syscall.DNS_TYPE_MF":                                  "syscall",
+	"syscall.DNS_TYPE_MG":                                  "syscall",
+	"syscall.DNS_TYPE_MINFO":                               "syscall",
+	"syscall.DNS_TYPE_MR":                                  "syscall",
+	"syscall.DNS_TYPE_MX":                                  "syscall",
+	"syscall.DNS_TYPE_NAPTR":                               "syscall",
+	"syscall.DNS_TYPE_NBSTAT":                              "syscall",
+	"syscall.DNS_TYPE_NIMLOC":                              "syscall",
+	"syscall.DNS_TYPE_NS":                                  "syscall",
+	"syscall.DNS_TYPE_NSAP":                                "syscall",
+	"syscall.DNS_TYPE_NSAPPTR":                             "syscall",
+	"syscall.DNS_TYPE_NSEC":                                "syscall",
+	"syscall.DNS_TYPE_NULL":                                "syscall",
+	"syscall.DNS_TYPE_NXT":                                 "syscall",
+	"syscall.DNS_TYPE_OPT":                                 "syscall",
+	"syscall.DNS_TYPE_PTR":                                 "syscall",
+	"syscall.DNS_TYPE_PX":                                  "syscall",
+	"syscall.DNS_TYPE_RP":                                  "syscall",
+	"syscall.DNS_TYPE_RRSIG":                               "syscall",
+	"syscall.DNS_TYPE_RT":                                  "syscall",
+	"syscall.DNS_TYPE_SIG":                                 "syscall",
+	"syscall.DNS_TYPE_SINK":                                "syscall",
+	"syscall.DNS_TYPE_SOA":                                 "syscall",
+	"syscall.DNS_TYPE_SRV":                                 "syscall",
+	"syscall.DNS_TYPE_TEXT":                                "syscall",
+	"syscall.DNS_TYPE_TKEY":                                "syscall",
+	"syscall.DNS_TYPE_TSIG":                                "syscall",
+	"syscall.DNS_TYPE_UID":                                 "syscall",
+	"syscall.DNS_TYPE_UINFO":                               "syscall",
+	"syscall.DNS_TYPE_UNSPEC":                              "syscall",
+	"syscall.DNS_TYPE_WINS":                                "syscall",
+	"syscall.DNS_TYPE_WINSR":                               "syscall",
+	"syscall.DNS_TYPE_WKS":                                 "syscall",
+	"syscall.DNS_TYPE_X25":                                 "syscall",
+	"syscall.DT_BLK":                                       "syscall",
+	"syscall.DT_CHR":                                       "syscall",
+	"syscall.DT_DIR":                                       "syscall",
+	"syscall.DT_FIFO":                                      "syscall",
+	"syscall.DT_LNK":                                       "syscall",
+	"syscall.DT_REG":                                       "syscall",
+	"syscall.DT_SOCK":                                      "syscall",
+	"syscall.DT_UNKNOWN":                                   "syscall",
+	"syscall.DT_WHT":                                       "syscall",
+	"syscall.DUPLICATE_CLOSE_SOURCE":                       "syscall",
+	"syscall.DUPLICATE_SAME_ACCESS":                        "syscall",
+	"syscall.DeleteFile":                                   "syscall",
+	"syscall.DetachLsf":                                    "syscall",
+	"syscall.DeviceIoControl":                              "syscall",
+	"syscall.Dirent":                                       "syscall",
+	"syscall.DnsNameCompare":                               "syscall",
+	"syscall.DnsQuery":                                     "syscall",
+	"syscall.DnsRecordListFree":                            "syscall",
+	"syscall.DnsSectionAdditional":                         "syscall",
+	"syscall.DnsSectionAnswer":                             "syscall",
+	"syscall.DnsSectionAuthority":                          "syscall",
+	"syscall.DnsSectionQuestion":                           "syscall",
+	"syscall.Dup":                                          "syscall",
+	"syscall.Dup2":                                         "syscall",
+	"syscall.Dup3":                                         "syscall",
+	"syscall.DuplicateHandle":                              "syscall",
+	"syscall.E2BIG":                                        "syscall",
+	"syscall.EACCES":                                       "syscall",
+	"syscall.EADDRINUSE":                                   "syscall",
+	"syscall.EADDRNOTAVAIL":                                "syscall",
+	"syscall.EADV":                                         "syscall",
+	"syscall.EAFNOSUPPORT":                                 "syscall",
+	"syscall.EAGAIN":                                       "syscall",
+	"syscall.EALREADY":                                     "syscall",
+	"syscall.EAUTH":                                        "syscall",
+	"syscall.EBADARCH":                                     "syscall",
+	"syscall.EBADE":                                        "syscall",
+	"syscall.EBADEXEC":                                     "syscall",
+	"syscall.EBADF":                                        "syscall",
+	"syscall.EBADFD":                                       "syscall",
+	"syscall.EBADMACHO":                                    "syscall",
+	"syscall.EBADMSG":                                      "syscall",
+	"syscall.EBADR":                                        "syscall",
+	"syscall.EBADRPC":                                      "syscall",
+	"syscall.EBADRQC":                                      "syscall",
+	"syscall.EBADSLT":                                      "syscall",
+	"syscall.EBFONT":                                       "syscall",
+	"syscall.EBUSY":                                        "syscall",
+	"syscall.ECANCELED":                                    "syscall",
+	"syscall.ECAPMODE":                                     "syscall",
+	"syscall.ECHILD":                                       "syscall",
+	"syscall.ECHO":                                         "syscall",
+	"syscall.ECHOCTL":                                      "syscall",
+	"syscall.ECHOE":                                        "syscall",
+	"syscall.ECHOK":                                        "syscall",
+	"syscall.ECHOKE":                                       "syscall",
+	"syscall.ECHONL":                                       "syscall",
+	"syscall.ECHOPRT":                                      "syscall",
+	"syscall.ECHRNG":                                       "syscall",
+	"syscall.ECOMM":                                        "syscall",
+	"syscall.ECONNABORTED":                                 "syscall",
+	"syscall.ECONNREFUSED":                                 "syscall",
+	"syscall.ECONNRESET":                                   "syscall",
+	"syscall.EDEADLK":                                      "syscall",
+	"syscall.EDEADLOCK":                                    "syscall",
+	"syscall.EDESTADDRREQ":                                 "syscall",
+	"syscall.EDEVERR":                                      "syscall",
+	"syscall.EDOM":                                         "syscall",
+	"syscall.EDOOFUS":                                      "syscall",
+	"syscall.EDOTDOT":                                      "syscall",
+	"syscall.EDQUOT":                                       "syscall",
+	"syscall.EEXIST":                                       "syscall",
+	"syscall.EFAULT":                                       "syscall",
+	"syscall.EFBIG":                                        "syscall",
+	"syscall.EFER_LMA":                                     "syscall",
+	"syscall.EFER_LME":                                     "syscall",
+	"syscall.EFER_NXE":                                     "syscall",
+	"syscall.EFER_SCE":                                     "syscall",
+	"syscall.EFTYPE":                                       "syscall",
+	"syscall.EHOSTDOWN":                                    "syscall",
+	"syscall.EHOSTUNREACH":                                 "syscall",
+	"syscall.EHWPOISON":                                    "syscall",
+	"syscall.EIDRM":                                        "syscall",
+	"syscall.EILSEQ":                                       "syscall",
+	"syscall.EINPROGRESS":                                  "syscall",
+	"syscall.EINTR":                                        "syscall",
+	"syscall.EINVAL":                                       "syscall",
+	"syscall.EIO":                                          "syscall",
+	"syscall.EIPSEC":                                       "syscall",
+	"syscall.EISCONN":                                      "syscall",
+	"syscall.EISDIR":                                       "syscall",
+	"syscall.EISNAM":                                       "syscall",
+	"syscall.EKEYEXPIRED":                                  "syscall",
+	"syscall.EKEYREJECTED":                                 "syscall",
+	"syscall.EKEYREVOKED":                                  "syscall",
+	"syscall.EL2HLT":                                       "syscall",
+	"syscall.EL2NSYNC":                                     "syscall",
+	"syscall.EL3HLT":                                       "syscall",
+	"syscall.EL3RST":                                       "syscall",
+	"syscall.ELAST":                                        "syscall",
+	"syscall.ELF_NGREG":                                    "syscall",
+	"syscall.ELF_PRARGSZ":                                  "syscall",
+	"syscall.ELIBACC":                                      "syscall",
+	"syscall.ELIBBAD":                                      "syscall",
+	"syscall.ELIBEXEC":                                     "syscall",
+	"syscall.ELIBMAX":                                      "syscall",
+	"syscall.ELIBSCN":                                      "syscall",
+	"syscall.ELNRNG":                                       "syscall",
+	"syscall.ELOOP":                                        "syscall",
+	"syscall.EMEDIUMTYPE":                                  "syscall",
+	"syscall.EMFILE":                                       "syscall",
+	"syscall.EMLINK":                                       "syscall",
+	"syscall.EMSGSIZE":                                     "syscall",
+	"syscall.EMT_TAGOVF":                                   "syscall",
+	"syscall.EMULTIHOP":                                    "syscall",
+	"syscall.EMUL_ENABLED":                                 "syscall",
+	"syscall.EMUL_LINUX":                                   "syscall",
+	"syscall.EMUL_LINUX32":                                 "syscall",
+	"syscall.EMUL_MAXID":                                   "syscall",
+	"syscall.EMUL_NATIVE":                                  "syscall",
+	"syscall.ENAMETOOLONG":                                 "syscall",
+	"syscall.ENAVAIL":                                      "syscall",
+	"syscall.ENDRUNDISC":                                   "syscall",
+	"syscall.ENEEDAUTH":                                    "syscall",
+	"syscall.ENETDOWN":                                     "syscall",
+	"syscall.ENETRESET":                                    "syscall",
+	"syscall.ENETUNREACH":                                  "syscall",
+	"syscall.ENFILE":                                       "syscall",
+	"syscall.ENOANO":                                       "syscall",
+	"syscall.ENOATTR":                                      "syscall",
+	"syscall.ENOBUFS":                                      "syscall",
+	"syscall.ENOCSI":                                       "syscall",
+	"syscall.ENODATA":                                      "syscall",
+	"syscall.ENODEV":                                       "syscall",
+	"syscall.ENOENT":                                       "syscall",
+	"syscall.ENOEXEC":                                      "syscall",
+	"syscall.ENOKEY":                                       "syscall",
+	"syscall.ENOLCK":                                       "syscall",
+	"syscall.ENOLINK":                                      "syscall",
+	"syscall.ENOMEDIUM":                                    "syscall",
+	"syscall.ENOMEM":                                       "syscall",
+	"syscall.ENOMSG":                                       "syscall",
+	"syscall.ENONET":                                       "syscall",
+	"syscall.ENOPKG":                                       "syscall",
+	"syscall.ENOPOLICY":                                    "syscall",
+	"syscall.ENOPROTOOPT":                                  "syscall",
+	"syscall.ENOSPC":                                       "syscall",
+	"syscall.ENOSR":                                        "syscall",
+	"syscall.ENOSTR":                                       "syscall",
+	"syscall.ENOSYS":                                       "syscall",
+	"syscall.ENOTBLK":                                      "syscall",
+	"syscall.ENOTCAPABLE":                                  "syscall",
+	"syscall.ENOTCONN":                                     "syscall",
+	"syscall.ENOTDIR":                                      "syscall",
+	"syscall.ENOTEMPTY":                                    "syscall",
+	"syscall.ENOTNAM":                                      "syscall",
+	"syscall.ENOTRECOVERABLE":                              "syscall",
+	"syscall.ENOTSOCK":                                     "syscall",
+	"syscall.ENOTSUP":                                      "syscall",
+	"syscall.ENOTTY":                                       "syscall",
+	"syscall.ENOTUNIQ":                                     "syscall",
+	"syscall.ENXIO":                                        "syscall",
+	"syscall.EN_SW_CTL_INF":                                "syscall",
+	"syscall.EN_SW_CTL_PREC":                               "syscall",
+	"syscall.EN_SW_CTL_ROUND":                              "syscall",
+	"syscall.EN_SW_DATACHAIN":                              "syscall",
+	"syscall.EN_SW_DENORM":                                 "syscall",
+	"syscall.EN_SW_INVOP":                                  "syscall",
+	"syscall.EN_SW_OVERFLOW":                               "syscall",
+	"syscall.EN_SW_PRECLOSS":                               "syscall",
+	"syscall.EN_SW_UNDERFLOW":                              "syscall",
+	"syscall.EN_SW_ZERODIV":                                "syscall",
+	"syscall.EOPNOTSUPP":                                   "syscall",
+	"syscall.EOVERFLOW":                                    "syscall",
+	"syscall.EOWNERDEAD":                                   "syscall",
+	"syscall.EPERM":                                        "syscall",
+	"syscall.EPFNOSUPPORT":                                 "syscall",
+	"syscall.EPIPE":                                        "syscall",
+	"syscall.EPOLLERR":                                     "syscall",
+	"syscall.EPOLLET":                                      "syscall",
+	"syscall.EPOLLHUP":                                     "syscall",
+	"syscall.EPOLLIN":                                      "syscall",
+	"syscall.EPOLLMSG":                                     "syscall",
+	"syscall.EPOLLONESHOT":                                 "syscall",
+	"syscall.EPOLLOUT":                                     "syscall",
+	"syscall.EPOLLPRI":                                     "syscall",
+	"syscall.EPOLLRDBAND":                                  "syscall",
+	"syscall.EPOLLRDHUP":                                   "syscall",
+	"syscall.EPOLLRDNORM":                                  "syscall",
+	"syscall.EPOLLWRBAND":                                  "syscall",
+	"syscall.EPOLLWRNORM":                                  "syscall",
+	"syscall.EPOLL_CLOEXEC":                                "syscall",
+	"syscall.EPOLL_CTL_ADD":                                "syscall",
+	"syscall.EPOLL_CTL_DEL":                                "syscall",
+	"syscall.EPOLL_CTL_MOD":                                "syscall",
+	"syscall.EPOLL_NONBLOCK":                               "syscall",
+	"syscall.EPROCLIM":                                     "syscall",
+	"syscall.EPROCUNAVAIL":                                 "syscall",
+	"syscall.EPROGMISMATCH":                                "syscall",
+	"syscall.EPROGUNAVAIL":                                 "syscall",
+	"syscall.EPROTO":                                       "syscall",
+	"syscall.EPROTONOSUPPORT":                              "syscall",
+	"syscall.EPROTOTYPE":                                   "syscall",
+	"syscall.EPWROFF":                                      "syscall",
+	"syscall.ERANGE":                                       "syscall",
+	"syscall.EREMCHG":                                      "syscall",
+	"syscall.EREMOTE":                                      "syscall",
+	"syscall.EREMOTEIO":                                    "syscall",
+	"syscall.ERESTART":                                     "syscall",
+	"syscall.ERFKILL":                                      "syscall",
+	"syscall.EROFS":                                        "syscall",
+	"syscall.ERPCMISMATCH":                                 "syscall",
+	"syscall.ERROR_ACCESS_DENIED":                          "syscall",
+	"syscall.ERROR_ALREADY_EXISTS":                         "syscall",
+	"syscall.ERROR_BROKEN_PIPE":                            "syscall",
+	"syscall.ERROR_BUFFER_OVERFLOW":                        "syscall",
+	"syscall.ERROR_DIR_NOT_EMPTY":                          "syscall",
+	"syscall.ERROR_ENVVAR_NOT_FOUND":                       "syscall",
+	"syscall.ERROR_FILE_EXISTS":                            "syscall",
+	"syscall.ERROR_FILE_NOT_FOUND":                         "syscall",
+	"syscall.ERROR_HANDLE_EOF":                             "syscall",
+	"syscall.ERROR_INSUFFICIENT_BUFFER":                    "syscall",
+	"syscall.ERROR_IO_PENDING":                             "syscall",
+	"syscall.ERROR_MOD_NOT_FOUND":                          "syscall",
+	"syscall.ERROR_MORE_DATA":                              "syscall",
+	"syscall.ERROR_NETNAME_DELETED":                        "syscall",
+	"syscall.ERROR_NOT_FOUND":                              "syscall",
+	"syscall.ERROR_NO_MORE_FILES":                          "syscall",
+	"syscall.ERROR_OPERATION_ABORTED":                      "syscall",
+	"syscall.ERROR_PATH_NOT_FOUND":                         "syscall",
+	"syscall.ERROR_PRIVILEGE_NOT_HELD":                     "syscall",
+	"syscall.ERROR_PROC_NOT_FOUND":                         "syscall",
+	"syscall.ESHLIBVERS":                                   "syscall",
+	"syscall.ESHUTDOWN":                                    "syscall",
+	"syscall.ESOCKTNOSUPPORT":                              "syscall",
+	"syscall.ESPIPE":                                       "syscall",
+	"syscall.ESRCH":                                        "syscall",
+	"syscall.ESRMNT":                                       "syscall",
+	"syscall.ESTALE":                                       "syscall",
+	"syscall.ESTRPIPE":                                     "syscall",
+	"syscall.ETHERCAP_JUMBO_MTU":                           "syscall",
+	"syscall.ETHERCAP_VLAN_HWTAGGING":                      "syscall",
+	"syscall.ETHERCAP_VLAN_MTU":                            "syscall",
+	"syscall.ETHERMIN":                                     "syscall",
+	"syscall.ETHERMTU":                                     "syscall",
+	"syscall.ETHERMTU_JUMBO":                               "syscall",
+	"syscall.ETHERTYPE_8023":                               "syscall",
+	"syscall.ETHERTYPE_AARP":                               "syscall",
+	"syscall.ETHERTYPE_ACCTON":                             "syscall",
+	"syscall.ETHERTYPE_AEONIC":                             "syscall",
+	"syscall.ETHERTYPE_ALPHA":                              "syscall",
+	"syscall.ETHERTYPE_AMBER":                              "syscall",
+	"syscall.ETHERTYPE_AMOEBA":                             "syscall",
+	"syscall.ETHERTYPE_AOE":                                "syscall",
+	"syscall.ETHERTYPE_APOLLO":                             "syscall",
+	"syscall.ETHERTYPE_APOLLODOMAIN":                       "syscall",
+	"syscall.ETHERTYPE_APPLETALK":                          "syscall",
+	"syscall.ETHERTYPE_APPLITEK":                           "syscall",
+	"syscall.ETHERTYPE_ARGONAUT":                           "syscall",
+	"syscall.ETHERTYPE_ARP":                                "syscall",
+	"syscall.ETHERTYPE_AT":                                 "syscall",
+	"syscall.ETHERTYPE_ATALK":                              "syscall",
+	"syscall.ETHERTYPE_ATOMIC":                             "syscall",
+	"syscall.ETHERTYPE_ATT":                                "syscall",
+	"syscall.ETHERTYPE_ATTSTANFORD":                        "syscall",
+	"syscall.ETHERTYPE_AUTOPHON":                           "syscall",
+	"syscall.ETHERTYPE_AXIS":                               "syscall",
+	"syscall.ETHERTYPE_BCLOOP":                             "syscall",
+	"syscall.ETHERTYPE_BOFL":                               "syscall",
+	"syscall.ETHERTYPE_CABLETRON":                          "syscall",
+	"syscall.ETHERTYPE_CHAOS":                              "syscall",
+	"syscall.ETHERTYPE_COMDESIGN":                          "syscall",
+	"syscall.ETHERTYPE_COMPUGRAPHIC":                       "syscall",
+	"syscall.ETHERTYPE_COUNTERPOINT":                       "syscall",
+	"syscall.ETHERTYPE_CRONUS":                             "syscall",
+	"syscall.ETHERTYPE_CRONUSVLN":                          "syscall",
+	"syscall.ETHERTYPE_DCA":                                "syscall",
+	"syscall.ETHERTYPE_DDE":                                "syscall",
+	"syscall.ETHERTYPE_DEBNI":                              "syscall",
+	"syscall.ETHERTYPE_DECAM":                              "syscall",
+	"syscall.ETHERTYPE_DECCUST":                            "syscall",
+	"syscall.ETHERTYPE_DECDIAG":                            "syscall",
+	"syscall.ETHERTYPE_DECDNS":                             "syscall",
+	"syscall.ETHERTYPE_DECDTS":                             "syscall",
+	"syscall.ETHERTYPE_DECEXPER":                           "syscall",
+	"syscall.ETHERTYPE_DECLAST":                            "syscall",
+	"syscall.ETHERTYPE_DECLTM":                             "syscall",
+	"syscall.ETHERTYPE_DECMUMPS":                           "syscall",
+	"syscall.ETHERTYPE_DECNETBIOS":                         "syscall",
+	"syscall.ETHERTYPE_DELTACON":                           "syscall",
+	"syscall.ETHERTYPE_DIDDLE":                             "syscall",
+	"syscall.ETHERTYPE_DLOG1":                              "syscall",
+	"syscall.ETHERTYPE_DLOG2":                              "syscall",
+	"syscall.ETHERTYPE_DN":                                 "syscall",
+	"syscall.ETHERTYPE_DOGFIGHT":                           "syscall",
+	"syscall.ETHERTYPE_DSMD":                               "syscall",
+	"syscall.ETHERTYPE_ECMA":                               "syscall",
+	"syscall.ETHERTYPE_ENCRYPT":                            "syscall",
+	"syscall.ETHERTYPE_ES":                                 "syscall",
+	"syscall.ETHERTYPE_EXCELAN":                            "syscall",
+	"syscall.ETHERTYPE_EXPERDATA":                          "syscall",
+	"syscall.ETHERTYPE_FLIP":                               "syscall",
+	"syscall.ETHERTYPE_FLOWCONTROL":                        "syscall",
+	"syscall.ETHERTYPE_FRARP":                              "syscall",
+	"syscall.ETHERTYPE_GENDYN":                             "syscall",
+	"syscall.ETHERTYPE_HAYES":                              "syscall",
+	"syscall.ETHERTYPE_HIPPI_FP":                           "syscall",
+	"syscall.ETHERTYPE_HITACHI":                            "syscall",
+	"syscall.ETHERTYPE_HP":                                 "syscall",
+	"syscall.ETHERTYPE_IEEEPUP":                            "syscall",
+	"syscall.ETHERTYPE_IEEEPUPAT":                          "syscall",
+	"syscall.ETHERTYPE_IMLBL":                              "syscall",
+	"syscall.ETHERTYPE_IMLBLDIAG":                          "syscall",
+	"syscall.ETHERTYPE_IP":                                 "syscall",
+	"syscall.ETHERTYPE_IPAS":                               "syscall",
+	"syscall.ETHERTYPE_IPV6":                               "syscall",
+	"syscall.ETHERTYPE_IPX":                                "syscall",
+	"syscall.ETHERTYPE_IPXNEW":                             "syscall",
+	"syscall.ETHERTYPE_KALPANA":                            "syscall",
+	"syscall.ETHERTYPE_LANBRIDGE":                          "syscall",
+	"syscall.ETHERTYPE_LANPROBE":                           "syscall",
+	"syscall.ETHERTYPE_LAT":                                "syscall",
+	"syscall.ETHERTYPE_LBACK":                              "syscall",
+	"syscall.ETHERTYPE_LITTLE":                             "syscall",
+	"syscall.ETHERTYPE_LLDP":                               "syscall",
+	"syscall.ETHERTYPE_LOGICRAFT":                          "syscall",
+	"syscall.ETHERTYPE_LOOPBACK":                           "syscall",
+	"syscall.ETHERTYPE_MATRA":                              "syscall",
+	"syscall.ETHERTYPE_MAX":                                "syscall",
+	"syscall.ETHERTYPE_MERIT":                              "syscall",
+	"syscall.ETHERTYPE_MICP":                               "syscall",
+	"syscall.ETHERTYPE_MOPDL":                              "syscall",
+	"syscall.ETHERTYPE_MOPRC":                              "syscall",
+	"syscall.ETHERTYPE_MOTOROLA":                           "syscall",
+	"syscall.ETHERTYPE_MPLS":                               "syscall",
+	"syscall.ETHERTYPE_MPLS_MCAST":                         "syscall",
+	"syscall.ETHERTYPE_MUMPS":                              "syscall",
+	"syscall.ETHERTYPE_NBPCC":                              "syscall",
+	"syscall.ETHERTYPE_NBPCLAIM":                           "syscall",
+	"syscall.ETHERTYPE_NBPCLREQ":                           "syscall",
+	"syscall.ETHERTYPE_NBPCLRSP":                           "syscall",
+	"syscall.ETHERTYPE_NBPCREQ":                            "syscall",
+	"syscall.ETHERTYPE_NBPCRSP":                            "syscall",
+	"syscall.ETHERTYPE_NBPDG":                              "syscall",
+	"syscall.ETHERTYPE_NBPDGB":                             "syscall",
+	"syscall.ETHERTYPE_NBPDLTE":                            "syscall",
+	"syscall.ETHERTYPE_NBPRAR":                             "syscall",
+	"syscall.ETHERTYPE_NBPRAS":                             "syscall",
+	"syscall.ETHERTYPE_NBPRST":                             "syscall",
+	"syscall.ETHERTYPE_NBPSCD":                             "syscall",
+	"syscall.ETHERTYPE_NBPVCD":                             "syscall",
+	"syscall.ETHERTYPE_NBS":                                "syscall",
+	"syscall.ETHERTYPE_NCD":                                "syscall",
+	"syscall.ETHERTYPE_NESTAR":                             "syscall",
+	"syscall.ETHERTYPE_NETBEUI":                            "syscall",
+	"syscall.ETHERTYPE_NOVELL":                             "syscall",
+	"syscall.ETHERTYPE_NS":                                 "syscall",
+	"syscall.ETHERTYPE_NSAT":                               "syscall",
+	"syscall.ETHERTYPE_NSCOMPAT":                           "syscall",
+	"syscall.ETHERTYPE_NTRAILER":                           "syscall",
+	"syscall.ETHERTYPE_OS9":                                "syscall",
+	"syscall.ETHERTYPE_OS9NET":                             "syscall",
+	"syscall.ETHERTYPE_PACER":                              "syscall",
+	"syscall.ETHERTYPE_PAE":                                "syscall",
+	"syscall.ETHERTYPE_PCS":                                "syscall",
+	"syscall.ETHERTYPE_PLANNING":                           "syscall",
+	"syscall.ETHERTYPE_PPP":                                "syscall",
+	"syscall.ETHERTYPE_PPPOE":                              "syscall",
+	"syscall.ETHERTYPE_PPPOEDISC":                          "syscall",
+	"syscall.ETHERTYPE_PRIMENTS":                           "syscall",
+	"syscall.ETHERTYPE_PUP":                                "syscall",
+	"syscall.ETHERTYPE_PUPAT":                              "syscall",
+	"syscall.ETHERTYPE_QINQ":                               "syscall",
+	"syscall.ETHERTYPE_RACAL":                              "syscall",
+	"syscall.ETHERTYPE_RATIONAL":                           "syscall",
+	"syscall.ETHERTYPE_RAWFR":                              "syscall",
+	"syscall.ETHERTYPE_RCL":                                "syscall",
+	"syscall.ETHERTYPE_RDP":                                "syscall",
+	"syscall.ETHERTYPE_RETIX":                              "syscall",
+	"syscall.ETHERTYPE_REVARP":                             "syscall",
+	"syscall.ETHERTYPE_SCA":                                "syscall",
+	"syscall.ETHERTYPE_SECTRA":                             "syscall",
+	"syscall.ETHERTYPE_SECUREDATA":                         "syscall",
+	"syscall.ETHERTYPE_SGITW":                              "syscall",
+	"syscall.ETHERTYPE_SG_BOUNCE":                          "syscall",
+	"syscall.ETHERTYPE_SG_DIAG":                            "syscall",
+	"syscall.ETHERTYPE_SG_NETGAMES":                        "syscall",
+	"syscall.ETHERTYPE_SG_RESV":                            "syscall",
+	"syscall.ETHERTYPE_SIMNET":                             "syscall",
+	"syscall.ETHERTYPE_SLOW":                               "syscall",
+	"syscall.ETHERTYPE_SLOWPROTOCOLS":                      "syscall",
+	"syscall.ETHERTYPE_SNA":                                "syscall",
+	"syscall.ETHERTYPE_SNMP":                               "syscall",
+	"syscall.ETHERTYPE_SONIX":                              "syscall",
+	"syscall.ETHERTYPE_SPIDER":                             "syscall",
+	"syscall.ETHERTYPE_SPRITE":                             "syscall",
+	"syscall.ETHERTYPE_STP":                                "syscall",
+	"syscall.ETHERTYPE_TALARIS":                            "syscall",
+	"syscall.ETHERTYPE_TALARISMC":                          "syscall",
+	"syscall.ETHERTYPE_TCPCOMP":                            "syscall",
+	"syscall.ETHERTYPE_TCPSM":                              "syscall",
+	"syscall.ETHERTYPE_TEC":                                "syscall",
+	"syscall.ETHERTYPE_TIGAN":                              "syscall",
+	"syscall.ETHERTYPE_TRAIL":                              "syscall",
+	"syscall.ETHERTYPE_TRANSETHER":                         "syscall",
+	"syscall.ETHERTYPE_TYMSHARE":                           "syscall",
+	"syscall.ETHERTYPE_UBBST":                              "syscall",
+	"syscall.ETHERTYPE_UBDEBUG":                            "syscall",
+	"syscall.ETHERTYPE_UBDIAGLOOP":                         "syscall",
+	"syscall.ETHERTYPE_UBDL":                               "syscall",
+	"syscall.ETHERTYPE_UBNIU":                              "syscall",
+	"syscall.ETHERTYPE_UBNMC":                              "syscall",
+	"syscall.ETHERTYPE_VALID":                              "syscall",
+	"syscall.ETHERTYPE_VARIAN":                             "syscall",
+	"syscall.ETHERTYPE_VAXELN":                             "syscall",
+	"syscall.ETHERTYPE_VEECO":                              "syscall",
+	"syscall.ETHERTYPE_VEXP":                               "syscall",
+	"syscall.ETHERTYPE_VGLAB":                              "syscall",
+	"syscall.ETHERTYPE_VINES":                              "syscall",
+	"syscall.ETHERTYPE_VINESECHO":                          "syscall",
+	"syscall.ETHERTYPE_VINESLOOP":                          "syscall",
+	"syscall.ETHERTYPE_VITAL":                              "syscall",
+	"syscall.ETHERTYPE_VLAN":                               "syscall",
+	"syscall.ETHERTYPE_VLTLMAN":                            "syscall",
+	"syscall.ETHERTYPE_VPROD":                              "syscall",
+	"syscall.ETHERTYPE_VURESERVED":                         "syscall",
+	"syscall.ETHERTYPE_WATERLOO":                           "syscall",
+	"syscall.ETHERTYPE_WELLFLEET":                          "syscall",
+	"syscall.ETHERTYPE_X25":                                "syscall",
+	"syscall.ETHERTYPE_X75":                                "syscall",
+	"syscall.ETHERTYPE_XNSSM":                              "syscall",
+	"syscall.ETHERTYPE_XTP":                                "syscall",
+	"syscall.ETHER_ADDR_LEN":                               "syscall",
+	"syscall.ETHER_ALIGN":                                  "syscall",
+	"syscall.ETHER_CRC_LEN":                                "syscall",
+	"syscall.ETHER_CRC_POLY_BE":                            "syscall",
+	"syscall.ETHER_CRC_POLY_LE":                            "syscall",
+	"syscall.ETHER_HDR_LEN":                                "syscall",
+	"syscall.ETHER_MAX_DIX_LEN":                            "syscall",
+	"syscall.ETHER_MAX_LEN":                                "syscall",
+	"syscall.ETHER_MAX_LEN_JUMBO":                          "syscall",
+	"syscall.ETHER_MIN_LEN":                                "syscall",
+	"syscall.ETHER_PPPOE_ENCAP_LEN":                        "syscall",
+	"syscall.ETHER_TYPE_LEN":                               "syscall",
+	"syscall.ETHER_VLAN_ENCAP_LEN":                         "syscall",
+	"syscall.ETH_P_1588":                                   "syscall",
+	"syscall.ETH_P_8021Q":                                  "syscall",
+	"syscall.ETH_P_802_2":                                  "syscall",
+	"syscall.ETH_P_802_3":                                  "syscall",
+	"syscall.ETH_P_AARP":                                   "syscall",
+	"syscall.ETH_P_ALL":                                    "syscall",
+	"syscall.ETH_P_AOE":                                    "syscall",
+	"syscall.ETH_P_ARCNET":                                 "syscall",
+	"syscall.ETH_P_ARP":                                    "syscall",
+	"syscall.ETH_P_ATALK":                                  "syscall",
+	"syscall.ETH_P_ATMFATE":                                "syscall",
+	"syscall.ETH_P_ATMMPOA":                                "syscall",
+	"syscall.ETH_P_AX25":                                   "syscall",
+	"syscall.ETH_P_BPQ":                                    "syscall",
+	"syscall.ETH_P_CAIF":                                   "syscall",
+	"syscall.ETH_P_CAN":                                    "syscall",
+	"syscall.ETH_P_CONTROL":                                "syscall",
+	"syscall.ETH_P_CUST":                                   "syscall",
+	"syscall.ETH_P_DDCMP":                                  "syscall",
+	"syscall.ETH_P_DEC":                                    "syscall",
+	"syscall.ETH_P_DIAG":                                   "syscall",
+	"syscall.ETH_P_DNA_DL":                                 "syscall",
+	"syscall.ETH_P_DNA_RC":                                 "syscall",
+	"syscall.ETH_P_DNA_RT":                                 "syscall",
+	"syscall.ETH_P_DSA":                                    "syscall",
+	"syscall.ETH_P_ECONET":                                 "syscall",
+	"syscall.ETH_P_EDSA":                                   "syscall",
+	"syscall.ETH_P_FCOE":                                   "syscall",
+	"syscall.ETH_P_FIP":                                    "syscall",
+	"syscall.ETH_P_HDLC":                                   "syscall",
+	"syscall.ETH_P_IEEE802154":                             "syscall",
+	"syscall.ETH_P_IEEEPUP":                                "syscall",
+	"syscall.ETH_P_IEEEPUPAT":                              "syscall",
+	"syscall.ETH_P_IP":                                     "syscall",
+	"syscall.ETH_P_IPV6":                                   "syscall",
+	"syscall.ETH_P_IPX":                                    "syscall",
+	"syscall.ETH_P_IRDA":                                   "syscall",
+	"syscall.ETH_P_LAT":                                    "syscall",
+	"syscall.ETH_P_LINK_CTL":                               "syscall",
+	"syscall.ETH_P_LOCALTALK":                              "syscall",
+	"syscall.ETH_P_LOOP":                                   "syscall",
+	"syscall.ETH_P_MOBITEX":                                "syscall",
+	"syscall.ETH_P_MPLS_MC":                                "syscall",
+	"syscall.ETH_P_MPLS_UC":                                "syscall",
+	"syscall.ETH_P_PAE":                                    "syscall",
+	"syscall.ETH_P_PAUSE":                                  "syscall",
+	"syscall.ETH_P_PHONET":                                 "syscall",
+	"syscall.ETH_P_PPPTALK":                                "syscall",
+	"syscall.ETH_P_PPP_DISC":                               "syscall",
+	"syscall.ETH_P_PPP_MP":                                 "syscall",
+	"syscall.ETH_P_PPP_SES":                                "syscall",
+	"syscall.ETH_P_PUP":                                    "syscall",
+	"syscall.ETH_P_PUPAT":                                  "syscall",
+	"syscall.ETH_P_RARP":                                   "syscall",
+	"syscall.ETH_P_SCA":                                    "syscall",
+	"syscall.ETH_P_SLOW":                                   "syscall",
+	"syscall.ETH_P_SNAP":                                   "syscall",
+	"syscall.ETH_P_TEB":                                    "syscall",
+	"syscall.ETH_P_TIPC":                                   "syscall",
+	"syscall.ETH_P_TRAILER":                                "syscall",
+	"syscall.ETH_P_TR_802_2":                               "syscall",
+	"syscall.ETH_P_WAN_PPP":                                "syscall",
+	"syscall.ETH_P_WCCP":                                   "syscall",
+	"syscall.ETH_P_X25":                                    "syscall",
+	"syscall.ETIME":                                        "syscall",
+	"syscall.ETIMEDOUT":                                    "syscall",
+	"syscall.ETOOMANYREFS":                                 "syscall",
+	"syscall.ETXTBSY":                                      "syscall",
+	"syscall.EUCLEAN":                                      "syscall",
+	"syscall.EUNATCH":                                      "syscall",
+	"syscall.EUSERS":                                       "syscall",
+	"syscall.EVFILT_AIO":                                   "syscall",
+	"syscall.EVFILT_FS":                                    "syscall",
+	"syscall.EVFILT_LIO":                                   "syscall",
+	"syscall.EVFILT_MACHPORT":                              "syscall",
+	"syscall.EVFILT_PROC":                                  "syscall",
+	"syscall.EVFILT_READ":                                  "syscall",
+	"syscall.EVFILT_SIGNAL":                                "syscall",
+	"syscall.EVFILT_SYSCOUNT":                              "syscall",
+	"syscall.EVFILT_THREADMARKER":                          "syscall",
+	"syscall.EVFILT_TIMER":                                 "syscall",
+	"syscall.EVFILT_USER":                                  "syscall",
+	"syscall.EVFILT_VM":                                    "syscall",
+	"syscall.EVFILT_VNODE":                                 "syscall",
+	"syscall.EVFILT_WRITE":                                 "syscall",
+	"syscall.EV_ADD":                                       "syscall",
+	"syscall.EV_CLEAR":                                     "syscall",
+	"syscall.EV_DELETE":                                    "syscall",
+	"syscall.EV_DISABLE":                                   "syscall",
+	"syscall.EV_DISPATCH":                                  "syscall",
+	"syscall.EV_DROP":                                      "syscall",
+	"syscall.EV_ENABLE":                                    "syscall",
+	"syscall.EV_EOF":                                       "syscall",
+	"syscall.EV_ERROR":                                     "syscall",
+	"syscall.EV_FLAG0":                                     "syscall",
+	"syscall.EV_FLAG1":                                     "syscall",
+	"syscall.EV_ONESHOT":                                   "syscall",
+	"syscall.EV_OOBAND":                                    "syscall",
+	"syscall.EV_POLL":                                      "syscall",
+	"syscall.EV_RECEIPT":                                   "syscall",
+	"syscall.EV_SYSFLAGS":                                  "syscall",
+	"syscall.EWINDOWS":                                     "syscall",
+	"syscall.EWOULDBLOCK":                                  "syscall",
+	"syscall.EXDEV":                                        "syscall",
+	"syscall.EXFULL":                                       "syscall",
+	"syscall.EXTA":                                         "syscall",
+	"syscall.EXTB":                                         "syscall",
+	"syscall.EXTPROC":                                      "syscall",
+	"syscall.Environ":                                      "syscall",
+	"syscall.EpollCreate":                                  "syscall",
+	"syscall.EpollCreate1":                                 "syscall",
+	"syscall.EpollCtl":                                     "syscall",
+	"syscall.EpollEvent":                                   "syscall",
+	"syscall.EpollWait":                                    "syscall",
+	"syscall.Errno":                                        "syscall",
+	"syscall.EscapeArg":                                    "syscall",
+	"syscall.Exchangedata":                                 "syscall",
+	"syscall.Exec":                                         "syscall",
+	"syscall.Exit":                                         "syscall",
+	"syscall.ExitProcess":                                  "syscall",
+	"syscall.FD_CLOEXEC":                                   "syscall",
+	"syscall.FD_SETSIZE":                                   "syscall",
+	"syscall.FILE_ACTION_ADDED":                            "syscall",
+	"syscall.FILE_ACTION_MODIFIED":                         "syscall",
+	"syscall.FILE_ACTION_REMOVED":                          "syscall",
+	"syscall.FILE_ACTION_RENAMED_NEW_NAME":                 "syscall",
+	"syscall.FILE_ACTION_RENAMED_OLD_NAME":                 "syscall",
+	"syscall.FILE_APPEND_DATA":                             "syscall",
+	"syscall.FILE_ATTRIBUTE_ARCHIVE":                       "syscall",
+	"syscall.FILE_ATTRIBUTE_DIRECTORY":                     "syscall",
+	"syscall.FILE_ATTRIBUTE_HIDDEN":                        "syscall",
+	"syscall.FILE_ATTRIBUTE_NORMAL":                        "syscall",
+	"syscall.FILE_ATTRIBUTE_READONLY":                      "syscall",
+	"syscall.FILE_ATTRIBUTE_REPARSE_POINT":                 "syscall",
+	"syscall.FILE_ATTRIBUTE_SYSTEM":                        "syscall",
+	"syscall.FILE_BEGIN":                                   "syscall",
+	"syscall.FILE_CURRENT":                                 "syscall",
+	"syscall.FILE_END":                                     "syscall",
+	"syscall.FILE_FLAG_BACKUP_SEMANTICS":                   "syscall",
+	"syscall.FILE_FLAG_OPEN_REPARSE_POINT":                 "syscall",
+	"syscall.FILE_FLAG_OVERLAPPED":                         "syscall",
+	"syscall.FILE_LIST_DIRECTORY":                          "syscall",
+	"syscall.FILE_MAP_COPY":                                "syscall",
+	"syscall.FILE_MAP_EXECUTE":                             "syscall",
+	"syscall.FILE_MAP_READ":                                "syscall",
+	"syscall.FILE_MAP_WRITE":                               "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES":                "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_CREATION":                  "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_DIR_NAME":                  "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_FILE_NAME":                 "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS":               "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_LAST_WRITE":                "syscall",
+	"syscall.FILE_NOTIFY_CHANGE_SIZE":                      "syscall",
+	"syscall.FILE_SHARE_DELETE":                            "syscall",
+	"syscall.FILE_SHARE_READ":                              "syscall",
+	"syscall.FILE_SHARE_WRITE":                             "syscall",
+	"syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS":         "syscall",
+	"syscall.FILE_SKIP_SET_EVENT_ON_HANDLE":                "syscall",
+	"syscall.FILE_TYPE_CHAR":                               "syscall",
+	"syscall.FILE_TYPE_DISK":                               "syscall",
+	"syscall.FILE_TYPE_PIPE":                               "syscall",
+	"syscall.FILE_TYPE_REMOTE":                             "syscall",
+	"syscall.FILE_TYPE_UNKNOWN":                            "syscall",
+	"syscall.FILE_WRITE_ATTRIBUTES":                        "syscall",
+	"syscall.FLUSHO":                                       "syscall",
+	"syscall.FORMAT_MESSAGE_ALLOCATE_BUFFER":               "syscall",
+	"syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY":                "syscall",
+	"syscall.FORMAT_MESSAGE_FROM_HMODULE":                  "syscall",
+	"syscall.FORMAT_MESSAGE_FROM_STRING":                   "syscall",
+	"syscall.FORMAT_MESSAGE_FROM_SYSTEM":                   "syscall",
+	"syscall.FORMAT_MESSAGE_IGNORE_INSERTS":                "syscall",
+	"syscall.FORMAT_MESSAGE_MAX_WIDTH_MASK":                "syscall",
+	"syscall.FSCTL_GET_REPARSE_POINT":                      "syscall",
+	"syscall.F_ADDFILESIGS":                                "syscall",
+	"syscall.F_ADDSIGS":                                    "syscall",
+	"syscall.F_ALLOCATEALL":                                "syscall",
+	"syscall.F_ALLOCATECONTIG":                             "syscall",
+	"syscall.F_CANCEL":                                     "syscall",
+	"syscall.F_CHKCLEAN":                                   "syscall",
+	"syscall.F_CLOSEM":                                     "syscall",
+	"syscall.F_DUP2FD":                                     "syscall",
+	"syscall.F_DUP2FD_CLOEXEC":                             "syscall",
+	"syscall.F_DUPFD":                                      "syscall",
+	"syscall.F_DUPFD_CLOEXEC":                              "syscall",
+	"syscall.F_EXLCK":                                      "syscall",
+	"syscall.F_FLUSH_DATA":                                 "syscall",
+	"syscall.F_FREEZE_FS":                                  "syscall",
+	"syscall.F_FSCTL":                                      "syscall",
+	"syscall.F_FSDIRMASK":                                  "syscall",
+	"syscall.F_FSIN":                                       "syscall",
+	"syscall.F_FSINOUT":                                    "syscall",
+	"syscall.F_FSOUT":                                      "syscall",
+	"syscall.F_FSPRIV":                                     "syscall",
+	"syscall.F_FSVOID":                                     "syscall",
+	"syscall.F_FULLFSYNC":                                  "syscall",
+	"syscall.F_GETFD":                                      "syscall",
+	"syscall.F_GETFL":                                      "syscall",
+	"syscall.F_GETLEASE":                                   "syscall",
+	"syscall.F_GETLK":                                      "syscall",
+	"syscall.F_GETLK64":                                    "syscall",
+	"syscall.F_GETLKPID":                                   "syscall",
+	"syscall.F_GETNOSIGPIPE":                               "syscall",
+	"syscall.F_GETOWN":                                     "syscall",
+	"syscall.F_GETOWN_EX":                                  "syscall",
+	"syscall.F_GETPATH":                                    "syscall",
+	"syscall.F_GETPATH_MTMINFO":                            "syscall",
+	"syscall.F_GETPIPE_SZ":                                 "syscall",
+	"syscall.F_GETPROTECTIONCLASS":                         "syscall",
+	"syscall.F_GETSIG":                                     "syscall",
+	"syscall.F_GLOBAL_NOCACHE":                             "syscall",
+	"syscall.F_LOCK":                                       "syscall",
+	"syscall.F_LOG2PHYS":                                   "syscall",
+	"syscall.F_LOG2PHYS_EXT":                               "syscall",
+	"syscall.F_MARKDEPENDENCY":                             "syscall",
+	"syscall.F_MAXFD":                                      "syscall",
+	"syscall.F_NOCACHE":                                    "syscall",
+	"syscall.F_NODIRECT":                                   "syscall",
+	"syscall.F_NOTIFY":                                     "syscall",
+	"syscall.F_OGETLK":                                     "syscall",
+	"syscall.F_OK":                                         "syscall",
+	"syscall.F_OSETLK":                                     "syscall",
+	"syscall.F_OSETLKW":                                    "syscall",
+	"syscall.F_PARAM_MASK":                                 "syscall",
+	"syscall.F_PARAM_MAX":                                  "syscall",
+	"syscall.F_PATHPKG_CHECK":                              "syscall",
+	"syscall.F_PEOFPOSMODE":                                "syscall",
+	"syscall.F_PREALLOCATE":                                "syscall",
+	"syscall.F_RDADVISE":                                   "syscall",
+	"syscall.F_RDAHEAD":                                    "syscall",
+	"syscall.F_RDLCK":                                      "syscall",
+	"syscall.F_READAHEAD":                                  "syscall",
+	"syscall.F_READBOOTSTRAP":                              "syscall",
+	"syscall.F_SETBACKINGSTORE":                            "syscall",
+	"syscall.F_SETFD":                                      "syscall",
+	"syscall.F_SETFL":                                      "syscall",
+	"syscall.F_SETLEASE":                                   "syscall",
+	"syscall.F_SETLK":                                      "syscall",
+	"syscall.F_SETLK64":                                    "syscall",
+	"syscall.F_SETLKW":                                     "syscall",
+	"syscall.F_SETLKW64":                                   "syscall",
+	"syscall.F_SETLK_REMOTE":                               "syscall",
+	"syscall.F_SETNOSIGPIPE":                               "syscall",
+	"syscall.F_SETOWN":                                     "syscall",
+	"syscall.F_SETOWN_EX":                                  "syscall",
+	"syscall.F_SETPIPE_SZ":                                 "syscall",
+	"syscall.F_SETPROTECTIONCLASS":                         "syscall",
+	"syscall.F_SETSIG":                                     "syscall",
+	"syscall.F_SETSIZE":                                    "syscall",
+	"syscall.F_SHLCK":                                      "syscall",
+	"syscall.F_TEST":                                       "syscall",
+	"syscall.F_THAW_FS":                                    "syscall",
+	"syscall.F_TLOCK":                                      "syscall",
+	"syscall.F_ULOCK":                                      "syscall",
+	"syscall.F_UNLCK":                                      "syscall",
+	"syscall.F_UNLCKSYS":                                   "syscall",
+	"syscall.F_VOLPOSMODE":                                 "syscall",
+	"syscall.F_WRITEBOOTSTRAP":                             "syscall",
+	"syscall.F_WRLCK":                                      "syscall",
+	"syscall.Faccessat":                                    "syscall",
+	"syscall.Fallocate":                                    "syscall",
+	"syscall.Fbootstraptransfer_t":                         "syscall",
+	"syscall.Fchdir":                                       "syscall",
+	"syscall.Fchflags":                                     "syscall",
+	"syscall.Fchmod":                                       "syscall",
+	"syscall.Fchmodat":                                     "syscall",
+	"syscall.Fchown":                                       "syscall",
+	"syscall.Fchownat":                                     "syscall",
+	"syscall.FcntlFlock":                                   "syscall",
+	"syscall.FdSet":                                        "syscall",
+	"syscall.Fdatasync":                                    "syscall",
+	"syscall.FileNotifyInformation":                        "syscall",
+	"syscall.Filetime":                                     "syscall",
+	"syscall.FindClose":                                    "syscall",
+	"syscall.FindFirstFile":                                "syscall",
+	"syscall.FindNextFile":                                 "syscall",
+	"syscall.Flock":                                        "syscall",
+	"syscall.Flock_t":                                      "syscall",
+	"syscall.FlushBpf":                                     "syscall",
+	"syscall.FlushFileBuffers":                             "syscall",
+	"syscall.FlushViewOfFile":                              "syscall",
+	"syscall.ForkExec":                                     "syscall",
+	"syscall.ForkLock":                                     "syscall",
+	"syscall.FormatMessage":                                "syscall",
+	"syscall.Fpathconf":                                    "syscall",
+	"syscall.FreeAddrInfoW":                                "syscall",
+	"syscall.FreeEnvironmentStrings":                       "syscall",
+	"syscall.FreeLibrary":                                  "syscall",
+	"syscall.Fsid":                                         "syscall",
+	"syscall.Fstat":                                        "syscall",
+	"syscall.Fstatfs":                                      "syscall",
+	"syscall.Fstore_t":                                     "syscall",
+	"syscall.Fsync":                                        "syscall",
+	"syscall.Ftruncate":                                    "syscall",
+	"syscall.FullPath":                                     "syscall",
+	"syscall.Futimes":                                      "syscall",
+	"syscall.Futimesat":                                    "syscall",
+	"syscall.GENERIC_ALL":                                  "syscall",
+	"syscall.GENERIC_EXECUTE":                              "syscall",
+	"syscall.GENERIC_READ":                                 "syscall",
+	"syscall.GENERIC_WRITE":                                "syscall",
+	"syscall.GUID":                                         "syscall",
+	"syscall.GetAcceptExSockaddrs":                         "syscall",
+	"syscall.GetAdaptersInfo":                              "syscall",
+	"syscall.GetAddrInfoW":                                 "syscall",
+	"syscall.GetCommandLine":                               "syscall",
+	"syscall.GetComputerName":                              "syscall",
+	"syscall.GetConsoleMode":                               "syscall",
+	"syscall.GetCurrentDirectory":                          "syscall",
+	"syscall.GetCurrentProcess":                            "syscall",
+	"syscall.GetEnvironmentStrings":                        "syscall",
+	"syscall.GetEnvironmentVariable":                       "syscall",
+	"syscall.GetExitCodeProcess":                           "syscall",
+	"syscall.GetFileAttributes":                            "syscall",
+	"syscall.GetFileAttributesEx":                          "syscall",
+	"syscall.GetFileExInfoStandard":                        "syscall",
+	"syscall.GetFileExMaxInfoLevel":                        "syscall",
+	"syscall.GetFileInformationByHandle":                   "syscall",
+	"syscall.GetFileType":                                  "syscall",
+	"syscall.GetFullPathName":                              "syscall",
+	"syscall.GetHostByName":                                "syscall",
+	"syscall.GetIfEntry":                                   "syscall",
+	"syscall.GetLastError":                                 "syscall",
+	"syscall.GetLengthSid":                                 "syscall",
+	"syscall.GetLongPathName":                              "syscall",
+	"syscall.GetProcAddress":                               "syscall",
+	"syscall.GetProcessTimes":                              "syscall",
+	"syscall.GetProtoByName":                               "syscall",
+	"syscall.GetQueuedCompletionStatus":                    "syscall",
+	"syscall.GetServByName":                                "syscall",
+	"syscall.GetShortPathName":                             "syscall",
+	"syscall.GetStartupInfo":                               "syscall",
+	"syscall.GetStdHandle":                                 "syscall",
+	"syscall.GetSystemTimeAsFileTime":                      "syscall",
+	"syscall.GetTempPath":                                  "syscall",
+	"syscall.GetTimeZoneInformation":                       "syscall",
+	"syscall.GetTokenInformation":                          "syscall",
+	"syscall.GetUserNameEx":                                "syscall",
+	"syscall.GetUserProfileDirectory":                      "syscall",
+	"syscall.GetVersion":                                   "syscall",
+	"syscall.Getcwd":                                       "syscall",
+	"syscall.Getdents":                                     "syscall",
+	"syscall.Getdirentries":                                "syscall",
+	"syscall.Getdtablesize":                                "syscall",
+	"syscall.Getegid":                                      "syscall",
+	"syscall.Getenv":                                       "syscall",
+	"syscall.Geteuid":                                      "syscall",
+	"syscall.Getfsstat":                                    "syscall",
+	"syscall.Getgid":                                       "syscall",
+	"syscall.Getgroups":                                    "syscall",
+	"syscall.Getpagesize":                                  "syscall",
+	"syscall.Getpeername":                                  "syscall",
+	"syscall.Getpgid":                                      "syscall",
+	"syscall.Getpgrp":                                      "syscall",
+	"syscall.Getpid":                                       "syscall",
+	"syscall.Getppid":                                      "syscall",
+	"syscall.Getpriority":                                  "syscall",
+	"syscall.Getrlimit":                                    "syscall",
+	"syscall.Getrusage":                                    "syscall",
+	"syscall.Getsid":                                       "syscall",
+	"syscall.Getsockname":                                  "syscall",
+	"syscall.Getsockopt":                                   "syscall",
+	"syscall.GetsockoptByte":                               "syscall",
+	"syscall.GetsockoptICMPv6Filter":                       "syscall",
+	"syscall.GetsockoptIPMreq":                             "syscall",
+	"syscall.GetsockoptIPMreqn":                            "syscall",
+	"syscall.GetsockoptIPv6MTUInfo":                        "syscall",
+	"syscall.GetsockoptIPv6Mreq":                           "syscall",
+	"syscall.GetsockoptInet4Addr":                          "syscall",
+	"syscall.GetsockoptInt":                                "syscall",
+	"syscall.GetsockoptUcred":                              "syscall",
+	"syscall.Gettid":                                       "syscall",
+	"syscall.Gettimeofday":                                 "syscall",
+	"syscall.Getuid":                                       "syscall",
+	"syscall.Getwd":                                        "syscall",
+	"syscall.Getxattr":                                     "syscall",
+	"syscall.HANDLE_FLAG_INHERIT":                          "syscall",
+	"syscall.HKEY_CLASSES_ROOT":                            "syscall",
+	"syscall.HKEY_CURRENT_CONFIG":                          "syscall",
+	"syscall.HKEY_CURRENT_USER":                            "syscall",
+	"syscall.HKEY_DYN_DATA":                                "syscall",
+	"syscall.HKEY_LOCAL_MACHINE":                           "syscall",
+	"syscall.HKEY_PERFORMANCE_DATA":                        "syscall",
+	"syscall.HKEY_USERS":                                   "syscall",
+	"syscall.HUPCL":                                        "syscall",
+	"syscall.Handle":                                       "syscall",
+	"syscall.Hostent":                                      "syscall",
+	"syscall.ICANON":                                       "syscall",
+	"syscall.ICMP6_FILTER":                                 "syscall",
+	"syscall.ICMPV6_FILTER":                                "syscall",
+	"syscall.ICMPv6Filter":                                 "syscall",
+	"syscall.ICRNL":                                        "syscall",
+	"syscall.IEXTEN":                                       "syscall",
+	"syscall.IFAN_ARRIVAL":                                 "syscall",
+	"syscall.IFAN_DEPARTURE":                               "syscall",
+	"syscall.IFA_ADDRESS":                                  "syscall",
+	"syscall.IFA_ANYCAST":                                  "syscall",
+	"syscall.IFA_BROADCAST":                                "syscall",
+	"syscall.IFA_CACHEINFO":                                "syscall",
+	"syscall.IFA_F_DADFAILED":                              "syscall",
+	"syscall.IFA_F_DEPRECATED":                             "syscall",
+	"syscall.IFA_F_HOMEADDRESS":                            "syscall",
+	"syscall.IFA_F_NODAD":                                  "syscall",
+	"syscall.IFA_F_OPTIMISTIC":                             "syscall",
+	"syscall.IFA_F_PERMANENT":                              "syscall",
+	"syscall.IFA_F_SECONDARY":                              "syscall",
+	"syscall.IFA_F_TEMPORARY":                              "syscall",
+	"syscall.IFA_F_TENTATIVE":                              "syscall",
+	"syscall.IFA_LABEL":                                    "syscall",
+	"syscall.IFA_LOCAL":                                    "syscall",
+	"syscall.IFA_MAX":                                      "syscall",
+	"syscall.IFA_MULTICAST":                                "syscall",
+	"syscall.IFA_ROUTE":                                    "syscall",
+	"syscall.IFA_UNSPEC":                                   "syscall",
+	"syscall.IFF_ALLMULTI":                                 "syscall",
+	"syscall.IFF_ALTPHYS":                                  "syscall",
+	"syscall.IFF_AUTOMEDIA":                                "syscall",
+	"syscall.IFF_BROADCAST":                                "syscall",
+	"syscall.IFF_CANTCHANGE":                               "syscall",
+	"syscall.IFF_CANTCONFIG":                               "syscall",
+	"syscall.IFF_DEBUG":                                    "syscall",
+	"syscall.IFF_DRV_OACTIVE":                              "syscall",
+	"syscall.IFF_DRV_RUNNING":                              "syscall",
+	"syscall.IFF_DYING":                                    "syscall",
+	"syscall.IFF_DYNAMIC":                                  "syscall",
+	"syscall.IFF_LINK0":                                    "syscall",
+	"syscall.IFF_LINK1":                                    "syscall",
+	"syscall.IFF_LINK2":                                    "syscall",
+	"syscall.IFF_LOOPBACK":                                 "syscall",
+	"syscall.IFF_MASTER":                                   "syscall",
+	"syscall.IFF_MONITOR":                                  "syscall",
+	"syscall.IFF_MULTICAST":                                "syscall",
+	"syscall.IFF_NOARP":                                    "syscall",
+	"syscall.IFF_NOTRAILERS":                               "syscall",
+	"syscall.IFF_NO_PI":                                    "syscall",
+	"syscall.IFF_OACTIVE":                                  "syscall",
+	"syscall.IFF_ONE_QUEUE":                                "syscall",
+	"syscall.IFF_POINTOPOINT":                              "syscall",
+	"syscall.IFF_POINTTOPOINT":                             "syscall",
+	"syscall.IFF_PORTSEL":                                  "syscall",
+	"syscall.IFF_PPROMISC":                                 "syscall",
+	"syscall.IFF_PROMISC":                                  "syscall",
+	"syscall.IFF_RENAMING":                                 "syscall",
+	"syscall.IFF_RUNNING":                                  "syscall",
+	"syscall.IFF_SIMPLEX":                                  "syscall",
+	"syscall.IFF_SLAVE":                                    "syscall",
+	"syscall.IFF_SMART":                                    "syscall",
+	"syscall.IFF_STATICARP":                                "syscall",
+	"syscall.IFF_TAP":                                      "syscall",
+	"syscall.IFF_TUN":                                      "syscall",
+	"syscall.IFF_TUN_EXCL":                                 "syscall",
+	"syscall.IFF_UP":                                       "syscall",
+	"syscall.IFF_VNET_HDR":                                 "syscall",
+	"syscall.IFLA_ADDRESS":                                 "syscall",
+	"syscall.IFLA_BROADCAST":                               "syscall",
+	"syscall.IFLA_COST":                                    "syscall",
+	"syscall.IFLA_IFALIAS":                                 "syscall",
+	"syscall.IFLA_IFNAME":                                  "syscall",
+	"syscall.IFLA_LINK":                                    "syscall",
+	"syscall.IFLA_LINKINFO":                                "syscall",
+	"syscall.IFLA_LINKMODE":                                "syscall",
+	"syscall.IFLA_MAP":                                     "syscall",
+	"syscall.IFLA_MASTER":                                  "syscall",
+	"syscall.IFLA_MAX":                                     "syscall",
+	"syscall.IFLA_MTU":                                     "syscall",
+	"syscall.IFLA_NET_NS_PID":                              "syscall",
+	"syscall.IFLA_OPERSTATE":                               "syscall",
+	"syscall.IFLA_PRIORITY":                                "syscall",
+	"syscall.IFLA_PROTINFO":                                "syscall",
+	"syscall.IFLA_QDISC":                                   "syscall",
+	"syscall.IFLA_STATS":                                   "syscall",
+	"syscall.IFLA_TXQLEN":                                  "syscall",
+	"syscall.IFLA_UNSPEC":                                  "syscall",
+	"syscall.IFLA_WEIGHT":                                  "syscall",
+	"syscall.IFLA_WIRELESS":                                "syscall",
+	"syscall.IFNAMSIZ":                                     "syscall",
+	"syscall.IFT_1822":                                     "syscall",
+	"syscall.IFT_A12MPPSWITCH":                             "syscall",
+	"syscall.IFT_AAL2":                                     "syscall",
+	"syscall.IFT_AAL5":                                     "syscall",
+	"syscall.IFT_ADSL":                                     "syscall",
+	"syscall.IFT_AFLANE8023":                               "syscall",
+	"syscall.IFT_AFLANE8025":                               "syscall",
+	"syscall.IFT_ARAP":                                     "syscall",
+	"syscall.IFT_ARCNET":                                   "syscall",
+	"syscall.IFT_ARCNETPLUS":                               "syscall",
+	"syscall.IFT_ASYNC":                                    "syscall",
+	"syscall.IFT_ATM":                                      "syscall",
+	"syscall.IFT_ATMDXI":                                   "syscall",
+	"syscall.IFT_ATMFUNI":                                  "syscall",
+	"syscall.IFT_ATMIMA":                                   "syscall",
+	"syscall.IFT_ATMLOGICAL":                               "syscall",
+	"syscall.IFT_ATMRADIO":                                 "syscall",
+	"syscall.IFT_ATMSUBINTERFACE":                          "syscall",
+	"syscall.IFT_ATMVCIENDPT":                              "syscall",
+	"syscall.IFT_ATMVIRTUAL":                               "syscall",
+	"syscall.IFT_BGPPOLICYACCOUNTING":                      "syscall",
+	"syscall.IFT_BLUETOOTH":                                "syscall",
+	"syscall.IFT_BRIDGE":                                   "syscall",
+	"syscall.IFT_BSC":                                      "syscall",
+	"syscall.IFT_CARP":                                     "syscall",
+	"syscall.IFT_CCTEMUL":                                  "syscall",
+	"syscall.IFT_CELLULAR":                                 "syscall",
+	"syscall.IFT_CEPT":                                     "syscall",
+	"syscall.IFT_CES":                                      "syscall",
+	"syscall.IFT_CHANNEL":                                  "syscall",
+	"syscall.IFT_CNR":                                      "syscall",
+	"syscall.IFT_COFFEE":                                   "syscall",
+	"syscall.IFT_COMPOSITELINK":                            "syscall",
+	"syscall.IFT_DCN":                                      "syscall",
+	"syscall.IFT_DIGITALPOWERLINE":                         "syscall",
+	"syscall.IFT_DIGITALWRAPPEROVERHEADCHANNEL":            "syscall",
+	"syscall.IFT_DLSW":                                     "syscall",
+	"syscall.IFT_DOCSCABLEDOWNSTREAM":                      "syscall",
+	"syscall.IFT_DOCSCABLEMACLAYER":                        "syscall",
+	"syscall.IFT_DOCSCABLEUPSTREAM":                        "syscall",
+	"syscall.IFT_DOCSCABLEUPSTREAMCHANNEL":                 "syscall",
+	"syscall.IFT_DS0":                                      "syscall",
+	"syscall.IFT_DS0BUNDLE":                                "syscall",
+	"syscall.IFT_DS1FDL":                                   "syscall",
+	"syscall.IFT_DS3":                                      "syscall",
+	"syscall.IFT_DTM":                                      "syscall",
+	"syscall.IFT_DUMMY":                                    "syscall",
+	"syscall.IFT_DVBASILN":                                 "syscall",
+	"syscall.IFT_DVBASIOUT":                                "syscall",
+	"syscall.IFT_DVBRCCDOWNSTREAM":                         "syscall",
+	"syscall.IFT_DVBRCCMACLAYER":                           "syscall",
+	"syscall.IFT_DVBRCCUPSTREAM":                           "syscall",
+	"syscall.IFT_ECONET":                                   "syscall",
+	"syscall.IFT_ENC":                                      "syscall",
+	"syscall.IFT_EON":                                      "syscall",
+	"syscall.IFT_EPLRS":                                    "syscall",
+	"syscall.IFT_ESCON":                                    "syscall",
+	"syscall.IFT_ETHER":                                    "syscall",
+	"syscall.IFT_FAITH":                                    "syscall",
+	"syscall.IFT_FAST":                                     "syscall",
+	"syscall.IFT_FASTETHER":                                "syscall",
+	"syscall.IFT_FASTETHERFX":                              "syscall",
+	"syscall.IFT_FDDI":                                     "syscall",
+	"syscall.IFT_FIBRECHANNEL":                             "syscall",
+	"syscall.IFT_FRAMERELAYINTERCONNECT":                   "syscall",
+	"syscall.IFT_FRAMERELAYMPI":                            "syscall",
+	"syscall.IFT_FRDLCIENDPT":                              "syscall",
+	"syscall.IFT_FRELAY":                                   "syscall",
+	"syscall.IFT_FRELAYDCE":                                "syscall",
+	"syscall.IFT_FRF16MFRBUNDLE":                           "syscall",
+	"syscall.IFT_FRFORWARD":                                "syscall",
+	"syscall.IFT_G703AT2MB":                                "syscall",
+	"syscall.IFT_G703AT64K":                                "syscall",
+	"syscall.IFT_GIF":                                      "syscall",
+	"syscall.IFT_GIGABITETHERNET":                          "syscall",
+	"syscall.IFT_GR303IDT":                                 "syscall",
+	"syscall.IFT_GR303RDT":                                 "syscall",
+	"syscall.IFT_H323GATEKEEPER":                           "syscall",
+	"syscall.IFT_H323PROXY":                                "syscall",
+	"syscall.IFT_HDH1822":                                  "syscall",
+	"syscall.IFT_HDLC":                                     "syscall",
+	"syscall.IFT_HDSL2":                                    "syscall",
+	"syscall.IFT_HIPERLAN2":                                "syscall",
+	"syscall.IFT_HIPPI":                                    "syscall",
+	"syscall.IFT_HIPPIINTERFACE":                           "syscall",
+	"syscall.IFT_HOSTPAD":                                  "syscall",
+	"syscall.IFT_HSSI":                                     "syscall",
+	"syscall.IFT_HY":                                       "syscall",
+	"syscall.IFT_IBM370PARCHAN":                            "syscall",
+	"syscall.IFT_IDSL":                                     "syscall",
+	"syscall.IFT_IEEE1394":                                 "syscall",
+	"syscall.IFT_IEEE80211":                                "syscall",
+	"syscall.IFT_IEEE80212":                                "syscall",
+	"syscall.IFT_IEEE8023ADLAG":                            "syscall",
+	"syscall.IFT_IFGSN":                                    "syscall",
+	"syscall.IFT_IMT":                                      "syscall",
+	"syscall.IFT_INFINIBAND":                               "syscall",
+	"syscall.IFT_INTERLEAVE":                               "syscall",
+	"syscall.IFT_IP":                                       "syscall",
+	"syscall.IFT_IPFORWARD":                                "syscall",
+	"syscall.IFT_IPOVERATM":                                "syscall",
+	"syscall.IFT_IPOVERCDLC":                               "syscall",
+	"syscall.IFT_IPOVERCLAW":                               "syscall",
+	"syscall.IFT_IPSWITCH":                                 "syscall",
+	"syscall.IFT_IPXIP":                                    "syscall",
+	"syscall.IFT_ISDN":                                     "syscall",
+	"syscall.IFT_ISDNBASIC":                                "syscall",
+	"syscall.IFT_ISDNPRIMARY":                              "syscall",
+	"syscall.IFT_ISDNS":                                    "syscall",
+	"syscall.IFT_ISDNU":                                    "syscall",
+	"syscall.IFT_ISO88022LLC":                              "syscall",
+	"syscall.IFT_ISO88023":                                 "syscall",
+	"syscall.IFT_ISO88024":                                 "syscall",
+	"syscall.IFT_ISO88025":                                 "syscall",
+	"syscall.IFT_ISO88025CRFPINT":                          "syscall",
+	"syscall.IFT_ISO88025DTR":                              "syscall",
+	"syscall.IFT_ISO88025FIBER":                            "syscall",
+	"syscall.IFT_ISO88026":                                 "syscall",
+	"syscall.IFT_ISUP":                                     "syscall",
+	"syscall.IFT_L2VLAN":                                   "syscall",
+	"syscall.IFT_L3IPVLAN":                                 "syscall",
+	"syscall.IFT_L3IPXVLAN":                                "syscall",
+	"syscall.IFT_LAPB":                                     "syscall",
+	"syscall.IFT_LAPD":                                     "syscall",
+	"syscall.IFT_LAPF":                                     "syscall",
+	"syscall.IFT_LINEGROUP":                                "syscall",
+	"syscall.IFT_LOCALTALK":                                "syscall",
+	"syscall.IFT_LOOP":                                     "syscall",
+	"syscall.IFT_MEDIAMAILOVERIP":                          "syscall",
+	"syscall.IFT_MFSIGLINK":                                "syscall",
+	"syscall.IFT_MIOX25":                                   "syscall",
+	"syscall.IFT_MODEM":                                    "syscall",
+	"syscall.IFT_MPC":                                      "syscall",
+	"syscall.IFT_MPLS":                                     "syscall",
+	"syscall.IFT_MPLSTUNNEL":                               "syscall",
+	"syscall.IFT_MSDSL":                                    "syscall",
+	"syscall.IFT_MVL":                                      "syscall",
+	"syscall.IFT_MYRINET":                                  "syscall",
+	"syscall.IFT_NFAS":                                     "syscall",
+	"syscall.IFT_NSIP":                                     "syscall",
+	"syscall.IFT_OPTICALCHANNEL":                           "syscall",
+	"syscall.IFT_OPTICALTRANSPORT":                         "syscall",
+	"syscall.IFT_OTHER":                                    "syscall",
+	"syscall.IFT_P10":                                      "syscall",
+	"syscall.IFT_P80":                                      "syscall",
+	"syscall.IFT_PARA":                                     "syscall",
+	"syscall.IFT_PDP":                                      "syscall",
+	"syscall.IFT_PFLOG":                                    "syscall",
+	"syscall.IFT_PFLOW":                                    "syscall",
+	"syscall.IFT_PFSYNC":                                   "syscall",
+	"syscall.IFT_PLC":                                      "syscall",
+	"syscall.IFT_PON155":                                   "syscall",
+	"syscall.IFT_PON622":                                   "syscall",
+	"syscall.IFT_POS":                                      "syscall",
+	"syscall.IFT_PPP":                                      "syscall",
+	"syscall.IFT_PPPMULTILINKBUNDLE":                       "syscall",
+	"syscall.IFT_PROPATM":                                  "syscall",
+	"syscall.IFT_PROPBWAP2MP":                              "syscall",
+	"syscall.IFT_PROPCNLS":                                 "syscall",
+	"syscall.IFT_PROPDOCSWIRELESSDOWNSTREAM":               "syscall",
+	"syscall.IFT_PROPDOCSWIRELESSMACLAYER":                 "syscall",
+	"syscall.IFT_PROPDOCSWIRELESSUPSTREAM":                 "syscall",
+	"syscall.IFT_PROPMUX":                                  "syscall",
+	"syscall.IFT_PROPVIRTUAL":                              "syscall",
+	"syscall.IFT_PROPWIRELESSP2P":                          "syscall",
+	"syscall.IFT_PTPSERIAL":                                "syscall",
+	"syscall.IFT_PVC":                                      "syscall",
+	"syscall.IFT_Q2931":                                    "syscall",
+	"syscall.IFT_QLLC":                                     "syscall",
+	"syscall.IFT_RADIOMAC":                                 "syscall",
+	"syscall.IFT_RADSL":                                    "syscall",
+	"syscall.IFT_REACHDSL":                                 "syscall",
+	"syscall.IFT_RFC1483":                                  "syscall",
+	"syscall.IFT_RS232":                                    "syscall",
+	"syscall.IFT_RSRB":                                     "syscall",
+	"syscall.IFT_SDLC":                                     "syscall",
+	"syscall.IFT_SDSL":                                     "syscall",
+	"syscall.IFT_SHDSL":                                    "syscall",
+	"syscall.IFT_SIP":                                      "syscall",
+	"syscall.IFT_SIPSIG":                                   "syscall",
+	"syscall.IFT_SIPTG":                                    "syscall",
+	"syscall.IFT_SLIP":                                     "syscall",
+	"syscall.IFT_SMDSDXI":                                  "syscall",
+	"syscall.IFT_SMDSICIP":                                 "syscall",
+	"syscall.IFT_SONET":                                    "syscall",
+	"syscall.IFT_SONETOVERHEADCHANNEL":                     "syscall",
+	"syscall.IFT_SONETPATH":                                "syscall",
+	"syscall.IFT_SONETVT":                                  "syscall",
+	"syscall.IFT_SRP":                                      "syscall",
+	"syscall.IFT_SS7SIGLINK":                               "syscall",
+	"syscall.IFT_STACKTOSTACK":                             "syscall",
+	"syscall.IFT_STARLAN":                                  "syscall",
+	"syscall.IFT_STF":                                      "syscall",
+	"syscall.IFT_T1":                                       "syscall",
+	"syscall.IFT_TDLC":                                     "syscall",
+	"syscall.IFT_TELINK":                                   "syscall",
+	"syscall.IFT_TERMPAD":                                  "syscall",
+	"syscall.IFT_TR008":                                    "syscall",
+	"syscall.IFT_TRANSPHDLC":                               "syscall",
+	"syscall.IFT_TUNNEL":                                   "syscall",
+	"syscall.IFT_ULTRA":                                    "syscall",
+	"syscall.IFT_USB":                                      "syscall",
+	"syscall.IFT_V11":                                      "syscall",
+	"syscall.IFT_V35":                                      "syscall",
+	"syscall.IFT_V36":                                      "syscall",
+	"syscall.IFT_V37":                                      "syscall",
+	"syscall.IFT_VDSL":                                     "syscall",
+	"syscall.IFT_VIRTUALIPADDRESS":                         "syscall",
+	"syscall.IFT_VIRTUALTG":                                "syscall",
+	"syscall.IFT_VOICEDID":                                 "syscall",
+	"syscall.IFT_VOICEEM":                                  "syscall",
+	"syscall.IFT_VOICEEMFGD":                               "syscall",
+	"syscall.IFT_VOICEENCAP":                               "syscall",
+	"syscall.IFT_VOICEFGDEANA":                             "syscall",
+	"syscall.IFT_VOICEFXO":                                 "syscall",
+	"syscall.IFT_VOICEFXS":                                 "syscall",
+	"syscall.IFT_VOICEOVERATM":                             "syscall",
+	"syscall.IFT_VOICEOVERCABLE":                           "syscall",
+	"syscall.IFT_VOICEOVERFRAMERELAY":                      "syscall",
+	"syscall.IFT_VOICEOVERIP":                              "syscall",
+	"syscall.IFT_X213":                                     "syscall",
+	"syscall.IFT_X25":                                      "syscall",
+	"syscall.IFT_X25DDN":                                   "syscall",
+	"syscall.IFT_X25HUNTGROUP":                             "syscall",
+	"syscall.IFT_X25MLP":                                   "syscall",
+	"syscall.IFT_X25PLE":                                   "syscall",
+	"syscall.IFT_XETHER":                                   "syscall",
+	"syscall.IGNBRK":                                       "syscall",
+	"syscall.IGNCR":                                        "syscall",
+	"syscall.IGNORE":                                       "syscall",
+	"syscall.IGNPAR":                                       "syscall",
+	"syscall.IMAXBEL":                                      "syscall",
+	"syscall.INFINITE":                                     "syscall",
+	"syscall.INLCR":                                        "syscall",
+	"syscall.INPCK":                                        "syscall",
+	"syscall.INVALID_FILE_ATTRIBUTES":                      "syscall",
+	"syscall.IN_ACCESS":                                    "syscall",
+	"syscall.IN_ALL_EVENTS":                                "syscall",
+	"syscall.IN_ATTRIB":                                    "syscall",
+	"syscall.IN_CLASSA_HOST":                               "syscall",
+	"syscall.IN_CLASSA_MAX":                                "syscall",
+	"syscall.IN_CLASSA_NET":                                "syscall",
+	"syscall.IN_CLASSA_NSHIFT":                             "syscall",
+	"syscall.IN_CLASSB_HOST":                               "syscall",
+	"syscall.IN_CLASSB_MAX":                                "syscall",
+	"syscall.IN_CLASSB_NET":                                "syscall",
+	"syscall.IN_CLASSB_NSHIFT":                             "syscall",
+	"syscall.IN_CLASSC_HOST":                               "syscall",
+	"syscall.IN_CLASSC_NET":                                "syscall",
+	"syscall.IN_CLASSC_NSHIFT":                             "syscall",
+	"syscall.IN_CLASSD_HOST":                               "syscall",
+	"syscall.IN_CLASSD_NET":                                "syscall",
+	"syscall.IN_CLASSD_NSHIFT":                             "syscall",
+	"syscall.IN_CLOEXEC":                                   "syscall",
+	"syscall.IN_CLOSE":                                     "syscall",
+	"syscall.IN_CLOSE_NOWRITE":                             "syscall",
+	"syscall.IN_CLOSE_WRITE":                               "syscall",
+	"syscall.IN_CREATE":                                    "syscall",
+	"syscall.IN_DELETE":                                    "syscall",
+	"syscall.IN_DELETE_SELF":                               "syscall",
+	"syscall.IN_DONT_FOLLOW":                               "syscall",
+	"syscall.IN_EXCL_UNLINK":                               "syscall",
+	"syscall.IN_IGNORED":                                   "syscall",
+	"syscall.IN_ISDIR":                                     "syscall",
+	"syscall.IN_LINKLOCALNETNUM":                           "syscall",
+	"syscall.IN_LOOPBACKNET":                               "syscall",
+	"syscall.IN_MASK_ADD":                                  "syscall",
+	"syscall.IN_MODIFY":                                    "syscall",
+	"syscall.IN_MOVE":                                      "syscall",
+	"syscall.IN_MOVED_FROM":                                "syscall",
+	"syscall.IN_MOVED_TO":                                  "syscall",
+	"syscall.IN_MOVE_SELF":                                 "syscall",
+	"syscall.IN_NONBLOCK":                                  "syscall",
+	"syscall.IN_ONESHOT":                                   "syscall",
+	"syscall.IN_ONLYDIR":                                   "syscall",
+	"syscall.IN_OPEN":                                      "syscall",
+	"syscall.IN_Q_OVERFLOW":                                "syscall",
+	"syscall.IN_RFC3021_HOST":                              "syscall",
+	"syscall.IN_RFC3021_MASK":                              "syscall",
+	"syscall.IN_RFC3021_NET":                               "syscall",
+	"syscall.IN_RFC3021_NSHIFT":                            "syscall",
+	"syscall.IN_UNMOUNT":                                   "syscall",
+	"syscall.IOC_IN":                                       "syscall",
+	"syscall.IOC_INOUT":                                    "syscall",
+	"syscall.IOC_OUT":                                      "syscall",
+	"syscall.IOC_VENDOR":                                   "syscall",
+	"syscall.IOC_WS2":                                      "syscall",
+	"syscall.IO_REPARSE_TAG_SYMLINK":                       "syscall",
+	"syscall.IPMreq":                                       "syscall",
+	"syscall.IPMreqn":                                      "syscall",
+	"syscall.IPPROTO_3PC":                                  "syscall",
+	"syscall.IPPROTO_ADFS":                                 "syscall",
+	"syscall.IPPROTO_AH":                                   "syscall",
+	"syscall.IPPROTO_AHIP":                                 "syscall",
+	"syscall.IPPROTO_APES":                                 "syscall",
+	"syscall.IPPROTO_ARGUS":                                "syscall",
+	"syscall.IPPROTO_AX25":                                 "syscall",
+	"syscall.IPPROTO_BHA":                                  "syscall",
+	"syscall.IPPROTO_BLT":                                  "syscall",
+	"syscall.IPPROTO_BRSATMON":                             "syscall",
+	"syscall.IPPROTO_CARP":                                 "syscall",
+	"syscall.IPPROTO_CFTP":                                 "syscall",
+	"syscall.IPPROTO_CHAOS":                                "syscall",
+	"syscall.IPPROTO_CMTP":                                 "syscall",
+	"syscall.IPPROTO_COMP":                                 "syscall",
+	"syscall.IPPROTO_CPHB":                                 "syscall",
+	"syscall.IPPROTO_CPNX":                                 "syscall",
+	"syscall.IPPROTO_DCCP":                                 "syscall",
+	"syscall.IPPROTO_DDP":                                  "syscall",
+	"syscall.IPPROTO_DGP":                                  "syscall",
+	"syscall.IPPROTO_DIVERT":                               "syscall",
+	"syscall.IPPROTO_DIVERT_INIT":                          "syscall",
+	"syscall.IPPROTO_DIVERT_RESP":                          "syscall",
+	"syscall.IPPROTO_DONE":                                 "syscall",
+	"syscall.IPPROTO_DSTOPTS":                              "syscall",
+	"syscall.IPPROTO_EGP":                                  "syscall",
+	"syscall.IPPROTO_EMCON":                                "syscall",
+	"syscall.IPPROTO_ENCAP":                                "syscall",
+	"syscall.IPPROTO_EON":                                  "syscall",
+	"syscall.IPPROTO_ESP":                                  "syscall",
+	"syscall.IPPROTO_ETHERIP":                              "syscall",
+	"syscall.IPPROTO_FRAGMENT":                             "syscall",
+	"syscall.IPPROTO_GGP":                                  "syscall",
+	"syscall.IPPROTO_GMTP":                                 "syscall",
+	"syscall.IPPROTO_GRE":                                  "syscall",
+	"syscall.IPPROTO_HELLO":                                "syscall",
+	"syscall.IPPROTO_HMP":                                  "syscall",
+	"syscall.IPPROTO_HOPOPTS":                              "syscall",
+	"syscall.IPPROTO_ICMP":                                 "syscall",
+	"syscall.IPPROTO_ICMPV6":                               "syscall",
+	"syscall.IPPROTO_IDP":                                  "syscall",
+	"syscall.IPPROTO_IDPR":                                 "syscall",
+	"syscall.IPPROTO_IDRP":                                 "syscall",
+	"syscall.IPPROTO_IGMP":                                 "syscall",
+	"syscall.IPPROTO_IGP":                                  "syscall",
+	"syscall.IPPROTO_IGRP":                                 "syscall",
+	"syscall.IPPROTO_IL":                                   "syscall",
+	"syscall.IPPROTO_INLSP":                                "syscall",
+	"syscall.IPPROTO_INP":                                  "syscall",
+	"syscall.IPPROTO_IP":                                   "syscall",
+	"syscall.IPPROTO_IPCOMP":                               "syscall",
+	"syscall.IPPROTO_IPCV":                                 "syscall",
+	"syscall.IPPROTO_IPEIP":                                "syscall",
+	"syscall.IPPROTO_IPIP":                                 "syscall",
+	"syscall.IPPROTO_IPPC":                                 "syscall",
+	"syscall.IPPROTO_IPV4":                                 "syscall",
+	"syscall.IPPROTO_IPV6":                                 "syscall",
+	"syscall.IPPROTO_IPV6_ICMP":                            "syscall",
+	"syscall.IPPROTO_IRTP":                                 "syscall",
+	"syscall.IPPROTO_KRYPTOLAN":                            "syscall",
+	"syscall.IPPROTO_LARP":                                 "syscall",
+	"syscall.IPPROTO_LEAF1":                                "syscall",
+	"syscall.IPPROTO_LEAF2":                                "syscall",
+	"syscall.IPPROTO_MAX":                                  "syscall",
+	"syscall.IPPROTO_MAXID":                                "syscall",
+	"syscall.IPPROTO_MEAS":                                 "syscall",
+	"syscall.IPPROTO_MH":                                   "syscall",
+	"syscall.IPPROTO_MHRP":                                 "syscall",
+	"syscall.IPPROTO_MICP":                                 "syscall",
+	"syscall.IPPROTO_MOBILE":                               "syscall",
+	"syscall.IPPROTO_MPLS":                                 "syscall",
+	"syscall.IPPROTO_MTP":                                  "syscall",
+	"syscall.IPPROTO_MUX":                                  "syscall",
+	"syscall.IPPROTO_ND":                                   "syscall",
+	"syscall.IPPROTO_NHRP":                                 "syscall",
+	"syscall.IPPROTO_NONE":                                 "syscall",
+	"syscall.IPPROTO_NSP":                                  "syscall",
+	"syscall.IPPROTO_NVPII":                                "syscall",
+	"syscall.IPPROTO_OLD_DIVERT":                           "syscall",
+	"syscall.IPPROTO_OSPFIGP":                              "syscall",
+	"syscall.IPPROTO_PFSYNC":                               "syscall",
+	"syscall.IPPROTO_PGM":                                  "syscall",
+	"syscall.IPPROTO_PIGP":                                 "syscall",
+	"syscall.IPPROTO_PIM":                                  "syscall",
+	"syscall.IPPROTO_PRM":                                  "syscall",
+	"syscall.IPPROTO_PUP":                                  "syscall",
+	"syscall.IPPROTO_PVP":                                  "syscall",
+	"syscall.IPPROTO_RAW":                                  "syscall",
+	"syscall.IPPROTO_RCCMON":                               "syscall",
+	"syscall.IPPROTO_RDP":                                  "syscall",
+	"syscall.IPPROTO_ROUTING":                              "syscall",
+	"syscall.IPPROTO_RSVP":                                 "syscall",
+	"syscall.IPPROTO_RVD":                                  "syscall",
+	"syscall.IPPROTO_SATEXPAK":                             "syscall",
+	"syscall.IPPROTO_SATMON":                               "syscall",
+	"syscall.IPPROTO_SCCSP":                                "syscall",
+	"syscall.IPPROTO_SCTP":                                 "syscall",
+	"syscall.IPPROTO_SDRP":                                 "syscall",
+	"syscall.IPPROTO_SEND":                                 "syscall",
+	"syscall.IPPROTO_SEP":                                  "syscall",
+	"syscall.IPPROTO_SKIP":                                 "syscall",
+	"syscall.IPPROTO_SPACER":                               "syscall",
+	"syscall.IPPROTO_SRPC":                                 "syscall",
+	"syscall.IPPROTO_ST":                                   "syscall",
+	"syscall.IPPROTO_SVMTP":                                "syscall",
+	"syscall.IPPROTO_SWIPE":                                "syscall",
+	"syscall.IPPROTO_TCF":                                  "syscall",
+	"syscall.IPPROTO_TCP":                                  "syscall",
+	"syscall.IPPROTO_TLSP":                                 "syscall",
+	"syscall.IPPROTO_TP":                                   "syscall",
+	"syscall.IPPROTO_TPXX":                                 "syscall",
+	"syscall.IPPROTO_TRUNK1":                               "syscall",
+	"syscall.IPPROTO_TRUNK2":                               "syscall",
+	"syscall.IPPROTO_TTP":                                  "syscall",
+	"syscall.IPPROTO_UDP":                                  "syscall",
+	"syscall.IPPROTO_UDPLITE":                              "syscall",
+	"syscall.IPPROTO_VINES":                                "syscall",
+	"syscall.IPPROTO_VISA":                                 "syscall",
+	"syscall.IPPROTO_VMTP":                                 "syscall",
+	"syscall.IPPROTO_VRRP":                                 "syscall",
+	"syscall.IPPROTO_WBEXPAK":                              "syscall",
+	"syscall.IPPROTO_WBMON":                                "syscall",
+	"syscall.IPPROTO_WSN":                                  "syscall",
+	"syscall.IPPROTO_XNET":                                 "syscall",
+	"syscall.IPPROTO_XTP":                                  "syscall",
+	"syscall.IPV6_2292DSTOPTS":                             "syscall",
+	"syscall.IPV6_2292HOPLIMIT":                            "syscall",
+	"syscall.IPV6_2292HOPOPTS":                             "syscall",
+	"syscall.IPV6_2292NEXTHOP":                             "syscall",
+	"syscall.IPV6_2292PKTINFO":                             "syscall",
+	"syscall.IPV6_2292PKTOPTIONS":                          "syscall",
+	"syscall.IPV6_2292RTHDR":                               "syscall",
+	"syscall.IPV6_ADDRFORM":                                "syscall",
+	"syscall.IPV6_ADD_MEMBERSHIP":                          "syscall",
+	"syscall.IPV6_AUTHHDR":                                 "syscall",
+	"syscall.IPV6_AUTH_LEVEL":                              "syscall",
+	"syscall.IPV6_AUTOFLOWLABEL":                           "syscall",
+	"syscall.IPV6_BINDANY":                                 "syscall",
+	"syscall.IPV6_BINDV6ONLY":                              "syscall",
+	"syscall.IPV6_BOUND_IF":                                "syscall",
+	"syscall.IPV6_CHECKSUM":                                "syscall",
+	"syscall.IPV6_DEFAULT_MULTICAST_HOPS":                  "syscall",
+	"syscall.IPV6_DEFAULT_MULTICAST_LOOP":                  "syscall",
+	"syscall.IPV6_DEFHLIM":                                 "syscall",
+	"syscall.IPV6_DONTFRAG":                                "syscall",
+	"syscall.IPV6_DROP_MEMBERSHIP":                         "syscall",
+	"syscall.IPV6_DSTOPTS":                                 "syscall",
+	"syscall.IPV6_ESP_NETWORK_LEVEL":                       "syscall",
+	"syscall.IPV6_ESP_TRANS_LEVEL":                         "syscall",
+	"syscall.IPV6_FAITH":                                   "syscall",
+	"syscall.IPV6_FLOWINFO_MASK":                           "syscall",
+	"syscall.IPV6_FLOWLABEL_MASK":                          "syscall",
+	"syscall.IPV6_FRAGTTL":                                 "syscall",
+	"syscall.IPV6_FW_ADD":                                  "syscall",
+	"syscall.IPV6_FW_DEL":                                  "syscall",
+	"syscall.IPV6_FW_FLUSH":                                "syscall",
+	"syscall.IPV6_FW_GET":                                  "syscall",
+	"syscall.IPV6_FW_ZERO":                                 "syscall",
+	"syscall.IPV6_HLIMDEC":                                 "syscall",
+	"syscall.IPV6_HOPLIMIT":                                "syscall",
+	"syscall.IPV6_HOPOPTS":                                 "syscall",
+	"syscall.IPV6_IPCOMP_LEVEL":                            "syscall",
+	"syscall.IPV6_IPSEC_POLICY":                            "syscall",
+	"syscall.IPV6_JOIN_ANYCAST":                            "syscall",
+	"syscall.IPV6_JOIN_GROUP":                              "syscall",
+	"syscall.IPV6_LEAVE_ANYCAST":                           "syscall",
+	"syscall.IPV6_LEAVE_GROUP":                             "syscall",
+	"syscall.IPV6_MAXHLIM":                                 "syscall",
+	"syscall.IPV6_MAXOPTHDR":                               "syscall",
+	"syscall.IPV6_MAXPACKET":                               "syscall",
+	"syscall.IPV6_MAX_GROUP_SRC_FILTER":                    "syscall",
+	"syscall.IPV6_MAX_MEMBERSHIPS":                         "syscall",
+	"syscall.IPV6_MAX_SOCK_SRC_FILTER":                     "syscall",
+	"syscall.IPV6_MIN_MEMBERSHIPS":                         "syscall",
+	"syscall.IPV6_MMTU":                                    "syscall",
+	"syscall.IPV6_MSFILTER":                                "syscall",
+	"syscall.IPV6_MTU":                                     "syscall",
+	"syscall.IPV6_MTU_DISCOVER":                            "syscall",
+	"syscall.IPV6_MULTICAST_HOPS":                          "syscall",
+	"syscall.IPV6_MULTICAST_IF":                            "syscall",
+	"syscall.IPV6_MULTICAST_LOOP":                          "syscall",
+	"syscall.IPV6_NEXTHOP":                                 "syscall",
+	"syscall.IPV6_OPTIONS":                                 "syscall",
+	"syscall.IPV6_PATHMTU":                                 "syscall",
+	"syscall.IPV6_PIPEX":                                   "syscall",
+	"syscall.IPV6_PKTINFO":                                 "syscall",
+	"syscall.IPV6_PMTUDISC_DO":                             "syscall",
+	"syscall.IPV6_PMTUDISC_DONT":                           "syscall",
+	"syscall.IPV6_PMTUDISC_PROBE":                          "syscall",
+	"syscall.IPV6_PMTUDISC_WANT":                           "syscall",
+	"syscall.IPV6_PORTRANGE":                               "syscall",
+	"syscall.IPV6_PORTRANGE_DEFAULT":                       "syscall",
+	"syscall.IPV6_PORTRANGE_HIGH":                          "syscall",
+	"syscall.IPV6_PORTRANGE_LOW":                           "syscall",
+	"syscall.IPV6_PREFER_TEMPADDR":                         "syscall",
+	"syscall.IPV6_RECVDSTOPTS":                             "syscall",
+	"syscall.IPV6_RECVDSTPORT":                             "syscall",
+	"syscall.IPV6_RECVERR":                                 "syscall",
+	"syscall.IPV6_RECVHOPLIMIT":                            "syscall",
+	"syscall.IPV6_RECVHOPOPTS":                             "syscall",
+	"syscall.IPV6_RECVPATHMTU":                             "syscall",
+	"syscall.IPV6_RECVPKTINFO":                             "syscall",
+	"syscall.IPV6_RECVRTHDR":                               "syscall",
+	"syscall.IPV6_RECVTCLASS":                              "syscall",
+	"syscall.IPV6_ROUTER_ALERT":                            "syscall",
+	"syscall.IPV6_RTABLE":                                  "syscall",
+	"syscall.IPV6_RTHDR":                                   "syscall",
+	"syscall.IPV6_RTHDRDSTOPTS":                            "syscall",
+	"syscall.IPV6_RTHDR_LOOSE":                             "syscall",
+	"syscall.IPV6_RTHDR_STRICT":                            "syscall",
+	"syscall.IPV6_RTHDR_TYPE_0":                            "syscall",
+	"syscall.IPV6_RXDSTOPTS":                               "syscall",
+	"syscall.IPV6_RXHOPOPTS":                               "syscall",
+	"syscall.IPV6_SOCKOPT_RESERVED1":                       "syscall",
+	"syscall.IPV6_TCLASS":                                  "syscall",
+	"syscall.IPV6_UNICAST_HOPS":                            "syscall",
+	"syscall.IPV6_USE_MIN_MTU":                             "syscall",
+	"syscall.IPV6_V6ONLY":                                  "syscall",
+	"syscall.IPV6_VERSION":                                 "syscall",
+	"syscall.IPV6_VERSION_MASK":                            "syscall",
+	"syscall.IPV6_XFRM_POLICY":                             "syscall",
+	"syscall.IP_ADD_MEMBERSHIP":                            "syscall",
+	"syscall.IP_ADD_SOURCE_MEMBERSHIP":                     "syscall",
+	"syscall.IP_AUTH_LEVEL":                                "syscall",
+	"syscall.IP_BINDANY":                                   "syscall",
+	"syscall.IP_BLOCK_SOURCE":                              "syscall",
+	"syscall.IP_BOUND_IF":                                  "syscall",
+	"syscall.IP_DEFAULT_MULTICAST_LOOP":                    "syscall",
+	"syscall.IP_DEFAULT_MULTICAST_TTL":                     "syscall",
+	"syscall.IP_DF":                                        "syscall",
+	"syscall.IP_DIVERTFL":                                  "syscall",
+	"syscall.IP_DONTFRAG":                                  "syscall",
+	"syscall.IP_DROP_MEMBERSHIP":                           "syscall",
+	"syscall.IP_DROP_SOURCE_MEMBERSHIP":                    "syscall",
+	"syscall.IP_DUMMYNET3":                                 "syscall",
+	"syscall.IP_DUMMYNET_CONFIGURE":                        "syscall",
+	"syscall.IP_DUMMYNET_DEL":                              "syscall",
+	"syscall.IP_DUMMYNET_FLUSH":                            "syscall",
+	"syscall.IP_DUMMYNET_GET":                              "syscall",
+	"syscall.IP_EF":                                        "syscall",
+	"syscall.IP_ERRORMTU":                                  "syscall",
+	"syscall.IP_ESP_NETWORK_LEVEL":                         "syscall",
+	"syscall.IP_ESP_TRANS_LEVEL":                           "syscall",
+	"syscall.IP_FAITH":                                     "syscall",
+	"syscall.IP_FREEBIND":                                  "syscall",
+	"syscall.IP_FW3":                                       "syscall",
+	"syscall.IP_FW_ADD":                                    "syscall",
+	"syscall.IP_FW_DEL":                                    "syscall",
+	"syscall.IP_FW_FLUSH":                                  "syscall",
+	"syscall.IP_FW_GET":                                    "syscall",
+	"syscall.IP_FW_NAT_CFG":                                "syscall",
+	"syscall.IP_FW_NAT_DEL":                                "syscall",
+	"syscall.IP_FW_NAT_GET_CONFIG":                         "syscall",
+	"syscall.IP_FW_NAT_GET_LOG":                            "syscall",
+	"syscall.IP_FW_RESETLOG":                               "syscall",
+	"syscall.IP_FW_TABLE_ADD":                              "syscall",
+	"syscall.IP_FW_TABLE_DEL":                              "syscall",
+	"syscall.IP_FW_TABLE_FLUSH":                            "syscall",
+	"syscall.IP_FW_TABLE_GETSIZE":                          "syscall",
+	"syscall.IP_FW_TABLE_LIST":                             "syscall",
+	"syscall.IP_FW_ZERO":                                   "syscall",
+	"syscall.IP_HDRINCL":                                   "syscall",
+	"syscall.IP_IPCOMP_LEVEL":                              "syscall",
+	"syscall.IP_IPSECFLOWINFO":                             "syscall",
+	"syscall.IP_IPSEC_LOCAL_AUTH":                          "syscall",
+	"syscall.IP_IPSEC_LOCAL_CRED":                          "syscall",
+	"syscall.IP_IPSEC_LOCAL_ID":                            "syscall",
+	"syscall.IP_IPSEC_POLICY":                              "syscall",
+	"syscall.IP_IPSEC_REMOTE_AUTH":                         "syscall",
+	"syscall.IP_IPSEC_REMOTE_CRED":                         "syscall",
+	"syscall.IP_IPSEC_REMOTE_ID":                           "syscall",
+	"syscall.IP_MAXPACKET":                                 "syscall",
+	"syscall.IP_MAX_GROUP_SRC_FILTER":                      "syscall",
+	"syscall.IP_MAX_MEMBERSHIPS":                           "syscall",
+	"syscall.IP_MAX_SOCK_MUTE_FILTER":                      "syscall",
+	"syscall.IP_MAX_SOCK_SRC_FILTER":                       "syscall",
+	"syscall.IP_MAX_SOURCE_FILTER":                         "syscall",
+	"syscall.IP_MF":                                        "syscall",
+	"syscall.IP_MINFRAGSIZE":                               "syscall",
+	"syscall.IP_MINTTL":                                    "syscall",
+	"syscall.IP_MIN_MEMBERSHIPS":                           "syscall",
+	"syscall.IP_MSFILTER":                                  "syscall",
+	"syscall.IP_MSS":                                       "syscall",
+	"syscall.IP_MTU":                                       "syscall",
+	"syscall.IP_MTU_DISCOVER":                              "syscall",
+	"syscall.IP_MULTICAST_IF":                              "syscall",
+	"syscall.IP_MULTICAST_IFINDEX":                         "syscall",
+	"syscall.IP_MULTICAST_LOOP":                            "syscall",
+	"syscall.IP_MULTICAST_TTL":                             "syscall",
+	"syscall.IP_MULTICAST_VIF":                             "syscall",
+	"syscall.IP_NAT__XXX":                                  "syscall",
+	"syscall.IP_OFFMASK":                                   "syscall",
+	"syscall.IP_OLD_FW_ADD":                                "syscall",
+	"syscall.IP_OLD_FW_DEL":                                "syscall",
+	"syscall.IP_OLD_FW_FLUSH":                              "syscall",
+	"syscall.IP_OLD_FW_GET":                                "syscall",
+	"syscall.IP_OLD_FW_RESETLOG":                           "syscall",
+	"syscall.IP_OLD_FW_ZERO":                               "syscall",
+	"syscall.IP_ONESBCAST":                                 "syscall",
+	"syscall.IP_OPTIONS":                                   "syscall",
+	"syscall.IP_ORIGDSTADDR":                               "syscall",
+	"syscall.IP_PASSSEC":                                   "syscall",
+	"syscall.IP_PIPEX":                                     "syscall",
+	"syscall.IP_PKTINFO":                                   "syscall",
+	"syscall.IP_PKTOPTIONS":                                "syscall",
+	"syscall.IP_PMTUDISC":                                  "syscall",
+	"syscall.IP_PMTUDISC_DO":                               "syscall",
+	"syscall.IP_PMTUDISC_DONT":                             "syscall",
+	"syscall.IP_PMTUDISC_PROBE":                            "syscall",
+	"syscall.IP_PMTUDISC_WANT":                             "syscall",
+	"syscall.IP_PORTRANGE":                                 "syscall",
+	"syscall.IP_PORTRANGE_DEFAULT":                         "syscall",
+	"syscall.IP_PORTRANGE_HIGH":                            "syscall",
+	"syscall.IP_PORTRANGE_LOW":                             "syscall",
+	"syscall.IP_RECVDSTADDR":                               "syscall",
+	"syscall.IP_RECVDSTPORT":                               "syscall",
+	"syscall.IP_RECVERR":                                   "syscall",
+	"syscall.IP_RECVIF":                                    "syscall",
+	"syscall.IP_RECVOPTS":                                  "syscall",
+	"syscall.IP_RECVORIGDSTADDR":                           "syscall",
+	"syscall.IP_RECVPKTINFO":                               "syscall",
+	"syscall.IP_RECVRETOPTS":                               "syscall",
+	"syscall.IP_RECVRTABLE":                                "syscall",
+	"syscall.IP_RECVTOS":                                   "syscall",
+	"syscall.IP_RECVTTL":                                   "syscall",
+	"syscall.IP_RETOPTS":                                   "syscall",
+	"syscall.IP_RF":                                        "syscall",
+	"syscall.IP_ROUTER_ALERT":                              "syscall",
+	"syscall.IP_RSVP_OFF":                                  "syscall",
+	"syscall.IP_RSVP_ON":                                   "syscall",
+	"syscall.IP_RSVP_VIF_OFF":                              "syscall",
+	"syscall.IP_RSVP_VIF_ON":                               "syscall",
+	"syscall.IP_RTABLE":                                    "syscall",
+	"syscall.IP_SENDSRCADDR":                               "syscall",
+	"syscall.IP_STRIPHDR":                                  "syscall",
+	"syscall.IP_TOS":                                       "syscall",
+	"syscall.IP_TRAFFIC_MGT_BACKGROUND":                    "syscall",
+	"syscall.IP_TRANSPARENT":                               "syscall",
+	"syscall.IP_TTL":                                       "syscall",
+	"syscall.IP_UNBLOCK_SOURCE":                            "syscall",
+	"syscall.IP_XFRM_POLICY":                               "syscall",
+	"syscall.IPv6MTUInfo":                                  "syscall",
+	"syscall.IPv6Mreq":                                     "syscall",
+	"syscall.ISIG":                                         "syscall",
+	"syscall.ISTRIP":                                       "syscall",
+	"syscall.IUCLC":                                        "syscall",
+	"syscall.IUTF8":                                        "syscall",
+	"syscall.IXANY":                                        "syscall",
+	"syscall.IXOFF":                                        "syscall",
+	"syscall.IXON":                                         "syscall",
+	"syscall.IfAddrmsg":                                    "syscall",
+	"syscall.IfAnnounceMsghdr":                             "syscall",
+	"syscall.IfData":                                       "syscall",
+	"syscall.IfInfomsg":                                    "syscall",
+	"syscall.IfMsghdr":                                     "syscall",
+	"syscall.IfaMsghdr":                                    "syscall",
+	"syscall.IfmaMsghdr":                                   "syscall",
+	"syscall.IfmaMsghdr2":                                  "syscall",
+	"syscall.ImplementsGetwd":                              "syscall",
+	"syscall.Inet4Pktinfo":                                 "syscall",
+	"syscall.Inet6Pktinfo":                                 "syscall",
+	"syscall.InotifyAddWatch":                              "syscall",
+	"syscall.InotifyEvent":                                 "syscall",
+	"syscall.InotifyInit":                                  "syscall",
+	"syscall.InotifyInit1":                                 "syscall",
+	"syscall.InotifyRmWatch":                               "syscall",
+	"syscall.InterfaceAddrMessage":                         "syscall",
+	"syscall.InterfaceAnnounceMessage":                     "syscall",
+	"syscall.InterfaceInfo":                                "syscall",
+	"syscall.InterfaceMessage":                             "syscall",
+	"syscall.InterfaceMulticastAddrMessage":                "syscall",
+	"syscall.InvalidHandle":                                "syscall",
+	"syscall.Ioperm":                                       "syscall",
+	"syscall.Iopl":                                         "syscall",
+	"syscall.Iovec":                                        "syscall",
+	"syscall.IpAdapterInfo":                                "syscall",
+	"syscall.IpAddrString":                                 "syscall",
+	"syscall.IpAddressString":                              "syscall",
+	"syscall.IpMaskString":                                 "syscall",
+	"syscall.Issetugid":                                    "syscall",
+	"syscall.KEY_ALL_ACCESS":                               "syscall",
+	"syscall.KEY_CREATE_LINK":                              "syscall",
+	"syscall.KEY_CREATE_SUB_KEY":                           "syscall",
+	"syscall.KEY_ENUMERATE_SUB_KEYS":                       "syscall",
+	"syscall.KEY_EXECUTE":                                  "syscall",
+	"syscall.KEY_NOTIFY":                                   "syscall",
+	"syscall.KEY_QUERY_VALUE":                              "syscall",
+	"syscall.KEY_READ":                                     "syscall",
+	"syscall.KEY_SET_VALUE":                                "syscall",
+	"syscall.KEY_WOW64_32KEY":                              "syscall",
+	"syscall.KEY_WOW64_64KEY":                              "syscall",
+	"syscall.KEY_WRITE":                                    "syscall",
+	"syscall.Kevent":                                       "syscall",
+	"syscall.Kevent_t":                                     "syscall",
+	"syscall.Kill":                                         "syscall",
+	"syscall.Klogctl":                                      "syscall",
+	"syscall.Kqueue":                                       "syscall",
+	"syscall.LANG_ENGLISH":                                 "syscall",
+	"syscall.LAYERED_PROTOCOL":                             "syscall",
+	"syscall.LCNT_OVERLOAD_FLUSH":                          "syscall",
+	"syscall.LINUX_REBOOT_CMD_CAD_OFF":                     "syscall",
+	"syscall.LINUX_REBOOT_CMD_CAD_ON":                      "syscall",
+	"syscall.LINUX_REBOOT_CMD_HALT":                        "syscall",
+	"syscall.LINUX_REBOOT_CMD_KEXEC":                       "syscall",
+	"syscall.LINUX_REBOOT_CMD_POWER_OFF":                   "syscall",
+	"syscall.LINUX_REBOOT_CMD_RESTART":                     "syscall",
+	"syscall.LINUX_REBOOT_CMD_RESTART2":                    "syscall",
+	"syscall.LINUX_REBOOT_CMD_SW_SUSPEND":                  "syscall",
+	"syscall.LINUX_REBOOT_MAGIC1":                          "syscall",
+	"syscall.LINUX_REBOOT_MAGIC2":                          "syscall",
+	"syscall.LOCK_EX":                                      "syscall",
+	"syscall.LOCK_NB":                                      "syscall",
+	"syscall.LOCK_SH":                                      "syscall",
+	"syscall.LOCK_UN":                                      "syscall",
+	"syscall.LazyDLL":                                      "syscall",
+	"syscall.LazyProc":                                     "syscall",
+	"syscall.Lchown":                                       "syscall",
+	"syscall.Linger":                                       "syscall",
+	"syscall.Link":                                         "syscall",
+	"syscall.Listen":                                       "syscall",
+	"syscall.Listxattr":                                    "syscall",
+	"syscall.LoadCancelIoEx":                               "syscall",
+	"syscall.LoadConnectEx":                                "syscall",
+	"syscall.LoadCreateSymbolicLink":                       "syscall",
+	"syscall.LoadDLL":                                      "syscall",
+	"syscall.LoadGetAddrInfo":                              "syscall",
+	"syscall.LoadLibrary":                                  "syscall",
+	"syscall.LoadSetFileCompletionNotificationModes":       "syscall",
+	"syscall.LocalFree":                                    "syscall",
+	"syscall.Log2phys_t":                                   "syscall",
+	"syscall.LookupAccountName":                            "syscall",
+	"syscall.LookupAccountSid":                             "syscall",
+	"syscall.LookupSID":                                    "syscall",
+	"syscall.LsfJump":                                      "syscall",
+	"syscall.LsfSocket":                                    "syscall",
+	"syscall.LsfStmt":                                      "syscall",
+	"syscall.Lstat":                                        "syscall",
+	"syscall.MADV_AUTOSYNC":                                "syscall",
+	"syscall.MADV_CAN_REUSE":                               "syscall",
+	"syscall.MADV_CORE":                                    "syscall",
+	"syscall.MADV_DOFORK":                                  "syscall",
+	"syscall.MADV_DONTFORK":                                "syscall",
+	"syscall.MADV_DONTNEED":                                "syscall",
+	"syscall.MADV_FREE":                                    "syscall",
+	"syscall.MADV_FREE_REUSABLE":                           "syscall",
+	"syscall.MADV_FREE_REUSE":                              "syscall",
+	"syscall.MADV_HUGEPAGE":                                "syscall",
+	"syscall.MADV_HWPOISON":                                "syscall",
+	"syscall.MADV_MERGEABLE":                               "syscall",
+	"syscall.MADV_NOCORE":                                  "syscall",
+	"syscall.MADV_NOHUGEPAGE":                              "syscall",
+	"syscall.MADV_NORMAL":                                  "syscall",
+	"syscall.MADV_NOSYNC":                                  "syscall",
+	"syscall.MADV_PROTECT":                                 "syscall",
+	"syscall.MADV_RANDOM":                                  "syscall",
+	"syscall.MADV_REMOVE":                                  "syscall",
+	"syscall.MADV_SEQUENTIAL":                              "syscall",
+	"syscall.MADV_SPACEAVAIL":                              "syscall",
+	"syscall.MADV_UNMERGEABLE":                             "syscall",
+	"syscall.MADV_WILLNEED":                                "syscall",
+	"syscall.MADV_ZERO_WIRED_PAGES":                        "syscall",
+	"syscall.MAP_32BIT":                                    "syscall",
+	"syscall.MAP_ALIGNED_SUPER":                            "syscall",
+	"syscall.MAP_ALIGNMENT_16MB":                           "syscall",
+	"syscall.MAP_ALIGNMENT_1TB":                            "syscall",
+	"syscall.MAP_ALIGNMENT_256TB":                          "syscall",
+	"syscall.MAP_ALIGNMENT_4GB":                            "syscall",
+	"syscall.MAP_ALIGNMENT_64KB":                           "syscall",
+	"syscall.MAP_ALIGNMENT_64PB":                           "syscall",
+	"syscall.MAP_ALIGNMENT_MASK":                           "syscall",
+	"syscall.MAP_ALIGNMENT_SHIFT":                          "syscall",
+	"syscall.MAP_ANON":                                     "syscall",
+	"syscall.MAP_ANONYMOUS":                                "syscall",
+	"syscall.MAP_COPY":                                     "syscall",
+	"syscall.MAP_DENYWRITE":                                "syscall",
+	"syscall.MAP_EXECUTABLE":                               "syscall",
+	"syscall.MAP_FILE":                                     "syscall",
+	"syscall.MAP_FIXED":                                    "syscall",
+	"syscall.MAP_FLAGMASK":                                 "syscall",
+	"syscall.MAP_GROWSDOWN":                                "syscall",
+	"syscall.MAP_HASSEMAPHORE":                             "syscall",
+	"syscall.MAP_HUGETLB":                                  "syscall",
+	"syscall.MAP_INHERIT":                                  "syscall",
+	"syscall.MAP_INHERIT_COPY":                             "syscall",
+	"syscall.MAP_INHERIT_DEFAULT":                          "syscall",
+	"syscall.MAP_INHERIT_DONATE_COPY":                      "syscall",
+	"syscall.MAP_INHERIT_NONE":                             "syscall",
+	"syscall.MAP_INHERIT_SHARE":                            "syscall",
+	"syscall.MAP_JIT":                                      "syscall",
+	"syscall.MAP_LOCKED":                                   "syscall",
+	"syscall.MAP_NOCACHE":                                  "syscall",
+	"syscall.MAP_NOCORE":                                   "syscall",
+	"syscall.MAP_NOEXTEND":                                 "syscall",
+	"syscall.MAP_NONBLOCK":                                 "syscall",
+	"syscall.MAP_NORESERVE":                                "syscall",
+	"syscall.MAP_NOSYNC":                                   "syscall",
+	"syscall.MAP_POPULATE":                                 "syscall",
+	"syscall.MAP_PREFAULT_READ":                            "syscall",
+	"syscall.MAP_PRIVATE":                                  "syscall",
+	"syscall.MAP_RENAME":                                   "syscall",
+	"syscall.MAP_RESERVED0080":                             "syscall",
+	"syscall.MAP_RESERVED0100":                             "syscall",
+	"syscall.MAP_SHARED":                                   "syscall",
+	"syscall.MAP_STACK":                                    "syscall",
+	"syscall.MAP_TRYFIXED":                                 "syscall",
+	"syscall.MAP_TYPE":                                     "syscall",
+	"syscall.MAP_WIRED":                                    "syscall",
+	"syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE":             "syscall",
+	"syscall.MAXLEN_IFDESCR":                               "syscall",
+	"syscall.MAXLEN_PHYSADDR":                              "syscall",
+	"syscall.MAX_ADAPTER_ADDRESS_LENGTH":                   "syscall",
+	"syscall.MAX_ADAPTER_DESCRIPTION_LENGTH":               "syscall",
+	"syscall.MAX_ADAPTER_NAME_LENGTH":                      "syscall",
+	"syscall.MAX_COMPUTERNAME_LENGTH":                      "syscall",
+	"syscall.MAX_INTERFACE_NAME_LEN":                       "syscall",
+	"syscall.MAX_LONG_PATH":                                "syscall",
+	"syscall.MAX_PATH":                                     "syscall",
+	"syscall.MAX_PROTOCOL_CHAIN":                           "syscall",
+	"syscall.MCL_CURRENT":                                  "syscall",
+	"syscall.MCL_FUTURE":                                   "syscall",
+	"syscall.MNT_DETACH":                                   "syscall",
+	"syscall.MNT_EXPIRE":                                   "syscall",
+	"syscall.MNT_FORCE":                                    "syscall",
+	"syscall.MSG_BCAST":                                    "syscall",
+	"syscall.MSG_CMSG_CLOEXEC":                             "syscall",
+	"syscall.MSG_COMPAT":                                   "syscall",
+	"syscall.MSG_CONFIRM":                                  "syscall",
+	"syscall.MSG_CONTROLMBUF":                              "syscall",
+	"syscall.MSG_CTRUNC":                                   "syscall",
+	"syscall.MSG_DONTROUTE":                                "syscall",
+	"syscall.MSG_DONTWAIT":                                 "syscall",
+	"syscall.MSG_EOF":                                      "syscall",
+	"syscall.MSG_EOR":                                      "syscall",
+	"syscall.MSG_ERRQUEUE":                                 "syscall",
+	"syscall.MSG_FASTOPEN":                                 "syscall",
+	"syscall.MSG_FIN":                                      "syscall",
+	"syscall.MSG_FLUSH":                                    "syscall",
+	"syscall.MSG_HAVEMORE":                                 "syscall",
+	"syscall.MSG_HOLD":                                     "syscall",
+	"syscall.MSG_IOVUSRSPACE":                              "syscall",
+	"syscall.MSG_LENUSRSPACE":                              "syscall",
+	"syscall.MSG_MCAST":                                    "syscall",
+	"syscall.MSG_MORE":                                     "syscall",
+	"syscall.MSG_NAMEMBUF":                                 "syscall",
+	"syscall.MSG_NBIO":                                     "syscall",
+	"syscall.MSG_NEEDSA":                                   "syscall",
+	"syscall.MSG_NOSIGNAL":                                 "syscall",
+	"syscall.MSG_NOTIFICATION":                             "syscall",
+	"syscall.MSG_OOB":                                      "syscall",
+	"syscall.MSG_PEEK":                                     "syscall",
+	"syscall.MSG_PROXY":                                    "syscall",
+	"syscall.MSG_RCVMORE":                                  "syscall",
+	"syscall.MSG_RST":                                      "syscall",
+	"syscall.MSG_SEND":                                     "syscall",
+	"syscall.MSG_SYN":                                      "syscall",
+	"syscall.MSG_TRUNC":                                    "syscall",
+	"syscall.MSG_TRYHARD":                                  "syscall",
+	"syscall.MSG_USERFLAGS":                                "syscall",
+	"syscall.MSG_WAITALL":                                  "syscall",
+	"syscall.MSG_WAITFORONE":                               "syscall",
+	"syscall.MSG_WAITSTREAM":                               "syscall",
+	"syscall.MS_ACTIVE":                                    "syscall",
+	"syscall.MS_ASYNC":                                     "syscall",
+	"syscall.MS_BIND":                                      "syscall",
+	"syscall.MS_DEACTIVATE":                                "syscall",
+	"syscall.MS_DIRSYNC":                                   "syscall",
+	"syscall.MS_INVALIDATE":                                "syscall",
+	"syscall.MS_I_VERSION":                                 "syscall",
+	"syscall.MS_KERNMOUNT":                                 "syscall",
+	"syscall.MS_KILLPAGES":                                 "syscall",
+	"syscall.MS_MANDLOCK":                                  "syscall",
+	"syscall.MS_MGC_MSK":                                   "syscall",
+	"syscall.MS_MGC_VAL":                                   "syscall",
+	"syscall.MS_MOVE":                                      "syscall",
+	"syscall.MS_NOATIME":                                   "syscall",
+	"syscall.MS_NODEV":                                     "syscall",
+	"syscall.MS_NODIRATIME":                                "syscall",
+	"syscall.MS_NOEXEC":                                    "syscall",
+	"syscall.MS_NOSUID":                                    "syscall",
+	"syscall.MS_NOUSER":                                    "syscall",
+	"syscall.MS_POSIXACL":                                  "syscall",
+	"syscall.MS_PRIVATE":                                   "syscall",
+	"syscall.MS_RDONLY":                                    "syscall",
+	"syscall.MS_REC":                                       "syscall",
+	"syscall.MS_RELATIME":                                  "syscall",
+	"syscall.MS_REMOUNT":                                   "syscall",
+	"syscall.MS_RMT_MASK":                                  "syscall",
+	"syscall.MS_SHARED":                                    "syscall",
+	"syscall.MS_SILENT":                                    "syscall",
+	"syscall.MS_SLAVE":                                     "syscall",
+	"syscall.MS_STRICTATIME":                               "syscall",
+	"syscall.MS_SYNC":                                      "syscall",
+	"syscall.MS_SYNCHRONOUS":                               "syscall",
+	"syscall.MS_UNBINDABLE":                                "syscall",
+	"syscall.Madvise":                                      "syscall",
+	"syscall.MapViewOfFile":                                "syscall",
+	"syscall.MaxTokenInfoClass":                            "syscall",
+	"syscall.Mclpool":                                      "syscall",
+	"syscall.MibIfRow":                                     "syscall",
+	"syscall.Mkdir":                                        "syscall",
+	"syscall.Mkdirat":                                      "syscall",
+	"syscall.Mkfifo":                                       "syscall",
+	"syscall.Mknod":                                        "syscall",
+	"syscall.Mknodat":                                      "syscall",
+	"syscall.Mlock":                                        "syscall",
+	"syscall.Mlockall":                                     "syscall",
+	"syscall.Mmap":                                         "syscall",
+	"syscall.Mount":                                        "syscall",
+	"syscall.MoveFile":                                     "syscall",
+	"syscall.Mprotect":                                     "syscall",
+	"syscall.Msghdr":                                       "syscall",
+	"syscall.Munlock":                                      "syscall",
+	"syscall.Munlockall":                                   "syscall",
+	"syscall.Munmap":                                       "syscall",
+	"syscall.MustLoadDLL":                                  "syscall",
+	"syscall.NAME_MAX":                                     "syscall",
+	"syscall.NETLINK_ADD_MEMBERSHIP":                       "syscall",
+	"syscall.NETLINK_AUDIT":                                "syscall",
+	"syscall.NETLINK_BROADCAST_ERROR":                      "syscall",
+	"syscall.NETLINK_CONNECTOR":                            "syscall",
+	"syscall.NETLINK_DNRTMSG":                              "syscall",
+	"syscall.NETLINK_DROP_MEMBERSHIP":                      "syscall",
+	"syscall.NETLINK_ECRYPTFS":                             "syscall",
+	"syscall.NETLINK_FIB_LOOKUP":                           "syscall",
+	"syscall.NETLINK_FIREWALL":                             "syscall",
+	"syscall.NETLINK_GENERIC":                              "syscall",
+	"syscall.NETLINK_INET_DIAG":                            "syscall",
+	"syscall.NETLINK_IP6_FW":                               "syscall",
+	"syscall.NETLINK_ISCSI":                                "syscall",
+	"syscall.NETLINK_KOBJECT_UEVENT":                       "syscall",
+	"syscall.NETLINK_NETFILTER":                            "syscall",
+	"syscall.NETLINK_NFLOG":                                "syscall",
+	"syscall.NETLINK_NO_ENOBUFS":                           "syscall",
+	"syscall.NETLINK_PKTINFO":                              "syscall",
+	"syscall.NETLINK_RDMA":                                 "syscall",
+	"syscall.NETLINK_ROUTE":                                "syscall",
+	"syscall.NETLINK_SCSITRANSPORT":                        "syscall",
+	"syscall.NETLINK_SELINUX":                              "syscall",
+	"syscall.NETLINK_UNUSED":                               "syscall",
+	"syscall.NETLINK_USERSOCK":                             "syscall",
+	"syscall.NETLINK_XFRM":                                 "syscall",
+	"syscall.NET_RT_DUMP":                                  "syscall",
+	"syscall.NET_RT_DUMP2":                                 "syscall",
+	"syscall.NET_RT_FLAGS":                                 "syscall",
+	"syscall.NET_RT_IFLIST":                                "syscall",
+	"syscall.NET_RT_IFLIST2":                               "syscall",
+	"syscall.NET_RT_IFLISTL":                               "syscall",
+	"syscall.NET_RT_IFMALIST":                              "syscall",
+	"syscall.NET_RT_MAXID":                                 "syscall",
+	"syscall.NET_RT_OIFLIST":                               "syscall",
+	"syscall.NET_RT_OOIFLIST":                              "syscall",
+	"syscall.NET_RT_STAT":                                  "syscall",
+	"syscall.NET_RT_STATS":                                 "syscall",
+	"syscall.NET_RT_TABLE":                                 "syscall",
+	"syscall.NET_RT_TRASH":                                 "syscall",
+	"syscall.NLA_ALIGNTO":                                  "syscall",
+	"syscall.NLA_F_NESTED":                                 "syscall",
+	"syscall.NLA_F_NET_BYTEORDER":                          "syscall",
+	"syscall.NLA_HDRLEN":                                   "syscall",
+	"syscall.NLMSG_ALIGNTO":                                "syscall",
+	"syscall.NLMSG_DONE":                                   "syscall",
+	"syscall.NLMSG_ERROR":                                  "syscall",
+	"syscall.NLMSG_HDRLEN":                                 "syscall",
+	"syscall.NLMSG_MIN_TYPE":                               "syscall",
+	"syscall.NLMSG_NOOP":                                   "syscall",
+	"syscall.NLMSG_OVERRUN":                                "syscall",
+	"syscall.NLM_F_ACK":                                    "syscall",
+	"syscall.NLM_F_APPEND":                                 "syscall",
+	"syscall.NLM_F_ATOMIC":                                 "syscall",
+	"syscall.NLM_F_CREATE":                                 "syscall",
+	"syscall.NLM_F_DUMP":                                   "syscall",
+	"syscall.NLM_F_ECHO":                                   "syscall",
+	"syscall.NLM_F_EXCL":                                   "syscall",
+	"syscall.NLM_F_MATCH":                                  "syscall",
+	"syscall.NLM_F_MULTI":                                  "syscall",
+	"syscall.NLM_F_REPLACE":                                "syscall",
+	"syscall.NLM_F_REQUEST":                                "syscall",
+	"syscall.NLM_F_ROOT":                                   "syscall",
+	"syscall.NOFLSH":                                       "syscall",
+	"syscall.NOTE_ABSOLUTE":                                "syscall",
+	"syscall.NOTE_ATTRIB":                                  "syscall",
+	"syscall.NOTE_CHILD":                                   "syscall",
+	"syscall.NOTE_DELETE":                                  "syscall",
+	"syscall.NOTE_EOF":                                     "syscall",
+	"syscall.NOTE_EXEC":                                    "syscall",
+	"syscall.NOTE_EXIT":                                    "syscall",
+	"syscall.NOTE_EXITSTATUS":                              "syscall",
+	"syscall.NOTE_EXTEND":                                  "syscall",
+	"syscall.NOTE_FFAND":                                   "syscall",
+	"syscall.NOTE_FFCOPY":                                  "syscall",
+	"syscall.NOTE_FFCTRLMASK":                              "syscall",
+	"syscall.NOTE_FFLAGSMASK":                              "syscall",
+	"syscall.NOTE_FFNOP":                                   "syscall",
+	"syscall.NOTE_FFOR":                                    "syscall",
+	"syscall.NOTE_FORK":                                    "syscall",
+	"syscall.NOTE_LINK":                                    "syscall",
+	"syscall.NOTE_LOWAT":                                   "syscall",
+	"syscall.NOTE_NONE":                                    "syscall",
+	"syscall.NOTE_NSECONDS":                                "syscall",
+	"syscall.NOTE_PCTRLMASK":                               "syscall",
+	"syscall.NOTE_PDATAMASK":                               "syscall",
+	"syscall.NOTE_REAP":                                    "syscall",
+	"syscall.NOTE_RENAME":                                  "syscall",
+	"syscall.NOTE_RESOURCEEND":                             "syscall",
+	"syscall.NOTE_REVOKE":                                  "syscall",
+	"syscall.NOTE_SECONDS":                                 "syscall",
+	"syscall.NOTE_SIGNAL":                                  "syscall",
+	"syscall.NOTE_TRACK":                                   "syscall",
+	"syscall.NOTE_TRACKERR":                                "syscall",
+	"syscall.NOTE_TRIGGER":                                 "syscall",
+	"syscall.NOTE_TRUNCATE":                                "syscall",
+	"syscall.NOTE_USECONDS":                                "syscall",
+	"syscall.NOTE_VM_ERROR":                                "syscall",
+	"syscall.NOTE_VM_PRESSURE":                             "syscall",
+	"syscall.NOTE_VM_PRESSURE_SUDDEN_TERMINATE":            "syscall",
+	"syscall.NOTE_VM_PRESSURE_TERMINATE":                   "syscall",
+	"syscall.NOTE_WRITE":                                   "syscall",
+	"syscall.NameCanonical":                                "syscall",
+	"syscall.NameCanonicalEx":                              "syscall",
+	"syscall.NameDisplay":                                  "syscall",
+	"syscall.NameDnsDomain":                                "syscall",
+	"syscall.NameFullyQualifiedDN":                         "syscall",
+	"syscall.NameSamCompatible":                            "syscall",
+	"syscall.NameServicePrincipal":                         "syscall",
+	"syscall.NameUniqueId":                                 "syscall",
+	"syscall.NameUnknown":                                  "syscall",
+	"syscall.NameUserPrincipal":                            "syscall",
+	"syscall.Nanosleep":                                    "syscall",
+	"syscall.NetApiBufferFree":                             "syscall",
+	"syscall.NetGetJoinInformation":                        "syscall",
+	"syscall.NetSetupDomainName":                           "syscall",
+	"syscall.NetSetupUnjoined":                             "syscall",
+	"syscall.NetSetupUnknownStatus":                        "syscall",
+	"syscall.NetSetupWorkgroupName":                        "syscall",
+	"syscall.NetUserGetInfo":                               "syscall",
+	"syscall.NetlinkMessage":                               "syscall",
+	"syscall.NetlinkRIB":                                   "syscall",
+	"syscall.NetlinkRouteAttr":                             "syscall",
+	"syscall.NetlinkRouteRequest":                          "syscall",
+	"syscall.NewCallback":                                  "syscall",
+	"syscall.NewCallbackCDecl":                             "syscall",
+	"syscall.NewLazyDLL":                                   "syscall",
+	"syscall.NlAttr":                                       "syscall",
+	"syscall.NlMsgerr":                                     "syscall",
+	"syscall.NlMsghdr":                                     "syscall",
+	"syscall.NsecToFiletime":                               "syscall",
+	"syscall.NsecToTimespec":                               "syscall",
+	"syscall.NsecToTimeval":                                "syscall",
+	"syscall.Ntohs":                                        "syscall",
+	"syscall.OCRNL":                                        "syscall",
+	"syscall.OFDEL":                                        "syscall",
+	"syscall.OFILL":                                        "syscall",
+	"syscall.OFIOGETBMAP":                                  "syscall",
+	"syscall.OID_PKIX_KP_SERVER_AUTH":                      "syscall",
+	"syscall.OID_SERVER_GATED_CRYPTO":                      "syscall",
+	"syscall.OID_SGC_NETSCAPE":                             "syscall",
+	"syscall.OLCUC":                                        "syscall",
+	"syscall.ONLCR":                                        "syscall",
+	"syscall.ONLRET":                                       "syscall",
+	"syscall.ONOCR":                                        "syscall",
+	"syscall.ONOEOT":                                       "syscall",
+	"syscall.OPEN_ALWAYS":                                  "syscall",
+	"syscall.OPEN_EXISTING":                                "syscall",
+	"syscall.OPOST":                                        "syscall",
+	"syscall.O_ACCMODE":                                    "syscall",
+	"syscall.O_ALERT":                                      "syscall",
+	"syscall.O_ALT_IO":                                     "syscall",
+	"syscall.O_APPEND":                                     "syscall",
+	"syscall.O_ASYNC":                                      "syscall",
+	"syscall.O_CLOEXEC":                                    "syscall",
+	"syscall.O_CREAT":                                      "syscall",
+	"syscall.O_DIRECT":                                     "syscall",
+	"syscall.O_DIRECTORY":                                  "syscall",
+	"syscall.O_DSYNC":                                      "syscall",
+	"syscall.O_EVTONLY":                                    "syscall",
+	"syscall.O_EXCL":                                       "syscall",
+	"syscall.O_EXEC":                                       "syscall",
+	"syscall.O_EXLOCK":                                     "syscall",
+	"syscall.O_FSYNC":                                      "syscall",
+	"syscall.O_LARGEFILE":                                  "syscall",
+	"syscall.O_NDELAY":                                     "syscall",
+	"syscall.O_NOATIME":                                    "syscall",
+	"syscall.O_NOCTTY":                                     "syscall",
+	"syscall.O_NOFOLLOW":                                   "syscall",
+	"syscall.O_NONBLOCK":                                   "syscall",
+	"syscall.O_NOSIGPIPE":                                  "syscall",
+	"syscall.O_POPUP":                                      "syscall",
+	"syscall.O_RDONLY":                                     "syscall",
+	"syscall.O_RDWR":                                       "syscall",
+	"syscall.O_RSYNC":                                      "syscall",
+	"syscall.O_SHLOCK":                                     "syscall",
+	"syscall.O_SYMLINK":                                    "syscall",
+	"syscall.O_SYNC":                                       "syscall",
+	"syscall.O_TRUNC":                                      "syscall",
+	"syscall.O_TTY_INIT":                                   "syscall",
+	"syscall.O_WRONLY":                                     "syscall",
+	"syscall.Open":                                         "syscall",
+	"syscall.OpenCurrentProcessToken":                      "syscall",
+	"syscall.OpenProcess":                                  "syscall",
+	"syscall.OpenProcessToken":                             "syscall",
+	"syscall.Openat":                                       "syscall",
+	"syscall.Overlapped":                                   "syscall",
+	"syscall.PACKET_ADD_MEMBERSHIP":                        "syscall",
+	"syscall.PACKET_BROADCAST":                             "syscall",
+	"syscall.PACKET_DROP_MEMBERSHIP":                       "syscall",
+	"syscall.PACKET_FASTROUTE":                             "syscall",
+	"syscall.PACKET_HOST":                                  "syscall",
+	"syscall.PACKET_LOOPBACK":                              "syscall",
+	"syscall.PACKET_MR_ALLMULTI":                           "syscall",
+	"syscall.PACKET_MR_MULTICAST":                          "syscall",
+	"syscall.PACKET_MR_PROMISC":                            "syscall",
+	"syscall.PACKET_MULTICAST":                             "syscall",
+	"syscall.PACKET_OTHERHOST":                             "syscall",
+	"syscall.PACKET_OUTGOING":                              "syscall",
+	"syscall.PACKET_RECV_OUTPUT":                           "syscall",
+	"syscall.PACKET_RX_RING":                               "syscall",
+	"syscall.PACKET_STATISTICS":                            "syscall",
+	"syscall.PAGE_EXECUTE_READ":                            "syscall",
+	"syscall.PAGE_EXECUTE_READWRITE":                       "syscall",
+	"syscall.PAGE_EXECUTE_WRITECOPY":                       "syscall",
+	"syscall.PAGE_READONLY":                                "syscall",
+	"syscall.PAGE_READWRITE":                               "syscall",
+	"syscall.PAGE_WRITECOPY":                               "syscall",
+	"syscall.PARENB":                                       "syscall",
+	"syscall.PARMRK":                                       "syscall",
+	"syscall.PARODD":                                       "syscall",
+	"syscall.PENDIN":                                       "syscall",
+	"syscall.PFL_HIDDEN":                                   "syscall",
+	"syscall.PFL_MATCHES_PROTOCOL_ZERO":                    "syscall",
+	"syscall.PFL_MULTIPLE_PROTO_ENTRIES":                   "syscall",
+	"syscall.PFL_NETWORKDIRECT_PROVIDER":                   "syscall",
+	"syscall.PFL_RECOMMENDED_PROTO_ENTRY":                  "syscall",
+	"syscall.PF_FLUSH":                                     "syscall",
+	"syscall.PKCS_7_ASN_ENCODING":                          "syscall",
+	"syscall.PMC5_PIPELINE_FLUSH":                          "syscall",
+	"syscall.PRIO_PGRP":                                    "syscall",
+	"syscall.PRIO_PROCESS":                                 "syscall",
+	"syscall.PRIO_USER":                                    "syscall",
+	"syscall.PRI_IOFLUSH":                                  "syscall",
+	"syscall.PROCESS_QUERY_INFORMATION":                    "syscall",
+	"syscall.PROCESS_TERMINATE":                            "syscall",
+	"syscall.PROT_EXEC":                                    "syscall",
+	"syscall.PROT_GROWSDOWN":                               "syscall",
+	"syscall.PROT_GROWSUP":                                 "syscall",
+	"syscall.PROT_NONE":                                    "syscall",
+	"syscall.PROT_READ":                                    "syscall",
+	"syscall.PROT_WRITE":                                   "syscall",
+	"syscall.PROV_DH_SCHANNEL":                             "syscall",
+	"syscall.PROV_DSS":                                     "syscall",
+	"syscall.PROV_DSS_DH":                                  "syscall",
+	"syscall.PROV_EC_ECDSA_FULL":                           "syscall",
+	"syscall.PROV_EC_ECDSA_SIG":                            "syscall",
+	"syscall.PROV_EC_ECNRA_FULL":                           "syscall",
+	"syscall.PROV_EC_ECNRA_SIG":                            "syscall",
+	"syscall.PROV_FORTEZZA":                                "syscall",
+	"syscall.PROV_INTEL_SEC":                               "syscall",
+	"syscall.PROV_MS_EXCHANGE":                             "syscall",
+	"syscall.PROV_REPLACE_OWF":                             "syscall",
+	"syscall.PROV_RNG":                                     "syscall",
+	"syscall.PROV_RSA_AES":                                 "syscall",
+	"syscall.PROV_RSA_FULL":                                "syscall",
+	"syscall.PROV_RSA_SCHANNEL":                            "syscall",
+	"syscall.PROV_RSA_SIG":                                 "syscall",
+	"syscall.PROV_SPYRUS_LYNKS":                            "syscall",
+	"syscall.PROV_SSL":                                     "syscall",
+	"syscall.PR_CAPBSET_DROP":                              "syscall",
+	"syscall.PR_CAPBSET_READ":                              "syscall",
+	"syscall.PR_CLEAR_SECCOMP_FILTER":                      "syscall",
+	"syscall.PR_ENDIAN_BIG":                                "syscall",
+	"syscall.PR_ENDIAN_LITTLE":                             "syscall",
+	"syscall.PR_ENDIAN_PPC_LITTLE":                         "syscall",
+	"syscall.PR_FPEMU_NOPRINT":                             "syscall",
+	"syscall.PR_FPEMU_SIGFPE":                              "syscall",
+	"syscall.PR_FP_EXC_ASYNC":                              "syscall",
+	"syscall.PR_FP_EXC_DISABLED":                           "syscall",
+	"syscall.PR_FP_EXC_DIV":                                "syscall",
+	"syscall.PR_FP_EXC_INV":                                "syscall",
+	"syscall.PR_FP_EXC_NONRECOV":                           "syscall",
+	"syscall.PR_FP_EXC_OVF":                                "syscall",
+	"syscall.PR_FP_EXC_PRECISE":                            "syscall",
+	"syscall.PR_FP_EXC_RES":                                "syscall",
+	"syscall.PR_FP_EXC_SW_ENABLE":                          "syscall",
+	"syscall.PR_FP_EXC_UND":                                "syscall",
+	"syscall.PR_GET_DUMPABLE":                              "syscall",
+	"syscall.PR_GET_ENDIAN":                                "syscall",
+	"syscall.PR_GET_FPEMU":                                 "syscall",
+	"syscall.PR_GET_FPEXC":                                 "syscall",
+	"syscall.PR_GET_KEEPCAPS":                              "syscall",
+	"syscall.PR_GET_NAME":                                  "syscall",
+	"syscall.PR_GET_PDEATHSIG":                             "syscall",
+	"syscall.PR_GET_SECCOMP":                               "syscall",
+	"syscall.PR_GET_SECCOMP_FILTER":                        "syscall",
+	"syscall.PR_GET_SECUREBITS":                            "syscall",
+	"syscall.PR_GET_TIMERSLACK":                            "syscall",
+	"syscall.PR_GET_TIMING":                                "syscall",
+	"syscall.PR_GET_TSC":                                   "syscall",
+	"syscall.PR_GET_UNALIGN":                               "syscall",
+	"syscall.PR_MCE_KILL":                                  "syscall",
+	"syscall.PR_MCE_KILL_CLEAR":                            "syscall",
+	"syscall.PR_MCE_KILL_DEFAULT":                          "syscall",
+	"syscall.PR_MCE_KILL_EARLY":                            "syscall",
+	"syscall.PR_MCE_KILL_GET":                              "syscall",
+	"syscall.PR_MCE_KILL_LATE":                             "syscall",
+	"syscall.PR_MCE_KILL_SET":                              "syscall",
+	"syscall.PR_SECCOMP_FILTER_EVENT":                      "syscall",
+	"syscall.PR_SECCOMP_FILTER_SYSCALL":                    "syscall",
+	"syscall.PR_SET_DUMPABLE":                              "syscall",
+	"syscall.PR_SET_ENDIAN":                                "syscall",
+	"syscall.PR_SET_FPEMU":                                 "syscall",
+	"syscall.PR_SET_FPEXC":                                 "syscall",
+	"syscall.PR_SET_KEEPCAPS":                              "syscall",
+	"syscall.PR_SET_NAME":                                  "syscall",
+	"syscall.PR_SET_PDEATHSIG":                             "syscall",
+	"syscall.PR_SET_PTRACER":                               "syscall",
+	"syscall.PR_SET_SECCOMP":                               "syscall",
+	"syscall.PR_SET_SECCOMP_FILTER":                        "syscall",
+	"syscall.PR_SET_SECUREBITS":                            "syscall",
+	"syscall.PR_SET_TIMERSLACK":                            "syscall",
+	"syscall.PR_SET_TIMING":                                "syscall",
+	"syscall.PR_SET_TSC":                                   "syscall",
+	"syscall.PR_SET_UNALIGN":                               "syscall",
+	"syscall.PR_TASK_PERF_EVENTS_DISABLE":                  "syscall",
+	"syscall.PR_TASK_PERF_EVENTS_ENABLE":                   "syscall",
+	"syscall.PR_TIMING_STATISTICAL":                        "syscall",
+	"syscall.PR_TIMING_TIMESTAMP":                          "syscall",
+	"syscall.PR_TSC_ENABLE":                                "syscall",
+	"syscall.PR_TSC_SIGSEGV":                               "syscall",
+	"syscall.PR_UNALIGN_NOPRINT":                           "syscall",
+	"syscall.PR_UNALIGN_SIGBUS":                            "syscall",
+	"syscall.PTRACE_ARCH_PRCTL":                            "syscall",
+	"syscall.PTRACE_ATTACH":                                "syscall",
+	"syscall.PTRACE_CONT":                                  "syscall",
+	"syscall.PTRACE_DETACH":                                "syscall",
+	"syscall.PTRACE_EVENT_CLONE":                           "syscall",
+	"syscall.PTRACE_EVENT_EXEC":                            "syscall",
+	"syscall.PTRACE_EVENT_EXIT":                            "syscall",
+	"syscall.PTRACE_EVENT_FORK":                            "syscall",
+	"syscall.PTRACE_EVENT_VFORK":                           "syscall",
+	"syscall.PTRACE_EVENT_VFORK_DONE":                      "syscall",
+	"syscall.PTRACE_GETCRUNCHREGS":                         "syscall",
+	"syscall.PTRACE_GETEVENTMSG":                           "syscall",
+	"syscall.PTRACE_GETFPREGS":                             "syscall",
+	"syscall.PTRACE_GETFPXREGS":                            "syscall",
+	"syscall.PTRACE_GETHBPREGS":                            "syscall",
+	"syscall.PTRACE_GETREGS":                               "syscall",
+	"syscall.PTRACE_GETREGSET":                             "syscall",
+	"syscall.PTRACE_GETSIGINFO":                            "syscall",
+	"syscall.PTRACE_GETVFPREGS":                            "syscall",
+	"syscall.PTRACE_GETWMMXREGS":                           "syscall",
+	"syscall.PTRACE_GET_THREAD_AREA":                       "syscall",
+	"syscall.PTRACE_KILL":                                  "syscall",
+	"syscall.PTRACE_OLDSETOPTIONS":                         "syscall",
+	"syscall.PTRACE_O_MASK":                                "syscall",
+	"syscall.PTRACE_O_TRACECLONE":                          "syscall",
+	"syscall.PTRACE_O_TRACEEXEC":                           "syscall",
+	"syscall.PTRACE_O_TRACEEXIT":                           "syscall",
+	"syscall.PTRACE_O_TRACEFORK":                           "syscall",
+	"syscall.PTRACE_O_TRACESYSGOOD":                        "syscall",
+	"syscall.PTRACE_O_TRACEVFORK":                          "syscall",
+	"syscall.PTRACE_O_TRACEVFORKDONE":                      "syscall",
+	"syscall.PTRACE_PEEKDATA":                              "syscall",
+	"syscall.PTRACE_PEEKTEXT":                              "syscall",
+	"syscall.PTRACE_PEEKUSR":                               "syscall",
+	"syscall.PTRACE_POKEDATA":                              "syscall",
+	"syscall.PTRACE_POKETEXT":                              "syscall",
+	"syscall.PTRACE_POKEUSR":                               "syscall",
+	"syscall.PTRACE_SETCRUNCHREGS":                         "syscall",
+	"syscall.PTRACE_SETFPREGS":                             "syscall",
+	"syscall.PTRACE_SETFPXREGS":                            "syscall",
+	"syscall.PTRACE_SETHBPREGS":                            "syscall",
+	"syscall.PTRACE_SETOPTIONS":                            "syscall",
+	"syscall.PTRACE_SETREGS":                               "syscall",
+	"syscall.PTRACE_SETREGSET":                             "syscall",
+	"syscall.PTRACE_SETSIGINFO":                            "syscall",
+	"syscall.PTRACE_SETVFPREGS":                            "syscall",
+	"syscall.PTRACE_SETWMMXREGS":                           "syscall",
+	"syscall.PTRACE_SET_SYSCALL":                           "syscall",
+	"syscall.PTRACE_SET_THREAD_AREA":                       "syscall",
+	"syscall.PTRACE_SINGLEBLOCK":                           "syscall",
+	"syscall.PTRACE_SINGLESTEP":                            "syscall",
+	"syscall.PTRACE_SYSCALL":                               "syscall",
+	"syscall.PTRACE_SYSEMU":                                "syscall",
+	"syscall.PTRACE_SYSEMU_SINGLESTEP":                     "syscall",
+	"syscall.PTRACE_TRACEME":                               "syscall",
+	"syscall.PT_ATTACH":                                    "syscall",
+	"syscall.PT_ATTACHEXC":                                 "syscall",
+	"syscall.PT_CONTINUE":                                  "syscall",
+	"syscall.PT_DATA_ADDR":                                 "syscall",
+	"syscall.PT_DENY_ATTACH":                               "syscall",
+	"syscall.PT_DETACH":                                    "syscall",
+	"syscall.PT_FIRSTMACH":                                 "syscall",
+	"syscall.PT_FORCEQUOTA":                                "syscall",
+	"syscall.PT_KILL":                                      "syscall",
+	"syscall.PT_MASK":                                      "syscall",
+	"syscall.PT_READ_D":                                    "syscall",
+	"syscall.PT_READ_I":                                    "syscall",
+	"syscall.PT_READ_U":                                    "syscall",
+	"syscall.PT_SIGEXC":                                    "syscall",
+	"syscall.PT_STEP":                                      "syscall",
+	"syscall.PT_TEXT_ADDR":                                 "syscall",
+	"syscall.PT_TEXT_END_ADDR":                             "syscall",
+	"syscall.PT_THUPDATE":                                  "syscall",
+	"syscall.PT_TRACE_ME":                                  "syscall",
+	"syscall.PT_WRITE_D":                                   "syscall",
+	"syscall.PT_WRITE_I":                                   "syscall",
+	"syscall.PT_WRITE_U":                                   "syscall",
+	"syscall.ParseDirent":                                  "syscall",
+	"syscall.ParseNetlinkMessage":                          "syscall",
+	"syscall.ParseNetlinkRouteAttr":                        "syscall",
+	"syscall.ParseRoutingMessage":                          "syscall",
+	"syscall.ParseRoutingSockaddr":                         "syscall",
+	"syscall.ParseSocketControlMessage":                    "syscall",
+	"syscall.ParseUnixCredentials":                         "syscall",
+	"syscall.ParseUnixRights":                              "syscall",
+	"syscall.PathMax":                                      "syscall",
+	"syscall.Pathconf":                                     "syscall",
+	"syscall.Pause":                                        "syscall",
+	"syscall.Pipe":                                         "syscall",
+	"syscall.Pipe2":                                        "syscall",
+	"syscall.PivotRoot":                                    "syscall",
+	"syscall.PostQueuedCompletionStatus":                   "syscall",
+	"syscall.Pread":                                        "syscall",
+	"syscall.Proc":                                         "syscall",
+	"syscall.ProcAttr":                                     "syscall",
+	"syscall.Process32First":                               "syscall",
+	"syscall.Process32Next":                                "syscall",
+	"syscall.ProcessEntry32":                               "syscall",
+	"syscall.ProcessInformation":                           "syscall",
+	"syscall.Protoent":                                     "syscall",
+	"syscall.PtraceAttach":                                 "syscall",
+	"syscall.PtraceCont":                                   "syscall",
+	"syscall.PtraceDetach":                                 "syscall",
+	"syscall.PtraceGetEventMsg":                            "syscall",
+	"syscall.PtraceGetRegs":                                "syscall",
+	"syscall.PtracePeekData":                               "syscall",
+	"syscall.PtracePeekText":                               "syscall",
+	"syscall.PtracePokeData":                               "syscall",
+	"syscall.PtracePokeText":                               "syscall",
+	"syscall.PtraceRegs":                                   "syscall",
+	"syscall.PtraceSetOptions":                             "syscall",
+	"syscall.PtraceSetRegs":                                "syscall",
+	"syscall.PtraceSingleStep":                             "syscall",
+	"syscall.PtraceSyscall":                                "syscall",
+	"syscall.Pwrite":                                       "syscall",
+	"syscall.REG_BINARY":                                   "syscall",
+	"syscall.REG_DWORD":                                    "syscall",
+	"syscall.REG_DWORD_BIG_ENDIAN":                         "syscall",
+	"syscall.REG_DWORD_LITTLE_ENDIAN":                      "syscall",
+	"syscall.REG_EXPAND_SZ":                                "syscall",
+	"syscall.REG_FULL_RESOURCE_DESCRIPTOR":                 "syscall",
+	"syscall.REG_LINK":                                     "syscall",
+	"syscall.REG_MULTI_SZ":                                 "syscall",
+	"syscall.REG_NONE":                                     "syscall",
+	"syscall.REG_QWORD":                                    "syscall",
+	"syscall.REG_QWORD_LITTLE_ENDIAN":                      "syscall",
+	"syscall.REG_RESOURCE_LIST":                            "syscall",
+	"syscall.REG_RESOURCE_REQUIREMENTS_LIST":               "syscall",
+	"syscall.REG_SZ":                                       "syscall",
+	"syscall.RLIMIT_AS":                                    "syscall",
+	"syscall.RLIMIT_CORE":                                  "syscall",
+	"syscall.RLIMIT_CPU":                                   "syscall",
+	"syscall.RLIMIT_DATA":                                  "syscall",
+	"syscall.RLIMIT_FSIZE":                                 "syscall",
+	"syscall.RLIMIT_NOFILE":                                "syscall",
+	"syscall.RLIMIT_STACK":                                 "syscall",
+	"syscall.RLIM_INFINITY":                                "syscall",
+	"syscall.RTAX_ADVMSS":                                  "syscall",
+	"syscall.RTAX_AUTHOR":                                  "syscall",
+	"syscall.RTAX_BRD":                                     "syscall",
+	"syscall.RTAX_CWND":                                    "syscall",
+	"syscall.RTAX_DST":                                     "syscall",
+	"syscall.RTAX_FEATURES":                                "syscall",
+	"syscall.RTAX_FEATURE_ALLFRAG":                         "syscall",
+	"syscall.RTAX_FEATURE_ECN":                             "syscall",
+	"syscall.RTAX_FEATURE_SACK":                            "syscall",
+	"syscall.RTAX_FEATURE_TIMESTAMP":                       "syscall",
+	"syscall.RTAX_GATEWAY":                                 "syscall",
+	"syscall.RTAX_GENMASK":                                 "syscall",
+	"syscall.RTAX_HOPLIMIT":                                "syscall",
+	"syscall.RTAX_IFA":                                     "syscall",
+	"syscall.RTAX_IFP":                                     "syscall",
+	"syscall.RTAX_INITCWND":                                "syscall",
+	"syscall.RTAX_INITRWND":                                "syscall",
+	"syscall.RTAX_LABEL":                                   "syscall",
+	"syscall.RTAX_LOCK":                                    "syscall",
+	"syscall.RTAX_MAX":                                     "syscall",
+	"syscall.RTAX_MTU":                                     "syscall",
+	"syscall.RTAX_NETMASK":                                 "syscall",
+	"syscall.RTAX_REORDERING":                              "syscall",
+	"syscall.RTAX_RTO_MIN":                                 "syscall",
+	"syscall.RTAX_RTT":                                     "syscall",
+	"syscall.RTAX_RTTVAR":                                  "syscall",
+	"syscall.RTAX_SRC":                                     "syscall",
+	"syscall.RTAX_SRCMASK":                                 "syscall",
+	"syscall.RTAX_SSTHRESH":                                "syscall",
+	"syscall.RTAX_TAG":                                     "syscall",
+	"syscall.RTAX_UNSPEC":                                  "syscall",
+	"syscall.RTAX_WINDOW":                                  "syscall",
+	"syscall.RTA_ALIGNTO":                                  "syscall",
+	"syscall.RTA_AUTHOR":                                   "syscall",
+	"syscall.RTA_BRD":                                      "syscall",
+	"syscall.RTA_CACHEINFO":                                "syscall",
+	"syscall.RTA_DST":                                      "syscall",
+	"syscall.RTA_FLOW":                                     "syscall",
+	"syscall.RTA_GATEWAY":                                  "syscall",
+	"syscall.RTA_GENMASK":                                  "syscall",
+	"syscall.RTA_IFA":                                      "syscall",
+	"syscall.RTA_IFP":                                      "syscall",
+	"syscall.RTA_IIF":                                      "syscall",
+	"syscall.RTA_LABEL":                                    "syscall",
+	"syscall.RTA_MAX":                                      "syscall",
+	"syscall.RTA_METRICS":                                  "syscall",
+	"syscall.RTA_MULTIPATH":                                "syscall",
+	"syscall.RTA_NETMASK":                                  "syscall",
+	"syscall.RTA_OIF":                                      "syscall",
+	"syscall.RTA_PREFSRC":                                  "syscall",
+	"syscall.RTA_PRIORITY":                                 "syscall",
+	"syscall.RTA_SRC":                                      "syscall",
+	"syscall.RTA_SRCMASK":                                  "syscall",
+	"syscall.RTA_TABLE":                                    "syscall",
+	"syscall.RTA_TAG":                                      "syscall",
+	"syscall.RTA_UNSPEC":                                   "syscall",
+	"syscall.RTCF_DIRECTSRC":                               "syscall",
+	"syscall.RTCF_DOREDIRECT":                              "syscall",
+	"syscall.RTCF_LOG":                                     "syscall",
+	"syscall.RTCF_MASQ":                                    "syscall",
+	"syscall.RTCF_NAT":                                     "syscall",
+	"syscall.RTCF_VALVE":                                   "syscall",
+	"syscall.RTF_ADDRCLASSMASK":                            "syscall",
+	"syscall.RTF_ADDRCONF":                                 "syscall",
+	"syscall.RTF_ALLONLINK":                                "syscall",
+	"syscall.RTF_ANNOUNCE":                                 "syscall",
+	"syscall.RTF_BLACKHOLE":                                "syscall",
+	"syscall.RTF_BROADCAST":                                "syscall",
+	"syscall.RTF_CACHE":                                    "syscall",
+	"syscall.RTF_CLONED":                                   "syscall",
+	"syscall.RTF_CLONING":                                  "syscall",
+	"syscall.RTF_CONDEMNED":                                "syscall",
+	"syscall.RTF_DEFAULT":                                  "syscall",
+	"syscall.RTF_DELCLONE":                                 "syscall",
+	"syscall.RTF_DONE":                                     "syscall",
+	"syscall.RTF_DYNAMIC":                                  "syscall",
+	"syscall.RTF_FLOW":                                     "syscall",
+	"syscall.RTF_FMASK":                                    "syscall",
+	"syscall.RTF_GATEWAY":                                  "syscall",
+	"syscall.RTF_GWFLAG_COMPAT":                            "syscall",
+	"syscall.RTF_HOST":                                     "syscall",
+	"syscall.RTF_IFREF":                                    "syscall",
+	"syscall.RTF_IFSCOPE":                                  "syscall",
+	"syscall.RTF_INTERFACE":                                "syscall",
+	"syscall.RTF_IRTT":                                     "syscall",
+	"syscall.RTF_LINKRT":                                   "syscall",
+	"syscall.RTF_LLDATA":                                   "syscall",
+	"syscall.RTF_LLINFO":                                   "syscall",
+	"syscall.RTF_LOCAL":                                    "syscall",
+	"syscall.RTF_MASK":                                     "syscall",
+	"syscall.RTF_MODIFIED":                                 "syscall",
+	"syscall.RTF_MPATH":                                    "syscall",
+	"syscall.RTF_MPLS":                                     "syscall",
+	"syscall.RTF_MSS":                                      "syscall",
+	"syscall.RTF_MTU":                                      "syscall",
+	"syscall.RTF_MULTICAST":                                "syscall",
+	"syscall.RTF_NAT":                                      "syscall",
+	"syscall.RTF_NOFORWARD":                                "syscall",
+	"syscall.RTF_NONEXTHOP":                                "syscall",
+	"syscall.RTF_NOPMTUDISC":                               "syscall",
+	"syscall.RTF_PERMANENT_ARP":                            "syscall",
+	"syscall.RTF_PINNED":                                   "syscall",
+	"syscall.RTF_POLICY":                                   "syscall",
+	"syscall.RTF_PRCLONING":                                "syscall",
+	"syscall.RTF_PROTO1":                                   "syscall",
+	"syscall.RTF_PROTO2":                                   "syscall",
+	"syscall.RTF_PROTO3":                                   "syscall",
+	"syscall.RTF_REINSTATE":                                "syscall",
+	"syscall.RTF_REJECT":                                   "syscall",
+	"syscall.RTF_RNH_LOCKED":                               "syscall",
+	"syscall.RTF_SOURCE":                                   "syscall",
+	"syscall.RTF_SRC":                                      "syscall",
+	"syscall.RTF_STATIC":                                   "syscall",
+	"syscall.RTF_STICKY":                                   "syscall",
+	"syscall.RTF_THROW":                                    "syscall",
+	"syscall.RTF_TUNNEL":                                   "syscall",
+	"syscall.RTF_UP":                                       "syscall",
+	"syscall.RTF_USETRAILERS":                              "syscall",
+	"syscall.RTF_WASCLONED":                                "syscall",
+	"syscall.RTF_WINDOW":                                   "syscall",
+	"syscall.RTF_XRESOLVE":                                 "syscall",
+	"syscall.RTM_ADD":                                      "syscall",
+	"syscall.RTM_BASE":                                     "syscall",
+	"syscall.RTM_CHANGE":                                   "syscall",
+	"syscall.RTM_CHGADDR":                                  "syscall",
+	"syscall.RTM_DELACTION":                                "syscall",
+	"syscall.RTM_DELADDR":                                  "syscall",
+	"syscall.RTM_DELADDRLABEL":                             "syscall",
+	"syscall.RTM_DELETE":                                   "syscall",
+	"syscall.RTM_DELLINK":                                  "syscall",
+	"syscall.RTM_DELMADDR":                                 "syscall",
+	"syscall.RTM_DELNEIGH":                                 "syscall",
+	"syscall.RTM_DELQDISC":                                 "syscall",
+	"syscall.RTM_DELROUTE":                                 "syscall",
+	"syscall.RTM_DELRULE":                                  "syscall",
+	"syscall.RTM_DELTCLASS":                                "syscall",
+	"syscall.RTM_DELTFILTER":                               "syscall",
+	"syscall.RTM_DESYNC":                                   "syscall",
+	"syscall.RTM_F_CLONED":                                 "syscall",
+	"syscall.RTM_F_EQUALIZE":                               "syscall",
+	"syscall.RTM_F_NOTIFY":                                 "syscall",
+	"syscall.RTM_F_PREFIX":                                 "syscall",
+	"syscall.RTM_GET":                                      "syscall",
+	"syscall.RTM_GET2":                                     "syscall",
+	"syscall.RTM_GETACTION":                                "syscall",
+	"syscall.RTM_GETADDR":                                  "syscall",
+	"syscall.RTM_GETADDRLABEL":                             "syscall",
+	"syscall.RTM_GETANYCAST":                               "syscall",
+	"syscall.RTM_GETDCB":                                   "syscall",
+	"syscall.RTM_GETLINK":                                  "syscall",
+	"syscall.RTM_GETMULTICAST":                             "syscall",
+	"syscall.RTM_GETNEIGH":                                 "syscall",
+	"syscall.RTM_GETNEIGHTBL":                              "syscall",
+	"syscall.RTM_GETQDISC":                                 "syscall",
+	"syscall.RTM_GETROUTE":                                 "syscall",
+	"syscall.RTM_GETRULE":                                  "syscall",
+	"syscall.RTM_GETTCLASS":                                "syscall",
+	"syscall.RTM_GETTFILTER":                               "syscall",
+	"syscall.RTM_IEEE80211":                                "syscall",
+	"syscall.RTM_IFANNOUNCE":                               "syscall",
+	"syscall.RTM_IFINFO":                                   "syscall",
+	"syscall.RTM_IFINFO2":                                  "syscall",
+	"syscall.RTM_LLINFO_UPD":                               "syscall",
+	"syscall.RTM_LOCK":                                     "syscall",
+	"syscall.RTM_LOSING":                                   "syscall",
+	"syscall.RTM_MAX":                                      "syscall",
+	"syscall.RTM_MAXSIZE":                                  "syscall",
+	"syscall.RTM_MISS":                                     "syscall",
+	"syscall.RTM_NEWACTION":                                "syscall",
+	"syscall.RTM_NEWADDR":                                  "syscall",
+	"syscall.RTM_NEWADDRLABEL":                             "syscall",
+	"syscall.RTM_NEWLINK":                                  "syscall",
+	"syscall.RTM_NEWMADDR":                                 "syscall",
+	"syscall.RTM_NEWMADDR2":                                "syscall",
+	"syscall.RTM_NEWNDUSEROPT":                             "syscall",
+	"syscall.RTM_NEWNEIGH":                                 "syscall",
+	"syscall.RTM_NEWNEIGHTBL":                              "syscall",
+	"syscall.RTM_NEWPREFIX":                                "syscall",
+	"syscall.RTM_NEWQDISC":                                 "syscall",
+	"syscall.RTM_NEWROUTE":                                 "syscall",
+	"syscall.RTM_NEWRULE":                                  "syscall",
+	"syscall.RTM_NEWTCLASS":                                "syscall",
+	"syscall.RTM_NEWTFILTER":                               "syscall",
+	"syscall.RTM_NR_FAMILIES":                              "syscall",
+	"syscall.RTM_NR_MSGTYPES":                              "syscall",
+	"syscall.RTM_OIFINFO":                                  "syscall",
+	"syscall.RTM_OLDADD":                                   "syscall",
+	"syscall.RTM_OLDDEL":                                   "syscall",
+	"syscall.RTM_OOIFINFO":                                 "syscall",
+	"syscall.RTM_REDIRECT":                                 "syscall",
+	"syscall.RTM_RESOLVE":                                  "syscall",
+	"syscall.RTM_RTTUNIT":                                  "syscall",
+	"syscall.RTM_SETDCB":                                   "syscall",
+	"syscall.RTM_SETGATE":                                  "syscall",
+	"syscall.RTM_SETLINK":                                  "syscall",
+	"syscall.RTM_SETNEIGHTBL":                              "syscall",
+	"syscall.RTM_VERSION":                                  "syscall",
+	"syscall.RTNH_ALIGNTO":                                 "syscall",
+	"syscall.RTNH_F_DEAD":                                  "syscall",
+	"syscall.RTNH_F_ONLINK":                                "syscall",
+	"syscall.RTNH_F_PERVASIVE":                             "syscall",
+	"syscall.RTNLGRP_IPV4_IFADDR":                          "syscall",
+	"syscall.RTNLGRP_IPV4_MROUTE":                          "syscall",
+	"syscall.RTNLGRP_IPV4_ROUTE":                           "syscall",
+	"syscall.RTNLGRP_IPV4_RULE":                            "syscall",
+	"syscall.RTNLGRP_IPV6_IFADDR":                          "syscall",
+	"syscall.RTNLGRP_IPV6_IFINFO":                          "syscall",
+	"syscall.RTNLGRP_IPV6_MROUTE":                          "syscall",
+	"syscall.RTNLGRP_IPV6_PREFIX":                          "syscall",
+	"syscall.RTNLGRP_IPV6_ROUTE":                           "syscall",
+	"syscall.RTNLGRP_IPV6_RULE":                            "syscall",
+	"syscall.RTNLGRP_LINK":                                 "syscall",
+	"syscall.RTNLGRP_ND_USEROPT":                           "syscall",
+	"syscall.RTNLGRP_NEIGH":                                "syscall",
+	"syscall.RTNLGRP_NONE":                                 "syscall",
+	"syscall.RTNLGRP_NOTIFY":                               "syscall",
+	"syscall.RTNLGRP_TC":                                   "syscall",
+	"syscall.RTN_ANYCAST":                                  "syscall",
+	"syscall.RTN_BLACKHOLE":                                "syscall",
+	"syscall.RTN_BROADCAST":                                "syscall",
+	"syscall.RTN_LOCAL":                                    "syscall",
+	"syscall.RTN_MAX":                                      "syscall",
+	"syscall.RTN_MULTICAST":                                "syscall",
+	"syscall.RTN_NAT":                                      "syscall",
+	"syscall.RTN_PROHIBIT":                                 "syscall",
+	"syscall.RTN_THROW":                                    "syscall",
+	"syscall.RTN_UNICAST":                                  "syscall",
+	"syscall.RTN_UNREACHABLE":                              "syscall",
+	"syscall.RTN_UNSPEC":                                   "syscall",
+	"syscall.RTN_XRESOLVE":                                 "syscall",
+	"syscall.RTPROT_BIRD":                                  "syscall",
+	"syscall.RTPROT_BOOT":                                  "syscall",
+	"syscall.RTPROT_DHCP":                                  "syscall",
+	"syscall.RTPROT_DNROUTED":                              "syscall",
+	"syscall.RTPROT_GATED":                                 "syscall",
+	"syscall.RTPROT_KERNEL":                                "syscall",
+	"syscall.RTPROT_MRT":                                   "syscall",
+	"syscall.RTPROT_NTK":                                   "syscall",
+	"syscall.RTPROT_RA":                                    "syscall",
+	"syscall.RTPROT_REDIRECT":                              "syscall",
+	"syscall.RTPROT_STATIC":                                "syscall",
+	"syscall.RTPROT_UNSPEC":                                "syscall",
+	"syscall.RTPROT_XORP":                                  "syscall",
+	"syscall.RTPROT_ZEBRA":                                 "syscall",
+	"syscall.RTV_EXPIRE":                                   "syscall",
+	"syscall.RTV_HOPCOUNT":                                 "syscall",
+	"syscall.RTV_MTU":                                      "syscall",
+	"syscall.RTV_RPIPE":                                    "syscall",
+	"syscall.RTV_RTT":                                      "syscall",
+	"syscall.RTV_RTTVAR":                                   "syscall",
+	"syscall.RTV_SPIPE":                                    "syscall",
+	"syscall.RTV_SSTHRESH":                                 "syscall",
+	"syscall.RTV_WEIGHT":                                   "syscall",
+	"syscall.RT_CACHING_CONTEXT":                           "syscall",
+	"syscall.RT_CLASS_DEFAULT":                             "syscall",
+	"syscall.RT_CLASS_LOCAL":                               "syscall",
+	"syscall.RT_CLASS_MAIN":                                "syscall",
+	"syscall.RT_CLASS_MAX":                                 "syscall",
+	"syscall.RT_CLASS_UNSPEC":                              "syscall",
+	"syscall.RT_DEFAULT_FIB":                               "syscall",
+	"syscall.RT_NORTREF":                                   "syscall",
+	"syscall.RT_SCOPE_HOST":                                "syscall",
+	"syscall.RT_SCOPE_LINK":                                "syscall",
+	"syscall.RT_SCOPE_NOWHERE":                             "syscall",
+	"syscall.RT_SCOPE_SITE":                                "syscall",
+	"syscall.RT_SCOPE_UNIVERSE":                            "syscall",
+	"syscall.RT_TABLEID_MAX":                               "syscall",
+	"syscall.RT_TABLE_COMPAT":                              "syscall",
+	"syscall.RT_TABLE_DEFAULT":                             "syscall",
+	"syscall.RT_TABLE_LOCAL":                               "syscall",
+	"syscall.RT_TABLE_MAIN":                                "syscall",
+	"syscall.RT_TABLE_MAX":                                 "syscall",
+	"syscall.RT_TABLE_UNSPEC":                              "syscall",
+	"syscall.RUSAGE_CHILDREN":                              "syscall",
+	"syscall.RUSAGE_SELF":                                  "syscall",
+	"syscall.RUSAGE_THREAD":                                "syscall",
+	"syscall.Radvisory_t":                                  "syscall",
+	"syscall.RawConn":                                      "syscall",
+	"syscall.RawSockaddr":                                  "syscall",
+	"syscall.RawSockaddrAny":                               "syscall",
+	"syscall.RawSockaddrDatalink":                          "syscall",
+	"syscall.RawSockaddrInet4":                             "syscall",
+	"syscall.RawSockaddrInet6":                             "syscall",
+	"syscall.RawSockaddrLinklayer":                         "syscall",
+	"syscall.RawSockaddrNetlink":                           "syscall",
+	"syscall.RawSockaddrUnix":                              "syscall",
+	"syscall.RawSyscall":                                   "syscall",
+	"syscall.RawSyscall6":                                  "syscall",
+	"syscall.Read":                                         "syscall",
+	"syscall.ReadConsole":                                  "syscall",
+	"syscall.ReadDirectoryChanges":                         "syscall",
+	"syscall.ReadDirent":                                   "syscall",
+	"syscall.ReadFile":                                     "syscall",
+	"syscall.Readlink":                                     "syscall",
+	"syscall.Reboot":                                       "syscall",
+	"syscall.Recvfrom":                                     "syscall",
+	"syscall.Recvmsg":                                      "syscall",
+	"syscall.RegCloseKey":                                  "syscall",
+	"syscall.RegEnumKeyEx":                                 "syscall",
+	"syscall.RegOpenKeyEx":                                 "syscall",
+	"syscall.RegQueryInfoKey":                              "syscall",
+	"syscall.RegQueryValueEx":                              "syscall",
+	"syscall.RemoveDirectory":                              "syscall",
+	"syscall.Removexattr":                                  "syscall",
+	"syscall.Rename":                                       "syscall",
+	"syscall.Renameat":                                     "syscall",
+	"syscall.Revoke":                                       "syscall",
+	"syscall.Rlimit":                                       "syscall",
+	"syscall.Rmdir":                                        "syscall",
+	"syscall.RouteMessage":                                 "syscall",
+	"syscall.RouteRIB":                                     "syscall",
+	"syscall.RtAttr":                                       "syscall",
+	"syscall.RtGenmsg":                                     "syscall",
+	"syscall.RtMetrics":                                    "syscall",
+	"syscall.RtMsg":                                        "syscall",
+	"syscall.RtMsghdr":                                     "syscall",
+	"syscall.RtNexthop":                                    "syscall",
+	"syscall.Rusage":                                       "syscall",
+	"syscall.SCM_BINTIME":                                  "syscall",
+	"syscall.SCM_CREDENTIALS":                              "syscall",
+	"syscall.SCM_CREDS":                                    "syscall",
+	"syscall.SCM_RIGHTS":                                   "syscall",
+	"syscall.SCM_TIMESTAMP":                                "syscall",
+	"syscall.SCM_TIMESTAMPING":                             "syscall",
+	"syscall.SCM_TIMESTAMPNS":                              "syscall",
+	"syscall.SCM_TIMESTAMP_MONOTONIC":                      "syscall",
+	"syscall.SHUT_RD":                                      "syscall",
+	"syscall.SHUT_RDWR":                                    "syscall",
+	"syscall.SHUT_WR":                                      "syscall",
+	"syscall.SID":                                          "syscall",
+	"syscall.SIDAndAttributes":                             "syscall",
+	"syscall.SIGABRT":                                      "syscall",
+	"syscall.SIGALRM":                                      "syscall",
+	"syscall.SIGBUS":                                       "syscall",
+	"syscall.SIGCHLD":                                      "syscall",
+	"syscall.SIGCLD":                                       "syscall",
+	"syscall.SIGCONT":                                      "syscall",
+	"syscall.SIGEMT":                                       "syscall",
+	"syscall.SIGFPE":                                       "syscall",
+	"syscall.SIGHUP":                                       "syscall",
+	"syscall.SIGILL":                                       "syscall",
+	"syscall.SIGINFO":                                      "syscall",
+	"syscall.SIGINT":                                       "syscall",
+	"syscall.SIGIO":                                        "syscall",
+	"syscall.SIGIOT":                                       "syscall",
+	"syscall.SIGKILL":                                      "syscall",
+	"syscall.SIGLIBRT":                                     "syscall",
+	"syscall.SIGLWP":                                       "syscall",
+	"syscall.SIGPIPE":                                      "syscall",
+	"syscall.SIGPOLL":                                      "syscall",
+	"syscall.SIGPROF":                                      "syscall",
+	"syscall.SIGPWR":                                       "syscall",
+	"syscall.SIGQUIT":                                      "syscall",
+	"syscall.SIGSEGV":                                      "syscall",
+	"syscall.SIGSTKFLT":                                    "syscall",
+	"syscall.SIGSTOP":                                      "syscall",
+	"syscall.SIGSYS":                                       "syscall",
+	"syscall.SIGTERM":                                      "syscall",
+	"syscall.SIGTHR":                                       "syscall",
+	"syscall.SIGTRAP":                                      "syscall",
+	"syscall.SIGTSTP":                                      "syscall",
+	"syscall.SIGTTIN":                                      "syscall",
+	"syscall.SIGTTOU":                                      "syscall",
+	"syscall.SIGUNUSED":                                    "syscall",
+	"syscall.SIGURG":                                       "syscall",
+	"syscall.SIGUSR1":                                      "syscall",
+	"syscall.SIGUSR2":                                      "syscall",
+	"syscall.SIGVTALRM":                                    "syscall",
+	"syscall.SIGWINCH":                                     "syscall",
+	"syscall.SIGXCPU":                                      "syscall",
+	"syscall.SIGXFSZ":                                      "syscall",
+	"syscall.SIOCADDDLCI":                                  "syscall",
+	"syscall.SIOCADDMULTI":                                 "syscall",
+	"syscall.SIOCADDRT":                                    "syscall",
+	"syscall.SIOCAIFADDR":                                  "syscall",
+	"syscall.SIOCAIFGROUP":                                 "syscall",
+	"syscall.SIOCALIFADDR":                                 "syscall",
+	"syscall.SIOCARPIPLL":                                  "syscall",
+	"syscall.SIOCATMARK":                                   "syscall",
+	"syscall.SIOCAUTOADDR":                                 "syscall",
+	"syscall.SIOCAUTONETMASK":                              "syscall",
+	"syscall.SIOCBRDGADD":                                  "syscall",
+	"syscall.SIOCBRDGADDS":                                 "syscall",
+	"syscall.SIOCBRDGARL":                                  "syscall",
+	"syscall.SIOCBRDGDADDR":                                "syscall",
+	"syscall.SIOCBRDGDEL":                                  "syscall",
+	"syscall.SIOCBRDGDELS":                                 "syscall",
+	"syscall.SIOCBRDGFLUSH":                                "syscall",
+	"syscall.SIOCBRDGFRL":                                  "syscall",
+	"syscall.SIOCBRDGGCACHE":                               "syscall",
+	"syscall.SIOCBRDGGFD":                                  "syscall",
+	"syscall.SIOCBRDGGHT":                                  "syscall",
+	"syscall.SIOCBRDGGIFFLGS":                              "syscall",
+	"syscall.SIOCBRDGGMA":                                  "syscall",
+	"syscall.SIOCBRDGGPARAM":                               "syscall",
+	"syscall.SIOCBRDGGPRI":                                 "syscall",
+	"syscall.SIOCBRDGGRL":                                  "syscall",
+	"syscall.SIOCBRDGGSIFS":                                "syscall",
+	"syscall.SIOCBRDGGTO":                                  "syscall",
+	"syscall.SIOCBRDGIFS":                                  "syscall",
+	"syscall.SIOCBRDGRTS":                                  "syscall",
+	"syscall.SIOCBRDGSADDR":                                "syscall",
+	"syscall.SIOCBRDGSCACHE":                               "syscall",
+	"syscall.SIOCBRDGSFD":                                  "syscall",
+	"syscall.SIOCBRDGSHT":                                  "syscall",
+	"syscall.SIOCBRDGSIFCOST":                              "syscall",
+	"syscall.SIOCBRDGSIFFLGS":                              "syscall",
+	"syscall.SIOCBRDGSIFPRIO":                              "syscall",
+	"syscall.SIOCBRDGSMA":                                  "syscall",
+	"syscall.SIOCBRDGSPRI":                                 "syscall",
+	"syscall.SIOCBRDGSPROTO":                               "syscall",
+	"syscall.SIOCBRDGSTO":                                  "syscall",
+	"syscall.SIOCBRDGSTXHC":                                "syscall",
+	"syscall.SIOCDARP":                                     "syscall",
+	"syscall.SIOCDELDLCI":                                  "syscall",
+	"syscall.SIOCDELMULTI":                                 "syscall",
+	"syscall.SIOCDELRT":                                    "syscall",
+	"syscall.SIOCDEVPRIVATE":                               "syscall",
+	"syscall.SIOCDIFADDR":                                  "syscall",
+	"syscall.SIOCDIFGROUP":                                 "syscall",
+	"syscall.SIOCDIFPHYADDR":                               "syscall",
+	"syscall.SIOCDLIFADDR":                                 "syscall",
+	"syscall.SIOCDRARP":                                    "syscall",
+	"syscall.SIOCGARP":                                     "syscall",
+	"syscall.SIOCGDRVSPEC":                                 "syscall",
+	"syscall.SIOCGETKALIVE":                                "syscall",
+	"syscall.SIOCGETLABEL":                                 "syscall",
+	"syscall.SIOCGETPFLOW":                                 "syscall",
+	"syscall.SIOCGETPFSYNC":                                "syscall",
+	"syscall.SIOCGETSGCNT":                                 "syscall",
+	"syscall.SIOCGETVIFCNT":                                "syscall",
+	"syscall.SIOCGETVLAN":                                  "syscall",
+	"syscall.SIOCGHIWAT":                                   "syscall",
+	"syscall.SIOCGIFADDR":                                  "syscall",
+	"syscall.SIOCGIFADDRPREF":                              "syscall",
+	"syscall.SIOCGIFALIAS":                                 "syscall",
+	"syscall.SIOCGIFALTMTU":                                "syscall",
+	"syscall.SIOCGIFASYNCMAP":                              "syscall",
+	"syscall.SIOCGIFBOND":                                  "syscall",
+	"syscall.SIOCGIFBR":                                    "syscall",
+	"syscall.SIOCGIFBRDADDR":                               "syscall",
+	"syscall.SIOCGIFCAP":                                   "syscall",
+	"syscall.SIOCGIFCONF":                                  "syscall",
+	"syscall.SIOCGIFCOUNT":                                 "syscall",
+	"syscall.SIOCGIFDATA":                                  "syscall",
+	"syscall.SIOCGIFDESCR":                                 "syscall",
+	"syscall.SIOCGIFDEVMTU":                                "syscall",
+	"syscall.SIOCGIFDLT":                                   "syscall",
+	"syscall.SIOCGIFDSTADDR":                               "syscall",
+	"syscall.SIOCGIFENCAP":                                 "syscall",
+	"syscall.SIOCGIFFIB":                                   "syscall",
+	"syscall.SIOCGIFFLAGS":                                 "syscall",
+	"syscall.SIOCGIFGATTR":                                 "syscall",
+	"syscall.SIOCGIFGENERIC":                               "syscall",
+	"syscall.SIOCGIFGMEMB":                                 "syscall",
+	"syscall.SIOCGIFGROUP":                                 "syscall",
+	"syscall.SIOCGIFHARDMTU":                               "syscall",
+	"syscall.SIOCGIFHWADDR":                                "syscall",
+	"syscall.SIOCGIFINDEX":                                 "syscall",
+	"syscall.SIOCGIFKPI":                                   "syscall",
+	"syscall.SIOCGIFMAC":                                   "syscall",
+	"syscall.SIOCGIFMAP":                                   "syscall",
+	"syscall.SIOCGIFMEDIA":                                 "syscall",
+	"syscall.SIOCGIFMEM":                                   "syscall",
+	"syscall.SIOCGIFMETRIC":                                "syscall",
+	"syscall.SIOCGIFMTU":                                   "syscall",
+	"syscall.SIOCGIFNAME":                                  "syscall",
+	"syscall.SIOCGIFNETMASK":                               "syscall",
+	"syscall.SIOCGIFPDSTADDR":                              "syscall",
+	"syscall.SIOCGIFPFLAGS":                                "syscall",
+	"syscall.SIOCGIFPHYS":                                  "syscall",
+	"syscall.SIOCGIFPRIORITY":                              "syscall",
+	"syscall.SIOCGIFPSRCADDR":                              "syscall",
+	"syscall.SIOCGIFRDOMAIN":                               "syscall",
+	"syscall.SIOCGIFRTLABEL":                               "syscall",
+	"syscall.SIOCGIFSLAVE":                                 "syscall",
+	"syscall.SIOCGIFSTATUS":                                "syscall",
+	"syscall.SIOCGIFTIMESLOT":                              "syscall",
+	"syscall.SIOCGIFTXQLEN":                                "syscall",
+	"syscall.SIOCGIFVLAN":                                  "syscall",
+	"syscall.SIOCGIFWAKEFLAGS":                             "syscall",
+	"syscall.SIOCGIFXFLAGS":                                "syscall",
+	"syscall.SIOCGLIFADDR":                                 "syscall",
+	"syscall.SIOCGLIFPHYADDR":                              "syscall",
+	"syscall.SIOCGLIFPHYRTABLE":                            "syscall",
+	"syscall.SIOCGLIFPHYTTL":                               "syscall",
+	"syscall.SIOCGLINKSTR":                                 "syscall",
+	"syscall.SIOCGLOWAT":                                   "syscall",
+	"syscall.SIOCGPGRP":                                    "syscall",
+	"syscall.SIOCGPRIVATE_0":                               "syscall",
+	"syscall.SIOCGPRIVATE_1":                               "syscall",
+	"syscall.SIOCGRARP":                                    "syscall",
+	"syscall.SIOCGSPPPPARAMS":                              "syscall",
+	"syscall.SIOCGSTAMP":                                   "syscall",
+	"syscall.SIOCGSTAMPNS":                                 "syscall",
+	"syscall.SIOCGVH":                                      "syscall",
+	"syscall.SIOCGVNETID":                                  "syscall",
+	"syscall.SIOCIFCREATE":                                 "syscall",
+	"syscall.SIOCIFCREATE2":                                "syscall",
+	"syscall.SIOCIFDESTROY":                                "syscall",
+	"syscall.SIOCIFGCLONERS":                               "syscall",
+	"syscall.SIOCINITIFADDR":                               "syscall",
+	"syscall.SIOCPROTOPRIVATE":                             "syscall",
+	"syscall.SIOCRSLVMULTI":                                "syscall",
+	"syscall.SIOCRTMSG":                                    "syscall",
+	"syscall.SIOCSARP":                                     "syscall",
+	"syscall.SIOCSDRVSPEC":                                 "syscall",
+	"syscall.SIOCSETKALIVE":                                "syscall",
+	"syscall.SIOCSETLABEL":                                 "syscall",
+	"syscall.SIOCSETPFLOW":                                 "syscall",
+	"syscall.SIOCSETPFSYNC":                                "syscall",
+	"syscall.SIOCSETVLAN":                                  "syscall",
+	"syscall.SIOCSHIWAT":                                   "syscall",
+	"syscall.SIOCSIFADDR":                                  "syscall",
+	"syscall.SIOCSIFADDRPREF":                              "syscall",
+	"syscall.SIOCSIFALTMTU":                                "syscall",
+	"syscall.SIOCSIFASYNCMAP":                              "syscall",
+	"syscall.SIOCSIFBOND":                                  "syscall",
+	"syscall.SIOCSIFBR":                                    "syscall",
+	"syscall.SIOCSIFBRDADDR":                               "syscall",
+	"syscall.SIOCSIFCAP":                                   "syscall",
+	"syscall.SIOCSIFDESCR":                                 "syscall",
+	"syscall.SIOCSIFDSTADDR":                               "syscall",
+	"syscall.SIOCSIFENCAP":                                 "syscall",
+	"syscall.SIOCSIFFIB":                                   "syscall",
+	"syscall.SIOCSIFFLAGS":                                 "syscall",
+	"syscall.SIOCSIFGATTR":                                 "syscall",
+	"syscall.SIOCSIFGENERIC":                               "syscall",
+	"syscall.SIOCSIFHWADDR":                                "syscall",
+	"syscall.SIOCSIFHWBROADCAST":                           "syscall",
+	"syscall.SIOCSIFKPI":                                   "syscall",
+	"syscall.SIOCSIFLINK":                                  "syscall",
+	"syscall.SIOCSIFLLADDR":                                "syscall",
+	"syscall.SIOCSIFMAC":                                   "syscall",
+	"syscall.SIOCSIFMAP":                                   "syscall",
+	"syscall.SIOCSIFMEDIA":                                 "syscall",
+	"syscall.SIOCSIFMEM":                                   "syscall",
+	"syscall.SIOCSIFMETRIC":                                "syscall",
+	"syscall.SIOCSIFMTU":                                   "syscall",
+	"syscall.SIOCSIFNAME":                                  "syscall",
+	"syscall.SIOCSIFNETMASK":                               "syscall",
+	"syscall.SIOCSIFPFLAGS":                                "syscall",
+	"syscall.SIOCSIFPHYADDR":                               "syscall",
+	"syscall.SIOCSIFPHYS":                                  "syscall",
+	"syscall.SIOCSIFPRIORITY":                              "syscall",
+	"syscall.SIOCSIFRDOMAIN":                               "syscall",
+	"syscall.SIOCSIFRTLABEL":                               "syscall",
+	"syscall.SIOCSIFRVNET":                                 "syscall",
+	"syscall.SIOCSIFSLAVE":                                 "syscall",
+	"syscall.SIOCSIFTIMESLOT":                              "syscall",
+	"syscall.SIOCSIFTXQLEN":                                "syscall",
+	"syscall.SIOCSIFVLAN":                                  "syscall",
+	"syscall.SIOCSIFVNET":                                  "syscall",
+	"syscall.SIOCSIFXFLAGS":                                "syscall",
+	"syscall.SIOCSLIFPHYADDR":                              "syscall",
+	"syscall.SIOCSLIFPHYRTABLE":                            "syscall",
+	"syscall.SIOCSLIFPHYTTL":                               "syscall",
+	"syscall.SIOCSLINKSTR":                                 "syscall",
+	"syscall.SIOCSLOWAT":                                   "syscall",
+	"syscall.SIOCSPGRP":                                    "syscall",
+	"syscall.SIOCSRARP":                                    "syscall",
+	"syscall.SIOCSSPPPPARAMS":                              "syscall",
+	"syscall.SIOCSVH":                                      "syscall",
+	"syscall.SIOCSVNETID":                                  "syscall",
+	"syscall.SIOCZIFDATA":                                  "syscall",
+	"syscall.SIO_GET_EXTENSION_FUNCTION_POINTER":           "syscall",
+	"syscall.SIO_GET_INTERFACE_LIST":                       "syscall",
+	"syscall.SIO_KEEPALIVE_VALS":                           "syscall",
+	"syscall.SIO_UDP_CONNRESET":                            "syscall",
+	"syscall.SOCK_CLOEXEC":                                 "syscall",
+	"syscall.SOCK_DCCP":                                    "syscall",
+	"syscall.SOCK_DGRAM":                                   "syscall",
+	"syscall.SOCK_FLAGS_MASK":                              "syscall",
+	"syscall.SOCK_MAXADDRLEN":                              "syscall",
+	"syscall.SOCK_NONBLOCK":                                "syscall",
+	"syscall.SOCK_NOSIGPIPE":                               "syscall",
+	"syscall.SOCK_PACKET":                                  "syscall",
+	"syscall.SOCK_RAW":                                     "syscall",
+	"syscall.SOCK_RDM":                                     "syscall",
+	"syscall.SOCK_SEQPACKET":                               "syscall",
+	"syscall.SOCK_STREAM":                                  "syscall",
+	"syscall.SOL_AAL":                                      "syscall",
+	"syscall.SOL_ATM":                                      "syscall",
+	"syscall.SOL_DECNET":                                   "syscall",
+	"syscall.SOL_ICMPV6":                                   "syscall",
+	"syscall.SOL_IP":                                       "syscall",
+	"syscall.SOL_IPV6":                                     "syscall",
+	"syscall.SOL_IRDA":                                     "syscall",
+	"syscall.SOL_PACKET":                                   "syscall",
+	"syscall.SOL_RAW":                                      "syscall",
+	"syscall.SOL_SOCKET":                                   "syscall",
+	"syscall.SOL_TCP":                                      "syscall",
+	"syscall.SOL_X25":                                      "syscall",
+	"syscall.SOMAXCONN":                                    "syscall",
+	"syscall.SO_ACCEPTCONN":                                "syscall",
+	"syscall.SO_ACCEPTFILTER":                              "syscall",
+	"syscall.SO_ATTACH_FILTER":                             "syscall",
+	"syscall.SO_BINDANY":                                   "syscall",
+	"syscall.SO_BINDTODEVICE":                              "syscall",
+	"syscall.SO_BINTIME":                                   "syscall",
+	"syscall.SO_BROADCAST":                                 "syscall",
+	"syscall.SO_BSDCOMPAT":                                 "syscall",
+	"syscall.SO_DEBUG":                                     "syscall",
+	"syscall.SO_DETACH_FILTER":                             "syscall",
+	"syscall.SO_DOMAIN":                                    "syscall",
+	"syscall.SO_DONTROUTE":                                 "syscall",
+	"syscall.SO_DONTTRUNC":                                 "syscall",
+	"syscall.SO_ERROR":                                     "syscall",
+	"syscall.SO_KEEPALIVE":                                 "syscall",
+	"syscall.SO_LABEL":                                     "syscall",
+	"syscall.SO_LINGER":                                    "syscall",
+	"syscall.SO_LINGER_SEC":                                "syscall",
+	"syscall.SO_LISTENINCQLEN":                             "syscall",
+	"syscall.SO_LISTENQLEN":                                "syscall",
+	"syscall.SO_LISTENQLIMIT":                              "syscall",
+	"syscall.SO_MARK":                                      "syscall",
+	"syscall.SO_NETPROC":                                   "syscall",
+	"syscall.SO_NKE":                                       "syscall",
+	"syscall.SO_NOADDRERR":                                 "syscall",
+	"syscall.SO_NOHEADER":                                  "syscall",
+	"syscall.SO_NOSIGPIPE":                                 "syscall",
+	"syscall.SO_NOTIFYCONFLICT":                            "syscall",
+	"syscall.SO_NO_CHECK":                                  "syscall",
+	"syscall.SO_NO_DDP":                                    "syscall",
+	"syscall.SO_NO_OFFLOAD":                                "syscall",
+	"syscall.SO_NP_EXTENSIONS":                             "syscall",
+	"syscall.SO_NREAD":                                     "syscall",
+	"syscall.SO_NWRITE":                                    "syscall",
+	"syscall.SO_OOBINLINE":                                 "syscall",
+	"syscall.SO_OVERFLOWED":                                "syscall",
+	"syscall.SO_PASSCRED":                                  "syscall",
+	"syscall.SO_PASSSEC":                                   "syscall",
+	"syscall.SO_PEERCRED":                                  "syscall",
+	"syscall.SO_PEERLABEL":                                 "syscall",
+	"syscall.SO_PEERNAME":                                  "syscall",
+	"syscall.SO_PEERSEC":                                   "syscall",
+	"syscall.SO_PRIORITY":                                  "syscall",
+	"syscall.SO_PROTOCOL":                                  "syscall",
+	"syscall.SO_PROTOTYPE":                                 "syscall",
+	"syscall.SO_RANDOMPORT":                                "syscall",
+	"syscall.SO_RCVBUF":                                    "syscall",
+	"syscall.SO_RCVBUFFORCE":                               "syscall",
+	"syscall.SO_RCVLOWAT":                                  "syscall",
+	"syscall.SO_RCVTIMEO":                                  "syscall",
+	"syscall.SO_RESTRICTIONS":                              "syscall",
+	"syscall.SO_RESTRICT_DENYIN":                           "syscall",
+	"syscall.SO_RESTRICT_DENYOUT":                          "syscall",
+	"syscall.SO_RESTRICT_DENYSET":                          "syscall",
+	"syscall.SO_REUSEADDR":                                 "syscall",
+	"syscall.SO_REUSEPORT":                                 "syscall",
+	"syscall.SO_REUSESHAREUID":                             "syscall",
+	"syscall.SO_RTABLE":                                    "syscall",
+	"syscall.SO_RXQ_OVFL":                                  "syscall",
+	"syscall.SO_SECURITY_AUTHENTICATION":                   "syscall",
+	"syscall.SO_SECURITY_ENCRYPTION_NETWORK":               "syscall",
+	"syscall.SO_SECURITY_ENCRYPTION_TRANSPORT":             "syscall",
+	"syscall.SO_SETFIB":                                    "syscall",
+	"syscall.SO_SNDBUF":                                    "syscall",
+	"syscall.SO_SNDBUFFORCE":                               "syscall",
+	"syscall.SO_SNDLOWAT":                                  "syscall",
+	"syscall.SO_SNDTIMEO":                                  "syscall",
+	"syscall.SO_SPLICE":                                    "syscall",
+	"syscall.SO_TIMESTAMP":                                 "syscall",
+	"syscall.SO_TIMESTAMPING":                              "syscall",
+	"syscall.SO_TIMESTAMPNS":                               "syscall",
+	"syscall.SO_TIMESTAMP_MONOTONIC":                       "syscall",
+	"syscall.SO_TYPE":                                      "syscall",
+	"syscall.SO_UPCALLCLOSEWAIT":                           "syscall",
+	"syscall.SO_UPDATE_ACCEPT_CONTEXT":                     "syscall",
+	"syscall.SO_UPDATE_CONNECT_CONTEXT":                    "syscall",
+	"syscall.SO_USELOOPBACK":                               "syscall",
+	"syscall.SO_USER_COOKIE":                               "syscall",
+	"syscall.SO_VENDOR":                                    "syscall",
+	"syscall.SO_WANTMORE":                                  "syscall",
+	"syscall.SO_WANTOOBFLAG":                               "syscall",
+	"syscall.SSLExtraCertChainPolicyPara":                  "syscall",
+	"syscall.STANDARD_RIGHTS_ALL":                          "syscall",
+	"syscall.STANDARD_RIGHTS_EXECUTE":                      "syscall",
+	"syscall.STANDARD_RIGHTS_READ":                         "syscall",
+	"syscall.STANDARD_RIGHTS_REQUIRED":                     "syscall",
+	"syscall.STANDARD_RIGHTS_WRITE":                        "syscall",
+	"syscall.STARTF_USESHOWWINDOW":                         "syscall",
+	"syscall.STARTF_USESTDHANDLES":                         "syscall",
+	"syscall.STD_ERROR_HANDLE":                             "syscall",
+	"syscall.STD_INPUT_HANDLE":                             "syscall",
+	"syscall.STD_OUTPUT_HANDLE":                            "syscall",
+	"syscall.SUBLANG_ENGLISH_US":                           "syscall",
+	"syscall.SW_FORCEMINIMIZE":                             "syscall",
+	"syscall.SW_HIDE":                                      "syscall",
+	"syscall.SW_MAXIMIZE":                                  "syscall",
+	"syscall.SW_MINIMIZE":                                  "syscall",
+	"syscall.SW_NORMAL":                                    "syscall",
+	"syscall.SW_RESTORE":                                   "syscall",
+	"syscall.SW_SHOW":                                      "syscall",
+	"syscall.SW_SHOWDEFAULT":                               "syscall",
+	"syscall.SW_SHOWMAXIMIZED":                             "syscall",
+	"syscall.SW_SHOWMINIMIZED":                             "syscall",
+	"syscall.SW_SHOWMINNOACTIVE":                           "syscall",
+	"syscall.SW_SHOWNA":                                    "syscall",
+	"syscall.SW_SHOWNOACTIVATE":                            "syscall",
+	"syscall.SW_SHOWNORMAL":                                "syscall",
+	"syscall.SYMBOLIC_LINK_FLAG_DIRECTORY":                 "syscall",
+	"syscall.SYNCHRONIZE":                                  "syscall",
+	"syscall.SYSCTL_VERSION":                               "syscall",
+	"syscall.SYSCTL_VERS_0":                                "syscall",
+	"syscall.SYSCTL_VERS_1":                                "syscall",
+	"syscall.SYSCTL_VERS_MASK":                             "syscall",
+	"syscall.SYS_ABORT2":                                   "syscall",
+	"syscall.SYS_ACCEPT":                                   "syscall",
+	"syscall.SYS_ACCEPT4":                                  "syscall",
+	"syscall.SYS_ACCEPT_NOCANCEL":                          "syscall",
+	"syscall.SYS_ACCESS":                                   "syscall",
+	"syscall.SYS_ACCESS_EXTENDED":                          "syscall",
+	"syscall.SYS_ACCT":                                     "syscall",
+	"syscall.SYS_ADD_KEY":                                  "syscall",
+	"syscall.SYS_ADD_PROFIL":                               "syscall",
+	"syscall.SYS_ADJFREQ":                                  "syscall",
+	"syscall.SYS_ADJTIME":                                  "syscall",
+	"syscall.SYS_ADJTIMEX":                                 "syscall",
+	"syscall.SYS_AFS_SYSCALL":                              "syscall",
+	"syscall.SYS_AIO_CANCEL":                               "syscall",
+	"syscall.SYS_AIO_ERROR":                                "syscall",
+	"syscall.SYS_AIO_FSYNC":                                "syscall",
+	"syscall.SYS_AIO_READ":                                 "syscall",
+	"syscall.SYS_AIO_RETURN":                               "syscall",
+	"syscall.SYS_AIO_SUSPEND":                              "syscall",
+	"syscall.SYS_AIO_SUSPEND_NOCANCEL":                     "syscall",
+	"syscall.SYS_AIO_WRITE":                                "syscall",
+	"syscall.SYS_ALARM":                                    "syscall",
+	"syscall.SYS_ARCH_PRCTL":                               "syscall",
+	"syscall.SYS_ARM_FADVISE64_64":                         "syscall",
+	"syscall.SYS_ARM_SYNC_FILE_RANGE":                      "syscall",
+	"syscall.SYS_ATGETMSG":                                 "syscall",
+	"syscall.SYS_ATPGETREQ":                                "syscall",
+	"syscall.SYS_ATPGETRSP":                                "syscall",
+	"syscall.SYS_ATPSNDREQ":                                "syscall",
+	"syscall.SYS_ATPSNDRSP":                                "syscall",
+	"syscall.SYS_ATPUTMSG":                                 "syscall",
+	"syscall.SYS_ATSOCKET":                                 "syscall",
+	"syscall.SYS_AUDIT":                                    "syscall",
+	"syscall.SYS_AUDITCTL":                                 "syscall",
+	"syscall.SYS_AUDITON":                                  "syscall",
+	"syscall.SYS_AUDIT_SESSION_JOIN":                       "syscall",
+	"syscall.SYS_AUDIT_SESSION_PORT":                       "syscall",
+	"syscall.SYS_AUDIT_SESSION_SELF":                       "syscall",
+	"syscall.SYS_BDFLUSH":                                  "syscall",
+	"syscall.SYS_BIND":                                     "syscall",
+	"syscall.SYS_BINDAT":                                   "syscall",
+	"syscall.SYS_BREAK":                                    "syscall",
+	"syscall.SYS_BRK":                                      "syscall",
+	"syscall.SYS_BSDTHREAD_CREATE":                         "syscall",
+	"syscall.SYS_BSDTHREAD_REGISTER":                       "syscall",
+	"syscall.SYS_BSDTHREAD_TERMINATE":                      "syscall",
+	"syscall.SYS_CAPGET":                                   "syscall",
+	"syscall.SYS_CAPSET":                                   "syscall",
+	"syscall.SYS_CAP_ENTER":                                "syscall",
+	"syscall.SYS_CAP_FCNTLS_GET":                           "syscall",
+	"syscall.SYS_CAP_FCNTLS_LIMIT":                         "syscall",
+	"syscall.SYS_CAP_GETMODE":                              "syscall",
+	"syscall.SYS_CAP_GETRIGHTS":                            "syscall",
+	"syscall.SYS_CAP_IOCTLS_GET":                           "syscall",
+	"syscall.SYS_CAP_IOCTLS_LIMIT":                         "syscall",
+	"syscall.SYS_CAP_NEW":                                  "syscall",
+	"syscall.SYS_CAP_RIGHTS_GET":                           "syscall",
+	"syscall.SYS_CAP_RIGHTS_LIMIT":                         "syscall",
+	"syscall.SYS_CHDIR":                                    "syscall",
+	"syscall.SYS_CHFLAGS":                                  "syscall",
+	"syscall.SYS_CHFLAGSAT":                                "syscall",
+	"syscall.SYS_CHMOD":                                    "syscall",
+	"syscall.SYS_CHMOD_EXTENDED":                           "syscall",
+	"syscall.SYS_CHOWN":                                    "syscall",
+	"syscall.SYS_CHOWN32":                                  "syscall",
+	"syscall.SYS_CHROOT":                                   "syscall",
+	"syscall.SYS_CHUD":                                     "syscall",
+	"syscall.SYS_CLOCK_ADJTIME":                            "syscall",
+	"syscall.SYS_CLOCK_GETCPUCLOCKID2":                     "syscall",
+	"syscall.SYS_CLOCK_GETRES":                             "syscall",
+	"syscall.SYS_CLOCK_GETTIME":                            "syscall",
+	"syscall.SYS_CLOCK_NANOSLEEP":                          "syscall",
+	"syscall.SYS_CLOCK_SETTIME":                            "syscall",
+	"syscall.SYS_CLONE":                                    "syscall",
+	"syscall.SYS_CLOSE":                                    "syscall",
+	"syscall.SYS_CLOSEFROM":                                "syscall",
+	"syscall.SYS_CLOSE_NOCANCEL":                           "syscall",
+	"syscall.SYS_CONNECT":                                  "syscall",
+	"syscall.SYS_CONNECTAT":                                "syscall",
+	"syscall.SYS_CONNECT_NOCANCEL":                         "syscall",
+	"syscall.SYS_COPYFILE":                                 "syscall",
+	"syscall.SYS_CPUSET":                                   "syscall",
+	"syscall.SYS_CPUSET_GETAFFINITY":                       "syscall",
+	"syscall.SYS_CPUSET_GETID":                             "syscall",
+	"syscall.SYS_CPUSET_SETAFFINITY":                       "syscall",
+	"syscall.SYS_CPUSET_SETID":                             "syscall",
+	"syscall.SYS_CREAT":                                    "syscall",
+	"syscall.SYS_CREATE_MODULE":                            "syscall",
+	"syscall.SYS_CSOPS":                                    "syscall",
+	"syscall.SYS_DELETE":                                   "syscall",
+	"syscall.SYS_DELETE_MODULE":                            "syscall",
+	"syscall.SYS_DUP":                                      "syscall",
+	"syscall.SYS_DUP2":                                     "syscall",
+	"syscall.SYS_DUP3":                                     "syscall",
+	"syscall.SYS_EACCESS":                                  "syscall",
+	"syscall.SYS_EPOLL_CREATE":                             "syscall",
+	"syscall.SYS_EPOLL_CREATE1":                            "syscall",
+	"syscall.SYS_EPOLL_CTL":                                "syscall",
+	"syscall.SYS_EPOLL_CTL_OLD":                            "syscall",
+	"syscall.SYS_EPOLL_PWAIT":                              "syscall",
+	"syscall.SYS_EPOLL_WAIT":                               "syscall",
+	"syscall.SYS_EPOLL_WAIT_OLD":                           "syscall",
+	"syscall.SYS_EVENTFD":                                  "syscall",
+	"syscall.SYS_EVENTFD2":                                 "syscall",
+	"syscall.SYS_EXCHANGEDATA":                             "syscall",
+	"syscall.SYS_EXECVE":                                   "syscall",
+	"syscall.SYS_EXIT":                                     "syscall",
+	"syscall.SYS_EXIT_GROUP":                               "syscall",
+	"syscall.SYS_EXTATTRCTL":                               "syscall",
+	"syscall.SYS_EXTATTR_DELETE_FD":                        "syscall",
+	"syscall.SYS_EXTATTR_DELETE_FILE":                      "syscall",
+	"syscall.SYS_EXTATTR_DELETE_LINK":                      "syscall",
+	"syscall.SYS_EXTATTR_GET_FD":                           "syscall",
+	"syscall.SYS_EXTATTR_GET_FILE":                         "syscall",
+	"syscall.SYS_EXTATTR_GET_LINK":                         "syscall",
+	"syscall.SYS_EXTATTR_LIST_FD":                          "syscall",
+	"syscall.SYS_EXTATTR_LIST_FILE":                        "syscall",
+	"syscall.SYS_EXTATTR_LIST_LINK":                        "syscall",
+	"syscall.SYS_EXTATTR_SET_FD":                           "syscall",
+	"syscall.SYS_EXTATTR_SET_FILE":                         "syscall",
+	"syscall.SYS_EXTATTR_SET_LINK":                         "syscall",
+	"syscall.SYS_FACCESSAT":                                "syscall",
+	"syscall.SYS_FADVISE64":                                "syscall",
+	"syscall.SYS_FADVISE64_64":                             "syscall",
+	"syscall.SYS_FALLOCATE":                                "syscall",
+	"syscall.SYS_FANOTIFY_INIT":                            "syscall",
+	"syscall.SYS_FANOTIFY_MARK":                            "syscall",
+	"syscall.SYS_FCHDIR":                                   "syscall",
+	"syscall.SYS_FCHFLAGS":                                 "syscall",
+	"syscall.SYS_FCHMOD":                                   "syscall",
+	"syscall.SYS_FCHMODAT":                                 "syscall",
+	"syscall.SYS_FCHMOD_EXTENDED":                          "syscall",
+	"syscall.SYS_FCHOWN":                                   "syscall",
+	"syscall.SYS_FCHOWN32":                                 "syscall",
+	"syscall.SYS_FCHOWNAT":                                 "syscall",
+	"syscall.SYS_FCHROOT":                                  "syscall",
+	"syscall.SYS_FCNTL":                                    "syscall",
+	"syscall.SYS_FCNTL64":                                  "syscall",
+	"syscall.SYS_FCNTL_NOCANCEL":                           "syscall",
+	"syscall.SYS_FDATASYNC":                                "syscall",
+	"syscall.SYS_FEXECVE":                                  "syscall",
+	"syscall.SYS_FFCLOCK_GETCOUNTER":                       "syscall",
+	"syscall.SYS_FFCLOCK_GETESTIMATE":                      "syscall",
+	"syscall.SYS_FFCLOCK_SETESTIMATE":                      "syscall",
+	"syscall.SYS_FFSCTL":                                   "syscall",
+	"syscall.SYS_FGETATTRLIST":                             "syscall",
+	"syscall.SYS_FGETXATTR":                                "syscall",
+	"syscall.SYS_FHOPEN":                                   "syscall",
+	"syscall.SYS_FHSTAT":                                   "syscall",
+	"syscall.SYS_FHSTATFS":                                 "syscall",
+	"syscall.SYS_FILEPORT_MAKEFD":                          "syscall",
+	"syscall.SYS_FILEPORT_MAKEPORT":                        "syscall",
+	"syscall.SYS_FKTRACE":                                  "syscall",
+	"syscall.SYS_FLISTXATTR":                               "syscall",
+	"syscall.SYS_FLOCK":                                    "syscall",
+	"syscall.SYS_FORK":                                     "syscall",
+	"syscall.SYS_FPATHCONF":                                "syscall",
+	"syscall.SYS_FREEBSD6_FTRUNCATE":                       "syscall",
+	"syscall.SYS_FREEBSD6_LSEEK":                           "syscall",
+	"syscall.SYS_FREEBSD6_MMAP":                            "syscall",
+	"syscall.SYS_FREEBSD6_PREAD":                           "syscall",
+	"syscall.SYS_FREEBSD6_PWRITE":                          "syscall",
+	"syscall.SYS_FREEBSD6_TRUNCATE":                        "syscall",
+	"syscall.SYS_FREMOVEXATTR":                             "syscall",
+	"syscall.SYS_FSCTL":                                    "syscall",
+	"syscall.SYS_FSETATTRLIST":                             "syscall",
+	"syscall.SYS_FSETXATTR":                                "syscall",
+	"syscall.SYS_FSGETPATH":                                "syscall",
+	"syscall.SYS_FSTAT":                                    "syscall",
+	"syscall.SYS_FSTAT64":                                  "syscall",
+	"syscall.SYS_FSTAT64_EXTENDED":                         "syscall",
+	"syscall.SYS_FSTATAT":                                  "syscall",
+	"syscall.SYS_FSTATAT64":                                "syscall",
+	"syscall.SYS_FSTATFS":                                  "syscall",
+	"syscall.SYS_FSTATFS64":                                "syscall",
+	"syscall.SYS_FSTATV":                                   "syscall",
+	"syscall.SYS_FSTATVFS1":                                "syscall",
+	"syscall.SYS_FSTAT_EXTENDED":                           "syscall",
+	"syscall.SYS_FSYNC":                                    "syscall",
+	"syscall.SYS_FSYNC_NOCANCEL":                           "syscall",
+	"syscall.SYS_FSYNC_RANGE":                              "syscall",
+	"syscall.SYS_FTIME":                                    "syscall",
+	"syscall.SYS_FTRUNCATE":                                "syscall",
+	"syscall.SYS_FTRUNCATE64":                              "syscall",
+	"syscall.SYS_FUTEX":                                    "syscall",
+	"syscall.SYS_FUTIMENS":                                 "syscall",
+	"syscall.SYS_FUTIMES":                                  "syscall",
+	"syscall.SYS_FUTIMESAT":                                "syscall",
+	"syscall.SYS_GETATTRLIST":                              "syscall",
+	"syscall.SYS_GETAUDIT":                                 "syscall",
+	"syscall.SYS_GETAUDIT_ADDR":                            "syscall",
+	"syscall.SYS_GETAUID":                                  "syscall",
+	"syscall.SYS_GETCONTEXT":                               "syscall",
+	"syscall.SYS_GETCPU":                                   "syscall",
+	"syscall.SYS_GETCWD":                                   "syscall",
+	"syscall.SYS_GETDENTS":                                 "syscall",
+	"syscall.SYS_GETDENTS64":                               "syscall",
+	"syscall.SYS_GETDIRENTRIES":                            "syscall",
+	"syscall.SYS_GETDIRENTRIES64":                          "syscall",
+	"syscall.SYS_GETDIRENTRIESATTR":                        "syscall",
+	"syscall.SYS_GETDTABLECOUNT":                           "syscall",
+	"syscall.SYS_GETDTABLESIZE":                            "syscall",
+	"syscall.SYS_GETEGID":                                  "syscall",
+	"syscall.SYS_GETEGID32":                                "syscall",
+	"syscall.SYS_GETEUID":                                  "syscall",
+	"syscall.SYS_GETEUID32":                                "syscall",
+	"syscall.SYS_GETFH":                                    "syscall",
+	"syscall.SYS_GETFSSTAT":                                "syscall",
+	"syscall.SYS_GETFSSTAT64":                              "syscall",
+	"syscall.SYS_GETGID":                                   "syscall",
+	"syscall.SYS_GETGID32":                                 "syscall",
+	"syscall.SYS_GETGROUPS":                                "syscall",
+	"syscall.SYS_GETGROUPS32":                              "syscall",
+	"syscall.SYS_GETHOSTUUID":                              "syscall",
+	"syscall.SYS_GETITIMER":                                "syscall",
+	"syscall.SYS_GETLCID":                                  "syscall",
+	"syscall.SYS_GETLOGIN":                                 "syscall",
+	"syscall.SYS_GETLOGINCLASS":                            "syscall",
+	"syscall.SYS_GETPEERNAME":                              "syscall",
+	"syscall.SYS_GETPGID":                                  "syscall",
+	"syscall.SYS_GETPGRP":                                  "syscall",
+	"syscall.SYS_GETPID":                                   "syscall",
+	"syscall.SYS_GETPMSG":                                  "syscall",
+	"syscall.SYS_GETPPID":                                  "syscall",
+	"syscall.SYS_GETPRIORITY":                              "syscall",
+	"syscall.SYS_GETRESGID":                                "syscall",
+	"syscall.SYS_GETRESGID32":                              "syscall",
+	"syscall.SYS_GETRESUID":                                "syscall",
+	"syscall.SYS_GETRESUID32":                              "syscall",
+	"syscall.SYS_GETRLIMIT":                                "syscall",
+	"syscall.SYS_GETRTABLE":                                "syscall",
+	"syscall.SYS_GETRUSAGE":                                "syscall",
+	"syscall.SYS_GETSGROUPS":                               "syscall",
+	"syscall.SYS_GETSID":                                   "syscall",
+	"syscall.SYS_GETSOCKNAME":                              "syscall",
+	"syscall.SYS_GETSOCKOPT":                               "syscall",
+	"syscall.SYS_GETTHRID":                                 "syscall",
+	"syscall.SYS_GETTID":                                   "syscall",
+	"syscall.SYS_GETTIMEOFDAY":                             "syscall",
+	"syscall.SYS_GETUID":                                   "syscall",
+	"syscall.SYS_GETUID32":                                 "syscall",
+	"syscall.SYS_GETVFSSTAT":                               "syscall",
+	"syscall.SYS_GETWGROUPS":                               "syscall",
+	"syscall.SYS_GETXATTR":                                 "syscall",
+	"syscall.SYS_GET_KERNEL_SYMS":                          "syscall",
+	"syscall.SYS_GET_MEMPOLICY":                            "syscall",
+	"syscall.SYS_GET_ROBUST_LIST":                          "syscall",
+	"syscall.SYS_GET_THREAD_AREA":                          "syscall",
+	"syscall.SYS_GTTY":                                     "syscall",
+	"syscall.SYS_IDENTITYSVC":                              "syscall",
+	"syscall.SYS_IDLE":                                     "syscall",
+	"syscall.SYS_INITGROUPS":                               "syscall",
+	"syscall.SYS_INIT_MODULE":                              "syscall",
+	"syscall.SYS_INOTIFY_ADD_WATCH":                        "syscall",
+	"syscall.SYS_INOTIFY_INIT":                             "syscall",
+	"syscall.SYS_INOTIFY_INIT1":                            "syscall",
+	"syscall.SYS_INOTIFY_RM_WATCH":                         "syscall",
+	"syscall.SYS_IOCTL":                                    "syscall",
+	"syscall.SYS_IOPERM":                                   "syscall",
+	"syscall.SYS_IOPL":                                     "syscall",
+	"syscall.SYS_IOPOLICYSYS":                              "syscall",
+	"syscall.SYS_IOPRIO_GET":                               "syscall",
+	"syscall.SYS_IOPRIO_SET":                               "syscall",
+	"syscall.SYS_IO_CANCEL":                                "syscall",
+	"syscall.SYS_IO_DESTROY":                               "syscall",
+	"syscall.SYS_IO_GETEVENTS":                             "syscall",
+	"syscall.SYS_IO_SETUP":                                 "syscall",
+	"syscall.SYS_IO_SUBMIT":                                "syscall",
+	"syscall.SYS_IPC":                                      "syscall",
+	"syscall.SYS_ISSETUGID":                                "syscall",
+	"syscall.SYS_JAIL":                                     "syscall",
+	"syscall.SYS_JAIL_ATTACH":                              "syscall",
+	"syscall.SYS_JAIL_GET":                                 "syscall",
+	"syscall.SYS_JAIL_REMOVE":                              "syscall",
+	"syscall.SYS_JAIL_SET":                                 "syscall",
+	"syscall.SYS_KDEBUG_TRACE":                             "syscall",
+	"syscall.SYS_KENV":                                     "syscall",
+	"syscall.SYS_KEVENT":                                   "syscall",
+	"syscall.SYS_KEVENT64":                                 "syscall",
+	"syscall.SYS_KEXEC_LOAD":                               "syscall",
+	"syscall.SYS_KEYCTL":                                   "syscall",
+	"syscall.SYS_KILL":                                     "syscall",
+	"syscall.SYS_KLDFIND":                                  "syscall",
+	"syscall.SYS_KLDFIRSTMOD":                              "syscall",
+	"syscall.SYS_KLDLOAD":                                  "syscall",
+	"syscall.SYS_KLDNEXT":                                  "syscall",
+	"syscall.SYS_KLDSTAT":                                  "syscall",
+	"syscall.SYS_KLDSYM":                                   "syscall",
+	"syscall.SYS_KLDUNLOAD":                                "syscall",
+	"syscall.SYS_KLDUNLOADF":                               "syscall",
+	"syscall.SYS_KQUEUE":                                   "syscall",
+	"syscall.SYS_KQUEUE1":                                  "syscall",
+	"syscall.SYS_KTIMER_CREATE":                            "syscall",
+	"syscall.SYS_KTIMER_DELETE":                            "syscall",
+	"syscall.SYS_KTIMER_GETOVERRUN":                        "syscall",
+	"syscall.SYS_KTIMER_GETTIME":                           "syscall",
+	"syscall.SYS_KTIMER_SETTIME":                           "syscall",
+	"syscall.SYS_KTRACE":                                   "syscall",
+	"syscall.SYS_LCHFLAGS":                                 "syscall",
+	"syscall.SYS_LCHMOD":                                   "syscall",
+	"syscall.SYS_LCHOWN":                                   "syscall",
+	"syscall.SYS_LCHOWN32":                                 "syscall",
+	"syscall.SYS_LGETFH":                                   "syscall",
+	"syscall.SYS_LGETXATTR":                                "syscall",
+	"syscall.SYS_LINK":                                     "syscall",
+	"syscall.SYS_LINKAT":                                   "syscall",
+	"syscall.SYS_LIO_LISTIO":                               "syscall",
+	"syscall.SYS_LISTEN":                                   "syscall",
+	"syscall.SYS_LISTXATTR":                                "syscall",
+	"syscall.SYS_LLISTXATTR":                               "syscall",
+	"syscall.SYS_LOCK":                                     "syscall",
+	"syscall.SYS_LOOKUP_DCOOKIE":                           "syscall",
+	"syscall.SYS_LPATHCONF":                                "syscall",
+	"syscall.SYS_LREMOVEXATTR":                             "syscall",
+	"syscall.SYS_LSEEK":                                    "syscall",
+	"syscall.SYS_LSETXATTR":                                "syscall",
+	"syscall.SYS_LSTAT":                                    "syscall",
+	"syscall.SYS_LSTAT64":                                  "syscall",
+	"syscall.SYS_LSTAT64_EXTENDED":                         "syscall",
+	"syscall.SYS_LSTATV":                                   "syscall",
+	"syscall.SYS_LSTAT_EXTENDED":                           "syscall",
+	"syscall.SYS_LUTIMES":                                  "syscall",
+	"syscall.SYS_MAC_SYSCALL":                              "syscall",
+	"syscall.SYS_MADVISE":                                  "syscall",
+	"syscall.SYS_MADVISE1":                                 "syscall",
+	"syscall.SYS_MAXSYSCALL":                               "syscall",
+	"syscall.SYS_MBIND":                                    "syscall",
+	"syscall.SYS_MIGRATE_PAGES":                            "syscall",
+	"syscall.SYS_MINCORE":                                  "syscall",
+	"syscall.SYS_MINHERIT":                                 "syscall",
+	"syscall.SYS_MKCOMPLEX":                                "syscall",
+	"syscall.SYS_MKDIR":                                    "syscall",
+	"syscall.SYS_MKDIRAT":                                  "syscall",
+	"syscall.SYS_MKDIR_EXTENDED":                           "syscall",
+	"syscall.SYS_MKFIFO":                                   "syscall",
+	"syscall.SYS_MKFIFOAT":                                 "syscall",
+	"syscall.SYS_MKFIFO_EXTENDED":                          "syscall",
+	"syscall.SYS_MKNOD":                                    "syscall",
+	"syscall.SYS_MKNODAT":                                  "syscall",
+	"syscall.SYS_MLOCK":                                    "syscall",
+	"syscall.SYS_MLOCKALL":                                 "syscall",
+	"syscall.SYS_MMAP":                                     "syscall",
+	"syscall.SYS_MMAP2":                                    "syscall",
+	"syscall.SYS_MODCTL":                                   "syscall",
+	"syscall.SYS_MODFIND":                                  "syscall",
+	"syscall.SYS_MODFNEXT":                                 "syscall",
+	"syscall.SYS_MODIFY_LDT":                               "syscall",
+	"syscall.SYS_MODNEXT":                                  "syscall",
+	"syscall.SYS_MODSTAT":                                  "syscall",
+	"syscall.SYS_MODWATCH":                                 "syscall",
+	"syscall.SYS_MOUNT":                                    "syscall",
+	"syscall.SYS_MOVE_PAGES":                               "syscall",
+	"syscall.SYS_MPROTECT":                                 "syscall",
+	"syscall.SYS_MPX":                                      "syscall",
+	"syscall.SYS_MQUERY":                                   "syscall",
+	"syscall.SYS_MQ_GETSETATTR":                            "syscall",
+	"syscall.SYS_MQ_NOTIFY":                                "syscall",
+	"syscall.SYS_MQ_OPEN":                                  "syscall",
+	"syscall.SYS_MQ_TIMEDRECEIVE":                          "syscall",
+	"syscall.SYS_MQ_TIMEDSEND":                             "syscall",
+	"syscall.SYS_MQ_UNLINK":                                "syscall",
+	"syscall.SYS_MREMAP":                                   "syscall",
+	"syscall.SYS_MSGCTL":                                   "syscall",
+	"syscall.SYS_MSGGET":                                   "syscall",
+	"syscall.SYS_MSGRCV":                                   "syscall",
+	"syscall.SYS_MSGRCV_NOCANCEL":                          "syscall",
+	"syscall.SYS_MSGSND":                                   "syscall",
+	"syscall.SYS_MSGSND_NOCANCEL":                          "syscall",
+	"syscall.SYS_MSGSYS":                                   "syscall",
+	"syscall.SYS_MSYNC":                                    "syscall",
+	"syscall.SYS_MSYNC_NOCANCEL":                           "syscall",
+	"syscall.SYS_MUNLOCK":                                  "syscall",
+	"syscall.SYS_MUNLOCKALL":                               "syscall",
+	"syscall.SYS_MUNMAP":                                   "syscall",
+	"syscall.SYS_NAME_TO_HANDLE_AT":                        "syscall",
+	"syscall.SYS_NANOSLEEP":                                "syscall",
+	"syscall.SYS_NEWFSTATAT":                               "syscall",
+	"syscall.SYS_NFSCLNT":                                  "syscall",
+	"syscall.SYS_NFSSERVCTL":                               "syscall",
+	"syscall.SYS_NFSSVC":                                   "syscall",
+	"syscall.SYS_NFSTAT":                                   "syscall",
+	"syscall.SYS_NICE":                                     "syscall",
+	"syscall.SYS_NLSTAT":                                   "syscall",
+	"syscall.SYS_NMOUNT":                                   "syscall",
+	"syscall.SYS_NSTAT":                                    "syscall",
+	"syscall.SYS_NTP_ADJTIME":                              "syscall",
+	"syscall.SYS_NTP_GETTIME":                              "syscall",
+	"syscall.SYS_OABI_SYSCALL_BASE":                        "syscall",
+	"syscall.SYS_OBREAK":                                   "syscall",
+	"syscall.SYS_OLDFSTAT":                                 "syscall",
+	"syscall.SYS_OLDLSTAT":                                 "syscall",
+	"syscall.SYS_OLDOLDUNAME":                              "syscall",
+	"syscall.SYS_OLDSTAT":                                  "syscall",
+	"syscall.SYS_OLDUNAME":                                 "syscall",
+	"syscall.SYS_OPEN":                                     "syscall",
+	"syscall.SYS_OPENAT":                                   "syscall",
+	"syscall.SYS_OPENBSD_POLL":                             "syscall",
+	"syscall.SYS_OPEN_BY_HANDLE_AT":                        "syscall",
+	"syscall.SYS_OPEN_EXTENDED":                            "syscall",
+	"syscall.SYS_OPEN_NOCANCEL":                            "syscall",
+	"syscall.SYS_OVADVISE":                                 "syscall",
+	"syscall.SYS_PACCEPT":                                  "syscall",
+	"syscall.SYS_PATHCONF":                                 "syscall",
+	"syscall.SYS_PAUSE":                                    "syscall",
+	"syscall.SYS_PCICONFIG_IOBASE":                         "syscall",
+	"syscall.SYS_PCICONFIG_READ":                           "syscall",
+	"syscall.SYS_PCICONFIG_WRITE":                          "syscall",
+	"syscall.SYS_PDFORK":                                   "syscall",
+	"syscall.SYS_PDGETPID":                                 "syscall",
+	"syscall.SYS_PDKILL":                                   "syscall",
+	"syscall.SYS_PERF_EVENT_OPEN":                          "syscall",
+	"syscall.SYS_PERSONALITY":                              "syscall",
+	"syscall.SYS_PID_HIBERNATE":                            "syscall",
+	"syscall.SYS_PID_RESUME":                               "syscall",
+	"syscall.SYS_PID_SHUTDOWN_SOCKETS":                     "syscall",
+	"syscall.SYS_PID_SUSPEND":                              "syscall",
+	"syscall.SYS_PIPE":                                     "syscall",
+	"syscall.SYS_PIPE2":                                    "syscall",
+	"syscall.SYS_PIVOT_ROOT":                               "syscall",
+	"syscall.SYS_PMC_CONTROL":                              "syscall",
+	"syscall.SYS_PMC_GET_INFO":                             "syscall",
+	"syscall.SYS_POLL":                                     "syscall",
+	"syscall.SYS_POLLTS":                                   "syscall",
+	"syscall.SYS_POLL_NOCANCEL":                            "syscall",
+	"syscall.SYS_POSIX_FADVISE":                            "syscall",
+	"syscall.SYS_POSIX_FALLOCATE":                          "syscall",
+	"syscall.SYS_POSIX_OPENPT":                             "syscall",
+	"syscall.SYS_POSIX_SPAWN":                              "syscall",
+	"syscall.SYS_PPOLL":                                    "syscall",
+	"syscall.SYS_PRCTL":                                    "syscall",
+	"syscall.SYS_PREAD":                                    "syscall",
+	"syscall.SYS_PREAD64":                                  "syscall",
+	"syscall.SYS_PREADV":                                   "syscall",
+	"syscall.SYS_PREAD_NOCANCEL":                           "syscall",
+	"syscall.SYS_PRLIMIT64":                                "syscall",
+	"syscall.SYS_PROCCTL":                                  "syscall",
+	"syscall.SYS_PROCESS_POLICY":                           "syscall",
+	"syscall.SYS_PROCESS_VM_READV":                         "syscall",
+	"syscall.SYS_PROCESS_VM_WRITEV":                        "syscall",
+	"syscall.SYS_PROC_INFO":                                "syscall",
+	"syscall.SYS_PROF":                                     "syscall",
+	"syscall.SYS_PROFIL":                                   "syscall",
+	"syscall.SYS_PSELECT":                                  "syscall",
+	"syscall.SYS_PSELECT6":                                 "syscall",
+	"syscall.SYS_PSET_ASSIGN":                              "syscall",
+	"syscall.SYS_PSET_CREATE":                              "syscall",
+	"syscall.SYS_PSET_DESTROY":                             "syscall",
+	"syscall.SYS_PSYNCH_CVBROAD":                           "syscall",
+	"syscall.SYS_PSYNCH_CVCLRPREPOST":                      "syscall",
+	"syscall.SYS_PSYNCH_CVSIGNAL":                          "syscall",
+	"syscall.SYS_PSYNCH_CVWAIT":                            "syscall",
+	"syscall.SYS_PSYNCH_MUTEXDROP":                         "syscall",
+	"syscall.SYS_PSYNCH_MUTEXWAIT":                         "syscall",
+	"syscall.SYS_PSYNCH_RW_DOWNGRADE":                      "syscall",
+	"syscall.SYS_PSYNCH_RW_LONGRDLOCK":                     "syscall",
+	"syscall.SYS_PSYNCH_RW_RDLOCK":                         "syscall",
+	"syscall.SYS_PSYNCH_RW_UNLOCK":                         "syscall",
+	"syscall.SYS_PSYNCH_RW_UNLOCK2":                        "syscall",
+	"syscall.SYS_PSYNCH_RW_UPGRADE":                        "syscall",
+	"syscall.SYS_PSYNCH_RW_WRLOCK":                         "syscall",
+	"syscall.SYS_PSYNCH_RW_YIELDWRLOCK":                    "syscall",
+	"syscall.SYS_PTRACE":                                   "syscall",
+	"syscall.SYS_PUTPMSG":                                  "syscall",
+	"syscall.SYS_PWRITE":                                   "syscall",
+	"syscall.SYS_PWRITE64":                                 "syscall",
+	"syscall.SYS_PWRITEV":                                  "syscall",
+	"syscall.SYS_PWRITE_NOCANCEL":                          "syscall",
+	"syscall.SYS_QUERY_MODULE":                             "syscall",
+	"syscall.SYS_QUOTACTL":                                 "syscall",
+	"syscall.SYS_RASCTL":                                   "syscall",
+	"syscall.SYS_RCTL_ADD_RULE":                            "syscall",
+	"syscall.SYS_RCTL_GET_LIMITS":                          "syscall",
+	"syscall.SYS_RCTL_GET_RACCT":                           "syscall",
+	"syscall.SYS_RCTL_GET_RULES":                           "syscall",
+	"syscall.SYS_RCTL_REMOVE_RULE":                         "syscall",
+	"syscall.SYS_READ":                                     "syscall",
+	"syscall.SYS_READAHEAD":                                "syscall",
+	"syscall.SYS_READDIR":                                  "syscall",
+	"syscall.SYS_READLINK":                                 "syscall",
+	"syscall.SYS_READLINKAT":                               "syscall",
+	"syscall.SYS_READV":                                    "syscall",
+	"syscall.SYS_READV_NOCANCEL":                           "syscall",
+	"syscall.SYS_READ_NOCANCEL":                            "syscall",
+	"syscall.SYS_REBOOT":                                   "syscall",
+	"syscall.SYS_RECV":                                     "syscall",
+	"syscall.SYS_RECVFROM":                                 "syscall",
+	"syscall.SYS_RECVFROM_NOCANCEL":                        "syscall",
+	"syscall.SYS_RECVMMSG":                                 "syscall",
+	"syscall.SYS_RECVMSG":                                  "syscall",
+	"syscall.SYS_RECVMSG_NOCANCEL":                         "syscall",
+	"syscall.SYS_REMAP_FILE_PAGES":                         "syscall",
+	"syscall.SYS_REMOVEXATTR":                              "syscall",
+	"syscall.SYS_RENAME":                                   "syscall",
+	"syscall.SYS_RENAMEAT":                                 "syscall",
+	"syscall.SYS_REQUEST_KEY":                              "syscall",
+	"syscall.SYS_RESTART_SYSCALL":                          "syscall",
+	"syscall.SYS_REVOKE":                                   "syscall",
+	"syscall.SYS_RFORK":                                    "syscall",
+	"syscall.SYS_RMDIR":                                    "syscall",
+	"syscall.SYS_RTPRIO":                                   "syscall",
+	"syscall.SYS_RTPRIO_THREAD":                            "syscall",
+	"syscall.SYS_RT_SIGACTION":                             "syscall",
+	"syscall.SYS_RT_SIGPENDING":                            "syscall",
+	"syscall.SYS_RT_SIGPROCMASK":                           "syscall",
+	"syscall.SYS_RT_SIGQUEUEINFO":                          "syscall",
+	"syscall.SYS_RT_SIGRETURN":                             "syscall",
+	"syscall.SYS_RT_SIGSUSPEND":                            "syscall",
+	"syscall.SYS_RT_SIGTIMEDWAIT":                          "syscall",
+	"syscall.SYS_RT_TGSIGQUEUEINFO":                        "syscall",
+	"syscall.SYS_SBRK":                                     "syscall",
+	"syscall.SYS_SCHED_GETAFFINITY":                        "syscall",
+	"syscall.SYS_SCHED_GETPARAM":                           "syscall",
+	"syscall.SYS_SCHED_GETSCHEDULER":                       "syscall",
+	"syscall.SYS_SCHED_GET_PRIORITY_MAX":                   "syscall",
+	"syscall.SYS_SCHED_GET_PRIORITY_MIN":                   "syscall",
+	"syscall.SYS_SCHED_RR_GET_INTERVAL":                    "syscall",
+	"syscall.SYS_SCHED_SETAFFINITY":                        "syscall",
+	"syscall.SYS_SCHED_SETPARAM":                           "syscall",
+	"syscall.SYS_SCHED_SETSCHEDULER":                       "syscall",
+	"syscall.SYS_SCHED_YIELD":                              "syscall",
+	"syscall.SYS_SCTP_GENERIC_RECVMSG":                     "syscall",
+	"syscall.SYS_SCTP_GENERIC_SENDMSG":                     "syscall",
+	"syscall.SYS_SCTP_GENERIC_SENDMSG_IOV":                 "syscall",
+	"syscall.SYS_SCTP_PEELOFF":                             "syscall",
+	"syscall.SYS_SEARCHFS":                                 "syscall",
+	"syscall.SYS_SECURITY":                                 "syscall",
+	"syscall.SYS_SELECT":                                   "syscall",
+	"syscall.SYS_SELECT_NOCANCEL":                          "syscall",
+	"syscall.SYS_SEMCONFIG":                                "syscall",
+	"syscall.SYS_SEMCTL":                                   "syscall",
+	"syscall.SYS_SEMGET":                                   "syscall",
+	"syscall.SYS_SEMOP":                                    "syscall",
+	"syscall.SYS_SEMSYS":                                   "syscall",
+	"syscall.SYS_SEMTIMEDOP":                               "syscall",
+	"syscall.SYS_SEM_CLOSE":                                "syscall",
+	"syscall.SYS_SEM_DESTROY":                              "syscall",
+	"syscall.SYS_SEM_GETVALUE":                             "syscall",
+	"syscall.SYS_SEM_INIT":                                 "syscall",
+	"syscall.SYS_SEM_OPEN":                                 "syscall",
+	"syscall.SYS_SEM_POST":                                 "syscall",
+	"syscall.SYS_SEM_TRYWAIT":                              "syscall",
+	"syscall.SYS_SEM_UNLINK":                               "syscall",
+	"syscall.SYS_SEM_WAIT":                                 "syscall",
+	"syscall.SYS_SEM_WAIT_NOCANCEL":                        "syscall",
+	"syscall.SYS_SEND":                                     "syscall",
+	"syscall.SYS_SENDFILE":                                 "syscall",
+	"syscall.SYS_SENDFILE64":                               "syscall",
+	"syscall.SYS_SENDMMSG":                                 "syscall",
+	"syscall.SYS_SENDMSG":                                  "syscall",
+	"syscall.SYS_SENDMSG_NOCANCEL":                         "syscall",
+	"syscall.SYS_SENDTO":                                   "syscall",
+	"syscall.SYS_SENDTO_NOCANCEL":                          "syscall",
+	"syscall.SYS_SETATTRLIST":                              "syscall",
+	"syscall.SYS_SETAUDIT":                                 "syscall",
+	"syscall.SYS_SETAUDIT_ADDR":                            "syscall",
+	"syscall.SYS_SETAUID":                                  "syscall",
+	"syscall.SYS_SETCONTEXT":                               "syscall",
+	"syscall.SYS_SETDOMAINNAME":                            "syscall",
+	"syscall.SYS_SETEGID":                                  "syscall",
+	"syscall.SYS_SETEUID":                                  "syscall",
+	"syscall.SYS_SETFIB":                                   "syscall",
+	"syscall.SYS_SETFSGID":                                 "syscall",
+	"syscall.SYS_SETFSGID32":                               "syscall",
+	"syscall.SYS_SETFSUID":                                 "syscall",
+	"syscall.SYS_SETFSUID32":                               "syscall",
+	"syscall.SYS_SETGID":                                   "syscall",
+	"syscall.SYS_SETGID32":                                 "syscall",
+	"syscall.SYS_SETGROUPS":                                "syscall",
+	"syscall.SYS_SETGROUPS32":                              "syscall",
+	"syscall.SYS_SETHOSTNAME":                              "syscall",
+	"syscall.SYS_SETITIMER":                                "syscall",
+	"syscall.SYS_SETLCID":                                  "syscall",
+	"syscall.SYS_SETLOGIN":                                 "syscall",
+	"syscall.SYS_SETLOGINCLASS":                            "syscall",
+	"syscall.SYS_SETNS":                                    "syscall",
+	"syscall.SYS_SETPGID":                                  "syscall",
+	"syscall.SYS_SETPRIORITY":                              "syscall",
+	"syscall.SYS_SETPRIVEXEC":                              "syscall",
+	"syscall.SYS_SETREGID":                                 "syscall",
+	"syscall.SYS_SETREGID32":                               "syscall",
+	"syscall.SYS_SETRESGID":                                "syscall",
+	"syscall.SYS_SETRESGID32":                              "syscall",
+	"syscall.SYS_SETRESUID":                                "syscall",
+	"syscall.SYS_SETRESUID32":                              "syscall",
+	"syscall.SYS_SETREUID":                                 "syscall",
+	"syscall.SYS_SETREUID32":                               "syscall",
+	"syscall.SYS_SETRLIMIT":                                "syscall",
+	"syscall.SYS_SETRTABLE":                                "syscall",
+	"syscall.SYS_SETSGROUPS":                               "syscall",
+	"syscall.SYS_SETSID":                                   "syscall",
+	"syscall.SYS_SETSOCKOPT":                               "syscall",
+	"syscall.SYS_SETTID":                                   "syscall",
+	"syscall.SYS_SETTID_WITH_PID":                          "syscall",
+	"syscall.SYS_SETTIMEOFDAY":                             "syscall",
+	"syscall.SYS_SETUID":                                   "syscall",
+	"syscall.SYS_SETUID32":                                 "syscall",
+	"syscall.SYS_SETWGROUPS":                               "syscall",
+	"syscall.SYS_SETXATTR":                                 "syscall",
+	"syscall.SYS_SET_MEMPOLICY":                            "syscall",
+	"syscall.SYS_SET_ROBUST_LIST":                          "syscall",
+	"syscall.SYS_SET_THREAD_AREA":                          "syscall",
+	"syscall.SYS_SET_TID_ADDRESS":                          "syscall",
+	"syscall.SYS_SGETMASK":                                 "syscall",
+	"syscall.SYS_SHARED_REGION_CHECK_NP":                   "syscall",
+	"syscall.SYS_SHARED_REGION_MAP_AND_SLIDE_NP":           "syscall",
+	"syscall.SYS_SHMAT":                                    "syscall",
+	"syscall.SYS_SHMCTL":                                   "syscall",
+	"syscall.SYS_SHMDT":                                    "syscall",
+	"syscall.SYS_SHMGET":                                   "syscall",
+	"syscall.SYS_SHMSYS":                                   "syscall",
+	"syscall.SYS_SHM_OPEN":                                 "syscall",
+	"syscall.SYS_SHM_UNLINK":                               "syscall",
+	"syscall.SYS_SHUTDOWN":                                 "syscall",
+	"syscall.SYS_SIGACTION":                                "syscall",
+	"syscall.SYS_SIGALTSTACK":                              "syscall",
+	"syscall.SYS_SIGNAL":                                   "syscall",
+	"syscall.SYS_SIGNALFD":                                 "syscall",
+	"syscall.SYS_SIGNALFD4":                                "syscall",
+	"syscall.SYS_SIGPENDING":                               "syscall",
+	"syscall.SYS_SIGPROCMASK":                              "syscall",
+	"syscall.SYS_SIGQUEUE":                                 "syscall",
+	"syscall.SYS_SIGQUEUEINFO":                             "syscall",
+	"syscall.SYS_SIGRETURN":                                "syscall",
+	"syscall.SYS_SIGSUSPEND":                               "syscall",
+	"syscall.SYS_SIGSUSPEND_NOCANCEL":                      "syscall",
+	"syscall.SYS_SIGTIMEDWAIT":                             "syscall",
+	"syscall.SYS_SIGWAIT":                                  "syscall",
+	"syscall.SYS_SIGWAITINFO":                              "syscall",
+	"syscall.SYS_SOCKET":                                   "syscall",
+	"syscall.SYS_SOCKETCALL":                               "syscall",
+	"syscall.SYS_SOCKETPAIR":                               "syscall",
+	"syscall.SYS_SPLICE":                                   "syscall",
+	"syscall.SYS_SSETMASK":                                 "syscall",
+	"syscall.SYS_SSTK":                                     "syscall",
+	"syscall.SYS_STACK_SNAPSHOT":                           "syscall",
+	"syscall.SYS_STAT":                                     "syscall",
+	"syscall.SYS_STAT64":                                   "syscall",
+	"syscall.SYS_STAT64_EXTENDED":                          "syscall",
+	"syscall.SYS_STATFS":                                   "syscall",
+	"syscall.SYS_STATFS64":                                 "syscall",
+	"syscall.SYS_STATV":                                    "syscall",
+	"syscall.SYS_STATVFS1":                                 "syscall",
+	"syscall.SYS_STAT_EXTENDED":                            "syscall",
+	"syscall.SYS_STIME":                                    "syscall",
+	"syscall.SYS_STTY":                                     "syscall",
+	"syscall.SYS_SWAPCONTEXT":                              "syscall",
+	"syscall.SYS_SWAPCTL":                                  "syscall",
+	"syscall.SYS_SWAPOFF":                                  "syscall",
+	"syscall.SYS_SWAPON":                                   "syscall",
+	"syscall.SYS_SYMLINK":                                  "syscall",
+	"syscall.SYS_SYMLINKAT":                                "syscall",
+	"syscall.SYS_SYNC":                                     "syscall",
+	"syscall.SYS_SYNCFS":                                   "syscall",
+	"syscall.SYS_SYNC_FILE_RANGE":                          "syscall",
+	"syscall.SYS_SYSARCH":                                  "syscall",
+	"syscall.SYS_SYSCALL":                                  "syscall",
+	"syscall.SYS_SYSCALL_BASE":                             "syscall",
+	"syscall.SYS_SYSFS":                                    "syscall",
+	"syscall.SYS_SYSINFO":                                  "syscall",
+	"syscall.SYS_SYSLOG":                                   "syscall",
+	"syscall.SYS_TEE":                                      "syscall",
+	"syscall.SYS_TGKILL":                                   "syscall",
+	"syscall.SYS_THREAD_SELFID":                            "syscall",
+	"syscall.SYS_THR_CREATE":                               "syscall",
+	"syscall.SYS_THR_EXIT":                                 "syscall",
+	"syscall.SYS_THR_KILL":                                 "syscall",
+	"syscall.SYS_THR_KILL2":                                "syscall",
+	"syscall.SYS_THR_NEW":                                  "syscall",
+	"syscall.SYS_THR_SELF":                                 "syscall",
+	"syscall.SYS_THR_SET_NAME":                             "syscall",
+	"syscall.SYS_THR_SUSPEND":                              "syscall",
+	"syscall.SYS_THR_WAKE":                                 "syscall",
+	"syscall.SYS_TIME":                                     "syscall",
+	"syscall.SYS_TIMERFD_CREATE":                           "syscall",
+	"syscall.SYS_TIMERFD_GETTIME":                          "syscall",
+	"syscall.SYS_TIMERFD_SETTIME":                          "syscall",
+	"syscall.SYS_TIMER_CREATE":                             "syscall",
+	"syscall.SYS_TIMER_DELETE":                             "syscall",
+	"syscall.SYS_TIMER_GETOVERRUN":                         "syscall",
+	"syscall.SYS_TIMER_GETTIME":                            "syscall",
+	"syscall.SYS_TIMER_SETTIME":                            "syscall",
+	"syscall.SYS_TIMES":                                    "syscall",
+	"syscall.SYS_TKILL":                                    "syscall",
+	"syscall.SYS_TRUNCATE":                                 "syscall",
+	"syscall.SYS_TRUNCATE64":                               "syscall",
+	"syscall.SYS_TUXCALL":                                  "syscall",
+	"syscall.SYS_UGETRLIMIT":                               "syscall",
+	"syscall.SYS_ULIMIT":                                   "syscall",
+	"syscall.SYS_UMASK":                                    "syscall",
+	"syscall.SYS_UMASK_EXTENDED":                           "syscall",
+	"syscall.SYS_UMOUNT":                                   "syscall",
+	"syscall.SYS_UMOUNT2":                                  "syscall",
+	"syscall.SYS_UNAME":                                    "syscall",
+	"syscall.SYS_UNDELETE":                                 "syscall",
+	"syscall.SYS_UNLINK":                                   "syscall",
+	"syscall.SYS_UNLINKAT":                                 "syscall",
+	"syscall.SYS_UNMOUNT":                                  "syscall",
+	"syscall.SYS_UNSHARE":                                  "syscall",
+	"syscall.SYS_USELIB":                                   "syscall",
+	"syscall.SYS_USTAT":                                    "syscall",
+	"syscall.SYS_UTIME":                                    "syscall",
+	"syscall.SYS_UTIMENSAT":                                "syscall",
+	"syscall.SYS_UTIMES":                                   "syscall",
+	"syscall.SYS_UTRACE":                                   "syscall",
+	"syscall.SYS_UUIDGEN":                                  "syscall",
+	"syscall.SYS_VADVISE":                                  "syscall",
+	"syscall.SYS_VFORK":                                    "syscall",
+	"syscall.SYS_VHANGUP":                                  "syscall",
+	"syscall.SYS_VM86":                                     "syscall",
+	"syscall.SYS_VM86OLD":                                  "syscall",
+	"syscall.SYS_VMSPLICE":                                 "syscall",
+	"syscall.SYS_VM_PRESSURE_MONITOR":                      "syscall",
+	"syscall.SYS_VSERVER":                                  "syscall",
+	"syscall.SYS_WAIT4":                                    "syscall",
+	"syscall.SYS_WAIT4_NOCANCEL":                           "syscall",
+	"syscall.SYS_WAIT6":                                    "syscall",
+	"syscall.SYS_WAITEVENT":                                "syscall",
+	"syscall.SYS_WAITID":                                   "syscall",
+	"syscall.SYS_WAITID_NOCANCEL":                          "syscall",
+	"syscall.SYS_WAITPID":                                  "syscall",
+	"syscall.SYS_WATCHEVENT":                               "syscall",
+	"syscall.SYS_WORKQ_KERNRETURN":                         "syscall",
+	"syscall.SYS_WORKQ_OPEN":                               "syscall",
+	"syscall.SYS_WRITE":                                    "syscall",
+	"syscall.SYS_WRITEV":                                   "syscall",
+	"syscall.SYS_WRITEV_NOCANCEL":                          "syscall",
+	"syscall.SYS_WRITE_NOCANCEL":                           "syscall",
+	"syscall.SYS_YIELD":                                    "syscall",
+	"syscall.SYS__LLSEEK":                                  "syscall",
+	"syscall.SYS__LWP_CONTINUE":                            "syscall",
+	"syscall.SYS__LWP_CREATE":                              "syscall",
+	"syscall.SYS__LWP_CTL":                                 "syscall",
+	"syscall.SYS__LWP_DETACH":                              "syscall",
+	"syscall.SYS__LWP_EXIT":                                "syscall",
+	"syscall.SYS__LWP_GETNAME":                             "syscall",
+	"syscall.SYS__LWP_GETPRIVATE":                          "syscall",
+	"syscall.SYS__LWP_KILL":                                "syscall",
+	"syscall.SYS__LWP_PARK":                                "syscall",
+	"syscall.SYS__LWP_SELF":                                "syscall",
+	"syscall.SYS__LWP_SETNAME":                             "syscall",
+	"syscall.SYS__LWP_SETPRIVATE":                          "syscall",
+	"syscall.SYS__LWP_SUSPEND":                             "syscall",
+	"syscall.SYS__LWP_UNPARK":                              "syscall",
+	"syscall.SYS__LWP_UNPARK_ALL":                          "syscall",
+	"syscall.SYS__LWP_WAIT":                                "syscall",
+	"syscall.SYS__LWP_WAKEUP":                              "syscall",
+	"syscall.SYS__NEWSELECT":                               "syscall",
+	"syscall.SYS__PSET_BIND":                               "syscall",
+	"syscall.SYS__SCHED_GETAFFINITY":                       "syscall",
+	"syscall.SYS__SCHED_GETPARAM":                          "syscall",
+	"syscall.SYS__SCHED_SETAFFINITY":                       "syscall",
+	"syscall.SYS__SCHED_SETPARAM":                          "syscall",
+	"syscall.SYS__SYSCTL":                                  "syscall",
+	"syscall.SYS__UMTX_LOCK":                               "syscall",
+	"syscall.SYS__UMTX_OP":                                 "syscall",
+	"syscall.SYS__UMTX_UNLOCK":                             "syscall",
+	"syscall.SYS___ACL_ACLCHECK_FD":                        "syscall",
+	"syscall.SYS___ACL_ACLCHECK_FILE":                      "syscall",
+	"syscall.SYS___ACL_ACLCHECK_LINK":                      "syscall",
+	"syscall.SYS___ACL_DELETE_FD":                          "syscall",
+	"syscall.SYS___ACL_DELETE_FILE":                        "syscall",
+	"syscall.SYS___ACL_DELETE_LINK":                        "syscall",
+	"syscall.SYS___ACL_GET_FD":                             "syscall",
+	"syscall.SYS___ACL_GET_FILE":                           "syscall",
+	"syscall.SYS___ACL_GET_LINK":                           "syscall",
+	"syscall.SYS___ACL_SET_FD":                             "syscall",
+	"syscall.SYS___ACL_SET_FILE":                           "syscall",
+	"syscall.SYS___ACL_SET_LINK":                           "syscall",
+	"syscall.SYS___CLONE":                                  "syscall",
+	"syscall.SYS___DISABLE_THREADSIGNAL":                   "syscall",
+	"syscall.SYS___GETCWD":                                 "syscall",
+	"syscall.SYS___GETLOGIN":                               "syscall",
+	"syscall.SYS___GET_TCB":                                "syscall",
+	"syscall.SYS___MAC_EXECVE":                             "syscall",
+	"syscall.SYS___MAC_GETFSSTAT":                          "syscall",
+	"syscall.SYS___MAC_GET_FD":                             "syscall",
+	"syscall.SYS___MAC_GET_FILE":                           "syscall",
+	"syscall.SYS___MAC_GET_LCID":                           "syscall",
+	"syscall.SYS___MAC_GET_LCTX":                           "syscall",
+	"syscall.SYS___MAC_GET_LINK":                           "syscall",
+	"syscall.SYS___MAC_GET_MOUNT":                          "syscall",
+	"syscall.SYS___MAC_GET_PID":                            "syscall",
+	"syscall.SYS___MAC_GET_PROC":                           "syscall",
+	"syscall.SYS___MAC_MOUNT":                              "syscall",
+	"syscall.SYS___MAC_SET_FD":                             "syscall",
+	"syscall.SYS___MAC_SET_FILE":                           "syscall",
+	"syscall.SYS___MAC_SET_LCTX":                           "syscall",
+	"syscall.SYS___MAC_SET_LINK":                           "syscall",
+	"syscall.SYS___MAC_SET_PROC":                           "syscall",
+	"syscall.SYS___MAC_SYSCALL":                            "syscall",
+	"syscall.SYS___OLD_SEMWAIT_SIGNAL":                     "syscall",
+	"syscall.SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL":            "syscall",
+	"syscall.SYS___POSIX_CHOWN":                            "syscall",
+	"syscall.SYS___POSIX_FCHOWN":                           "syscall",
+	"syscall.SYS___POSIX_LCHOWN":                           "syscall",
+	"syscall.SYS___POSIX_RENAME":                           "syscall",
+	"syscall.SYS___PTHREAD_CANCELED":                       "syscall",
+	"syscall.SYS___PTHREAD_CHDIR":                          "syscall",
+	"syscall.SYS___PTHREAD_FCHDIR":                         "syscall",
+	"syscall.SYS___PTHREAD_KILL":                           "syscall",
+	"syscall.SYS___PTHREAD_MARKCANCEL":                     "syscall",
+	"syscall.SYS___PTHREAD_SIGMASK":                        "syscall",
+	"syscall.SYS___QUOTACTL":                               "syscall",
+	"syscall.SYS___SEMCTL":                                 "syscall",
+	"syscall.SYS___SEMWAIT_SIGNAL":                         "syscall",
+	"syscall.SYS___SEMWAIT_SIGNAL_NOCANCEL":                "syscall",
+	"syscall.SYS___SETLOGIN":                               "syscall",
+	"syscall.SYS___SETUGID":                                "syscall",
+	"syscall.SYS___SET_TCB":                                "syscall",
+	"syscall.SYS___SIGACTION_SIGTRAMP":                     "syscall",
+	"syscall.SYS___SIGTIMEDWAIT":                           "syscall",
+	"syscall.SYS___SIGWAIT":                                "syscall",
+	"syscall.SYS___SIGWAIT_NOCANCEL":                       "syscall",
+	"syscall.SYS___SYSCTL":                                 "syscall",
+	"syscall.SYS___TFORK":                                  "syscall",
+	"syscall.SYS___THREXIT":                                "syscall",
+	"syscall.SYS___THRSIGDIVERT":                           "syscall",
+	"syscall.SYS___THRSLEEP":                               "syscall",
+	"syscall.SYS___THRWAKEUP":                              "syscall",
+	"syscall.S_ARCH1":                                      "syscall",
+	"syscall.S_ARCH2":                                      "syscall",
+	"syscall.S_BLKSIZE":                                    "syscall",
+	"syscall.S_IEXEC":                                      "syscall",
+	"syscall.S_IFBLK":                                      "syscall",
+	"syscall.S_IFCHR":                                      "syscall",
+	"syscall.S_IFDIR":                                      "syscall",
+	"syscall.S_IFIFO":                                      "syscall",
+	"syscall.S_IFLNK":                                      "syscall",
+	"syscall.S_IFMT":                                       "syscall",
+	"syscall.S_IFREG":                                      "syscall",
+	"syscall.S_IFSOCK":                                     "syscall",
+	"syscall.S_IFWHT":                                      "syscall",
+	"syscall.S_IREAD":                                      "syscall",
+	"syscall.S_IRGRP":                                      "syscall",
+	"syscall.S_IROTH":                                      "syscall",
+	"syscall.S_IRUSR":                                      "syscall",
+	"syscall.S_IRWXG":                                      "syscall",
+	"syscall.S_IRWXO":                                      "syscall",
+	"syscall.S_IRWXU":                                      "syscall",
+	"syscall.S_ISGID":                                      "syscall",
+	"syscall.S_ISTXT":                                      "syscall",
+	"syscall.S_ISUID":                                      "syscall",
+	"syscall.S_ISVTX":                                      "syscall",
+	"syscall.S_IWGRP":                                      "syscall",
+	"syscall.S_IWOTH":                                      "syscall",
+	"syscall.S_IWRITE":                                     "syscall",
+	"syscall.S_IWUSR":                                      "syscall",
+	"syscall.S_IXGRP":                                      "syscall",
+	"syscall.S_IXOTH":                                      "syscall",
+	"syscall.S_IXUSR":                                      "syscall",
+	"syscall.S_LOGIN_SET":                                  "syscall",
+	"syscall.SecurityAttributes":                           "syscall",
+	"syscall.Seek":                                         "syscall",
+	"syscall.Select":                                       "syscall",
+	"syscall.Sendfile":                                     "syscall",
+	"syscall.Sendmsg":                                      "syscall",
+	"syscall.SendmsgN":                                     "syscall",
+	"syscall.Sendto":                                       "syscall",
+	"syscall.Servent":                                      "syscall",
+	"syscall.SetBpf":                                       "syscall",
+	"syscall.SetBpfBuflen":                                 "syscall",
+	"syscall.SetBpfDatalink":                               "syscall",
+	"syscall.SetBpfHeadercmpl":                             "syscall",
+	"syscall.SetBpfImmediate":                              "syscall",
+	"syscall.SetBpfInterface":                              "syscall",
+	"syscall.SetBpfPromisc":                                "syscall",
+	"syscall.SetBpfTimeout":                                "syscall",
+	"syscall.SetCurrentDirectory":                          "syscall",
+	"syscall.SetEndOfFile":                                 "syscall",
+	"syscall.SetEnvironmentVariable":                       "syscall",
+	"syscall.SetFileAttributes":                            "syscall",
+	"syscall.SetFileCompletionNotificationModes":           "syscall",
+	"syscall.SetFilePointer":                               "syscall",
+	"syscall.SetFileTime":                                  "syscall",
+	"syscall.SetHandleInformation":                         "syscall",
+	"syscall.SetKevent":                                    "syscall",
+	"syscall.SetLsfPromisc":                                "syscall",
+	"syscall.SetNonblock":                                  "syscall",
+	"syscall.Setdomainname":                                "syscall",
+	"syscall.Setegid":                                      "syscall",
+	"syscall.Setenv":                                       "syscall",
+	"syscall.Seteuid":                                      "syscall",
+	"syscall.Setfsgid":                                     "syscall",
+	"syscall.Setfsuid":                                     "syscall",
+	"syscall.Setgid":                                       "syscall",
+	"syscall.Setgroups":                                    "syscall",
+	"syscall.Sethostname":                                  "syscall",
+	"syscall.Setlogin":                                     "syscall",
+	"syscall.Setpgid":                                      "syscall",
+	"syscall.Setpriority":                                  "syscall",
+	"syscall.Setprivexec":                                  "syscall",
+	"syscall.Setregid":                                     "syscall",
+	"syscall.Setresgid":                                    "syscall",
+	"syscall.Setresuid":                                    "syscall",
+	"syscall.Setreuid":                                     "syscall",
+	"syscall.Setrlimit":                                    "syscall",
+	"syscall.Setsid":                                       "syscall",
+	"syscall.Setsockopt":                                   "syscall",
+	"syscall.SetsockoptByte":                               "syscall",
+	"syscall.SetsockoptICMPv6Filter":                       "syscall",
+	"syscall.SetsockoptIPMreq":                             "syscall",
+	"syscall.SetsockoptIPMreqn":                            "syscall",
+	"syscall.SetsockoptIPv6Mreq":                           "syscall",
+	"syscall.SetsockoptInet4Addr":                          "syscall",
+	"syscall.SetsockoptInt":                                "syscall",
+	"syscall.SetsockoptLinger":                             "syscall",
+	"syscall.SetsockoptString":                             "syscall",
+	"syscall.SetsockoptTimeval":                            "syscall",
+	"syscall.Settimeofday":                                 "syscall",
+	"syscall.Setuid":                                       "syscall",
+	"syscall.Setxattr":                                     "syscall",
+	"syscall.Shutdown":                                     "syscall",
+	"syscall.SidTypeAlias":                                 "syscall",
+	"syscall.SidTypeComputer":                              "syscall",
+	"syscall.SidTypeDeletedAccount":                        "syscall",
+	"syscall.SidTypeDomain":                                "syscall",
+	"syscall.SidTypeGroup":                                 "syscall",
+	"syscall.SidTypeInvalid":                               "syscall",
+	"syscall.SidTypeLabel":                                 "syscall",
+	"syscall.SidTypeUnknown":                               "syscall",
+	"syscall.SidTypeUser":                                  "syscall",
+	"syscall.SidTypeWellKnownGroup":                        "syscall",
+	"syscall.Signal":                                       "syscall",
+	"syscall.SizeofBpfHdr":                                 "syscall",
+	"syscall.SizeofBpfInsn":                                "syscall",
+	"syscall.SizeofBpfProgram":                             "syscall",
+	"syscall.SizeofBpfStat":                                "syscall",
+	"syscall.SizeofBpfVersion":                             "syscall",
+	"syscall.SizeofBpfZbuf":                                "syscall",
+	"syscall.SizeofBpfZbufHeader":                          "syscall",
+	"syscall.SizeofCmsghdr":                                "syscall",
+	"syscall.SizeofICMPv6Filter":                           "syscall",
+	"syscall.SizeofIPMreq":                                 "syscall",
+	"syscall.SizeofIPMreqn":                                "syscall",
+	"syscall.SizeofIPv6MTUInfo":                            "syscall",
+	"syscall.SizeofIPv6Mreq":                               "syscall",
+	"syscall.SizeofIfAddrmsg":                              "syscall",
+	"syscall.SizeofIfAnnounceMsghdr":                       "syscall",
+	"syscall.SizeofIfData":                                 "syscall",
+	"syscall.SizeofIfInfomsg":                              "syscall",
+	"syscall.SizeofIfMsghdr":                               "syscall",
+	"syscall.SizeofIfaMsghdr":                              "syscall",
+	"syscall.SizeofIfmaMsghdr":                             "syscall",
+	"syscall.SizeofIfmaMsghdr2":                            "syscall",
+	"syscall.SizeofInet4Pktinfo":                           "syscall",
+	"syscall.SizeofInet6Pktinfo":                           "syscall",
+	"syscall.SizeofInotifyEvent":                           "syscall",
+	"syscall.SizeofLinger":                                 "syscall",
+	"syscall.SizeofMsghdr":                                 "syscall",
+	"syscall.SizeofNlAttr":                                 "syscall",
+	"syscall.SizeofNlMsgerr":                               "syscall",
+	"syscall.SizeofNlMsghdr":                               "syscall",
+	"syscall.SizeofRtAttr":                                 "syscall",
+	"syscall.SizeofRtGenmsg":                               "syscall",
+	"syscall.SizeofRtMetrics":                              "syscall",
+	"syscall.SizeofRtMsg":                                  "syscall",
+	"syscall.SizeofRtMsghdr":                               "syscall",
+	"syscall.SizeofRtNexthop":                              "syscall",
+	"syscall.SizeofSockFilter":                             "syscall",
+	"syscall.SizeofSockFprog":                              "syscall",
+	"syscall.SizeofSockaddrAny":                            "syscall",
+	"syscall.SizeofSockaddrDatalink":                       "syscall",
+	"syscall.SizeofSockaddrInet4":                          "syscall",
+	"syscall.SizeofSockaddrInet6":                          "syscall",
+	"syscall.SizeofSockaddrLinklayer":                      "syscall",
+	"syscall.SizeofSockaddrNetlink":                        "syscall",
+	"syscall.SizeofSockaddrUnix":                           "syscall",
+	"syscall.SizeofTCPInfo":                                "syscall",
+	"syscall.SizeofUcred":                                  "syscall",
+	"syscall.SlicePtrFromStrings":                          "syscall",
+	"syscall.SockFilter":                                   "syscall",
+	"syscall.SockFprog":                                    "syscall",
+	"syscall.SockaddrDatalink":                             "syscall",
+	"syscall.SockaddrGen":                                  "syscall",
+	"syscall.SockaddrInet4":                                "syscall",
+	"syscall.SockaddrInet6":                                "syscall",
+	"syscall.SockaddrLinklayer":                            "syscall",
+	"syscall.SockaddrNetlink":                              "syscall",
+	"syscall.SockaddrUnix":                                 "syscall",
+	"syscall.Socket":                                       "syscall",
+	"syscall.SocketControlMessage":                         "syscall",
+	"syscall.SocketDisableIPv6":                            "syscall",
+	"syscall.Socketpair":                                   "syscall",
+	"syscall.Splice":                                       "syscall",
+	"syscall.StartProcess":                                 "syscall",
+	"syscall.StartupInfo":                                  "syscall",
+	"syscall.Stat":                                         "syscall",
+	"syscall.Stat_t":                                       "syscall",
+	"syscall.Statfs":                                       "syscall",
+	"syscall.Statfs_t":                                     "syscall",
+	"syscall.Stderr":                                       "syscall",
+	"syscall.Stdin":                                        "syscall",
+	"syscall.Stdout":                                       "syscall",
+	"syscall.StringBytePtr":                                "syscall",
+	"syscall.StringByteSlice":                              "syscall",
+	"syscall.StringSlicePtr":                               "syscall",
+	"syscall.StringToSid":                                  "syscall",
+	"syscall.StringToUTF16":                                "syscall",
+	"syscall.StringToUTF16Ptr":                             "syscall",
+	"syscall.Symlink":                                      "syscall",
+	"syscall.Sync":                                         "syscall",
+	"syscall.SyncFileRange":                                "syscall",
+	"syscall.SysProcAttr":                                  "syscall",
+	"syscall.SysProcIDMap":                                 "syscall",
+	"syscall.Syscall":                                      "syscall",
+	"syscall.Syscall12":                                    "syscall",
+	"syscall.Syscall15":                                    "syscall",
+	"syscall.Syscall6":                                     "syscall",
+	"syscall.Syscall9":                                     "syscall",
+	"syscall.Sysctl":                                       "syscall",
+	"syscall.SysctlUint32":                                 "syscall",
+	"syscall.Sysctlnode":                                   "syscall",
+	"syscall.Sysinfo":                                      "syscall",
+	"syscall.Sysinfo_t":                                    "syscall",
+	"syscall.Systemtime":                                   "syscall",
+	"syscall.TCGETS":                                       "syscall",
+	"syscall.TCIFLUSH":                                     "syscall",
+	"syscall.TCIOFLUSH":                                    "syscall",
+	"syscall.TCOFLUSH":                                     "syscall",
+	"syscall.TCPInfo":                                      "syscall",
+	"syscall.TCPKeepalive":                                 "syscall",
+	"syscall.TCP_CA_NAME_MAX":                              "syscall",
+	"syscall.TCP_CONGCTL":                                  "syscall",
+	"syscall.TCP_CONGESTION":                               "syscall",
+	"syscall.TCP_CONNECTIONTIMEOUT":                        "syscall",
+	"syscall.TCP_CORK":                                     "syscall",
+	"syscall.TCP_DEFER_ACCEPT":                             "syscall",
+	"syscall.TCP_INFO":                                     "syscall",
+	"syscall.TCP_KEEPALIVE":                                "syscall",
+	"syscall.TCP_KEEPCNT":                                  "syscall",
+	"syscall.TCP_KEEPIDLE":                                 "syscall",
+	"syscall.TCP_KEEPINIT":                                 "syscall",
+	"syscall.TCP_KEEPINTVL":                                "syscall",
+	"syscall.TCP_LINGER2":                                  "syscall",
+	"syscall.TCP_MAXBURST":                                 "syscall",
+	"syscall.TCP_MAXHLEN":                                  "syscall",
+	"syscall.TCP_MAXOLEN":                                  "syscall",
+	"syscall.TCP_MAXSEG":                                   "syscall",
+	"syscall.TCP_MAXWIN":                                   "syscall",
+	"syscall.TCP_MAX_SACK":                                 "syscall",
+	"syscall.TCP_MAX_WINSHIFT":                             "syscall",
+	"syscall.TCP_MD5SIG":                                   "syscall",
+	"syscall.TCP_MD5SIG_MAXKEYLEN":                         "syscall",
+	"syscall.TCP_MINMSS":                                   "syscall",
+	"syscall.TCP_MINMSSOVERLOAD":                           "syscall",
+	"syscall.TCP_MSS":                                      "syscall",
+	"syscall.TCP_NODELAY":                                  "syscall",
+	"syscall.TCP_NOOPT":                                    "syscall",
+	"syscall.TCP_NOPUSH":                                   "syscall",
+	"syscall.TCP_NSTATES":                                  "syscall",
+	"syscall.TCP_QUICKACK":                                 "syscall",
+	"syscall.TCP_RXT_CONNDROPTIME":                         "syscall",
+	"syscall.TCP_RXT_FINDROP":                              "syscall",
+	"syscall.TCP_SACK_ENABLE":                              "syscall",
+	"syscall.TCP_SYNCNT":                                   "syscall",
+	"syscall.TCP_VENDOR":                                   "syscall",
+	"syscall.TCP_WINDOW_CLAMP":                             "syscall",
+	"syscall.TCSAFLUSH":                                    "syscall",
+	"syscall.TCSETS":                                       "syscall",
+	"syscall.TF_DISCONNECT":                                "syscall",
+	"syscall.TF_REUSE_SOCKET":                              "syscall",
+	"syscall.TF_USE_DEFAULT_WORKER":                        "syscall",
+	"syscall.TF_USE_KERNEL_APC":                            "syscall",
+	"syscall.TF_USE_SYSTEM_THREAD":                         "syscall",
+	"syscall.TF_WRITE_BEHIND":                              "syscall",
+	"syscall.TH32CS_INHERIT":                               "syscall",
+	"syscall.TH32CS_SNAPALL":                               "syscall",
+	"syscall.TH32CS_SNAPHEAPLIST":                          "syscall",
+	"syscall.TH32CS_SNAPMODULE":                            "syscall",
+	"syscall.TH32CS_SNAPMODULE32":                          "syscall",
+	"syscall.TH32CS_SNAPPROCESS":                           "syscall",
+	"syscall.TH32CS_SNAPTHREAD":                            "syscall",
+	"syscall.TIME_ZONE_ID_DAYLIGHT":                        "syscall",
+	"syscall.TIME_ZONE_ID_STANDARD":                        "syscall",
+	"syscall.TIME_ZONE_ID_UNKNOWN":                         "syscall",
+	"syscall.TIOCCBRK":                                     "syscall",
+	"syscall.TIOCCDTR":                                     "syscall",
+	"syscall.TIOCCONS":                                     "syscall",
+	"syscall.TIOCDCDTIMESTAMP":                             "syscall",
+	"syscall.TIOCDRAIN":                                    "syscall",
+	"syscall.TIOCDSIMICROCODE":                             "syscall",
+	"syscall.TIOCEXCL":                                     "syscall",
+	"syscall.TIOCEXT":                                      "syscall",
+	"syscall.TIOCFLAG_CDTRCTS":                             "syscall",
+	"syscall.TIOCFLAG_CLOCAL":                              "syscall",
+	"syscall.TIOCFLAG_CRTSCTS":                             "syscall",
+	"syscall.TIOCFLAG_MDMBUF":                              "syscall",
+	"syscall.TIOCFLAG_PPS":                                 "syscall",
+	"syscall.TIOCFLAG_SOFTCAR":                             "syscall",
+	"syscall.TIOCFLUSH":                                    "syscall",
+	"syscall.TIOCGDEV":                                     "syscall",
+	"syscall.TIOCGDRAINWAIT":                               "syscall",
+	"syscall.TIOCGETA":                                     "syscall",
+	"syscall.TIOCGETD":                                     "syscall",
+	"syscall.TIOCGFLAGS":                                   "syscall",
+	"syscall.TIOCGICOUNT":                                  "syscall",
+	"syscall.TIOCGLCKTRMIOS":                               "syscall",
+	"syscall.TIOCGLINED":                                   "syscall",
+	"syscall.TIOCGPGRP":                                    "syscall",
+	"syscall.TIOCGPTN":                                     "syscall",
+	"syscall.TIOCGQSIZE":                                   "syscall",
+	"syscall.TIOCGRANTPT":                                  "syscall",
+	"syscall.TIOCGRS485":                                   "syscall",
+	"syscall.TIOCGSERIAL":                                  "syscall",
+	"syscall.TIOCGSID":                                     "syscall",
+	"syscall.TIOCGSIZE":                                    "syscall",
+	"syscall.TIOCGSOFTCAR":                                 "syscall",
+	"syscall.TIOCGTSTAMP":                                  "syscall",
+	"syscall.TIOCGWINSZ":                                   "syscall",
+	"syscall.TIOCINQ":                                      "syscall",
+	"syscall.TIOCIXOFF":                                    "syscall",
+	"syscall.TIOCIXON":                                     "syscall",
+	"syscall.TIOCLINUX":                                    "syscall",
+	"syscall.TIOCMBIC":                                     "syscall",
+	"syscall.TIOCMBIS":                                     "syscall",
+	"syscall.TIOCMGDTRWAIT":                                "syscall",
+	"syscall.TIOCMGET":                                     "syscall",
+	"syscall.TIOCMIWAIT":                                   "syscall",
+	"syscall.TIOCMODG":                                     "syscall",
+	"syscall.TIOCMODS":                                     "syscall",
+	"syscall.TIOCMSDTRWAIT":                                "syscall",
+	"syscall.TIOCMSET":                                     "syscall",
+	"syscall.TIOCM_CAR":                                    "syscall",
+	"syscall.TIOCM_CD":                                     "syscall",
+	"syscall.TIOCM_CTS":                                    "syscall",
+	"syscall.TIOCM_DCD":                                    "syscall",
+	"syscall.TIOCM_DSR":                                    "syscall",
+	"syscall.TIOCM_DTR":                                    "syscall",
+	"syscall.TIOCM_LE":                                     "syscall",
+	"syscall.TIOCM_RI":                                     "syscall",
+	"syscall.TIOCM_RNG":                                    "syscall",
+	"syscall.TIOCM_RTS":                                    "syscall",
+	"syscall.TIOCM_SR":                                     "syscall",
+	"syscall.TIOCM_ST":                                     "syscall",
+	"syscall.TIOCNOTTY":                                    "syscall",
+	"syscall.TIOCNXCL":                                     "syscall",
+	"syscall.TIOCOUTQ":                                     "syscall",
+	"syscall.TIOCPKT":                                      "syscall",
+	"syscall.TIOCPKT_DATA":                                 "syscall",
+	"syscall.TIOCPKT_DOSTOP":                               "syscall",
+	"syscall.TIOCPKT_FLUSHREAD":                            "syscall",
+	"syscall.TIOCPKT_FLUSHWRITE":                           "syscall",
+	"syscall.TIOCPKT_IOCTL":                                "syscall",
+	"syscall.TIOCPKT_NOSTOP":                               "syscall",
+	"syscall.TIOCPKT_START":                                "syscall",
+	"syscall.TIOCPKT_STOP":                                 "syscall",
+	"syscall.TIOCPTMASTER":                                 "syscall",
+	"syscall.TIOCPTMGET":                                   "syscall",
+	"syscall.TIOCPTSNAME":                                  "syscall",
+	"syscall.TIOCPTYGNAME":                                 "syscall",
+	"syscall.TIOCPTYGRANT":                                 "syscall",
+	"syscall.TIOCPTYUNLK":                                  "syscall",
+	"syscall.TIOCRCVFRAME":                                 "syscall",
+	"syscall.TIOCREMOTE":                                   "syscall",
+	"syscall.TIOCSBRK":                                     "syscall",
+	"syscall.TIOCSCONS":                                    "syscall",
+	"syscall.TIOCSCTTY":                                    "syscall",
+	"syscall.TIOCSDRAINWAIT":                               "syscall",
+	"syscall.TIOCSDTR":                                     "syscall",
+	"syscall.TIOCSERCONFIG":                                "syscall",
+	"syscall.TIOCSERGETLSR":                                "syscall",
+	"syscall.TIOCSERGETMULTI":                              "syscall",
+	"syscall.TIOCSERGSTRUCT":                               "syscall",
+	"syscall.TIOCSERGWILD":                                 "syscall",
+	"syscall.TIOCSERSETMULTI":                              "syscall",
+	"syscall.TIOCSERSWILD":                                 "syscall",
+	"syscall.TIOCSER_TEMT":                                 "syscall",
+	"syscall.TIOCSETA":                                     "syscall",
+	"syscall.TIOCSETAF":                                    "syscall",
+	"syscall.TIOCSETAW":                                    "syscall",
+	"syscall.TIOCSETD":                                     "syscall",
+	"syscall.TIOCSFLAGS":                                   "syscall",
+	"syscall.TIOCSIG":                                      "syscall",
+	"syscall.TIOCSLCKTRMIOS":                               "syscall",
+	"syscall.TIOCSLINED":                                   "syscall",
+	"syscall.TIOCSPGRP":                                    "syscall",
+	"syscall.TIOCSPTLCK":                                   "syscall",
+	"syscall.TIOCSQSIZE":                                   "syscall",
+	"syscall.TIOCSRS485":                                   "syscall",
+	"syscall.TIOCSSERIAL":                                  "syscall",
+	"syscall.TIOCSSIZE":                                    "syscall",
+	"syscall.TIOCSSOFTCAR":                                 "syscall",
+	"syscall.TIOCSTART":                                    "syscall",
+	"syscall.TIOCSTAT":                                     "syscall",
+	"syscall.TIOCSTI":                                      "syscall",
+	"syscall.TIOCSTOP":                                     "syscall",
+	"syscall.TIOCSTSTAMP":                                  "syscall",
+	"syscall.TIOCSWINSZ":                                   "syscall",
+	"syscall.TIOCTIMESTAMP":                                "syscall",
+	"syscall.TIOCUCNTL":                                    "syscall",
+	"syscall.TIOCVHANGUP":                                  "syscall",
+	"syscall.TIOCXMTFRAME":                                 "syscall",
+	"syscall.TOKEN_ADJUST_DEFAULT":                         "syscall",
+	"syscall.TOKEN_ADJUST_GROUPS":                          "syscall",
+	"syscall.TOKEN_ADJUST_PRIVILEGES":                      "syscall",
+	"syscall.TOKEN_ALL_ACCESS":                             "syscall",
+	"syscall.TOKEN_ASSIGN_PRIMARY":                         "syscall",
+	"syscall.TOKEN_DUPLICATE":                              "syscall",
+	"syscall.TOKEN_EXECUTE":                                "syscall",
+	"syscall.TOKEN_IMPERSONATE":                            "syscall",
+	"syscall.TOKEN_QUERY":                                  "syscall",
+	"syscall.TOKEN_QUERY_SOURCE":                           "syscall",
+	"syscall.TOKEN_READ":                                   "syscall",
+	"syscall.TOKEN_WRITE":                                  "syscall",
+	"syscall.TOSTOP":                                       "syscall",
+	"syscall.TRUNCATE_EXISTING":                            "syscall",
+	"syscall.TUNATTACHFILTER":                              "syscall",
+	"syscall.TUNDETACHFILTER":                              "syscall",
+	"syscall.TUNGETFEATURES":                               "syscall",
+	"syscall.TUNGETIFF":                                    "syscall",
+	"syscall.TUNGETSNDBUF":                                 "syscall",
+	"syscall.TUNGETVNETHDRSZ":                              "syscall",
+	"syscall.TUNSETDEBUG":                                  "syscall",
+	"syscall.TUNSETGROUP":                                  "syscall",
+	"syscall.TUNSETIFF":                                    "syscall",
+	"syscall.TUNSETLINK":                                   "syscall",
+	"syscall.TUNSETNOCSUM":                                 "syscall",
+	"syscall.TUNSETOFFLOAD":                                "syscall",
+	"syscall.TUNSETOWNER":                                  "syscall",
+	"syscall.TUNSETPERSIST":                                "syscall",
+	"syscall.TUNSETSNDBUF":                                 "syscall",
+	"syscall.TUNSETTXFILTER":                               "syscall",
+	"syscall.TUNSETVNETHDRSZ":                              "syscall",
+	"syscall.Tee":                                          "syscall",
+	"syscall.TerminateProcess":                             "syscall",
+	"syscall.Termios":                                      "syscall",
+	"syscall.Tgkill":                                       "syscall",
+	"syscall.Time":                                         "syscall",
+	"syscall.Time_t":                                       "syscall",
+	"syscall.Times":                                        "syscall",
+	"syscall.Timespec":                                     "syscall",
+	"syscall.TimespecToNsec":                               "syscall",
+	"syscall.Timeval":                                      "syscall",
+	"syscall.Timeval32":                                    "syscall",
+	"syscall.TimevalToNsec":                                "syscall",
+	"syscall.Timex":                                        "syscall",
+	"syscall.Timezoneinformation":                          "syscall",
+	"syscall.Tms":                                          "syscall",
+	"syscall.Token":                                        "syscall",
+	"syscall.TokenAccessInformation":                       "syscall",
+	"syscall.TokenAuditPolicy":                             "syscall",
+	"syscall.TokenDefaultDacl":                             "syscall",
+	"syscall.TokenElevation":                               "syscall",
+	"syscall.TokenElevationType":                           "syscall",
+	"syscall.TokenGroups":                                  "syscall",
+	"syscall.TokenGroupsAndPrivileges":                     "syscall",
+	"syscall.TokenHasRestrictions":                         "syscall",
+	"syscall.TokenImpersonationLevel":                      "syscall",
+	"syscall.TokenIntegrityLevel":                          "syscall",
+	"syscall.TokenLinkedToken":                             "syscall",
+	"syscall.TokenLogonSid":                                "syscall",
+	"syscall.TokenMandatoryPolicy":                         "syscall",
+	"syscall.TokenOrigin":                                  "syscall",
+	"syscall.TokenOwner":                                   "syscall",
+	"syscall.TokenPrimaryGroup":                            "syscall",
+	"syscall.TokenPrivileges":                              "syscall",
+	"syscall.TokenRestrictedSids":                          "syscall",
+	"syscall.TokenSandBoxInert":                            "syscall",
+	"syscall.TokenSessionId":                               "syscall",
+	"syscall.TokenSessionReference":                        "syscall",
+	"syscall.TokenSource":                                  "syscall",
+	"syscall.TokenStatistics":                              "syscall",
+	"syscall.TokenType":                                    "syscall",
+	"syscall.TokenUIAccess":                                "syscall",
+	"syscall.TokenUser":                                    "syscall",
+	"syscall.TokenVirtualizationAllowed":                   "syscall",
+	"syscall.TokenVirtualizationEnabled":                   "syscall",
+	"syscall.Tokenprimarygroup":                            "syscall",
+	"syscall.Tokenuser":                                    "syscall",
+	"syscall.TranslateAccountName":                         "syscall",
+	"syscall.TranslateName":                                "syscall",
+	"syscall.TransmitFile":                                 "syscall",
+	"syscall.TransmitFileBuffers":                          "syscall",
+	"syscall.Truncate":                                     "syscall",
+	"syscall.USAGE_MATCH_TYPE_AND":                         "syscall",
+	"syscall.USAGE_MATCH_TYPE_OR":                          "syscall",
+	"syscall.UTF16FromString":                              "syscall",
+	"syscall.UTF16PtrFromString":                           "syscall",
+	"syscall.UTF16ToString":                                "syscall",
+	"syscall.Ucred":                                        "syscall",
+	"syscall.Umask":                                        "syscall",
+	"syscall.Uname":                                        "syscall",
+	"syscall.Undelete":                                     "syscall",
+	"syscall.UnixCredentials":                              "syscall",
+	"syscall.UnixRights":                                   "syscall",
+	"syscall.Unlink":                                       "syscall",
+	"syscall.Unlinkat":                                     "syscall",
+	"syscall.UnmapViewOfFile":                              "syscall",
+	"syscall.Unmount":                                      "syscall",
+	"syscall.Unsetenv":                                     "syscall",
+	"syscall.Unshare":                                      "syscall",
+	"syscall.UserInfo10":                                   "syscall",
+	"syscall.Ustat":                                        "syscall",
+	"syscall.Ustat_t":                                      "syscall",
+	"syscall.Utimbuf":                                      "syscall",
+	"syscall.Utime":                                        "syscall",
+	"syscall.Utimes":                                       "syscall",
+	"syscall.UtimesNano":                                   "syscall",
+	"syscall.Utsname":                                      "syscall",
+	"syscall.VDISCARD":                                     "syscall",
+	"syscall.VDSUSP":                                       "syscall",
+	"syscall.VEOF":                                         "syscall",
+	"syscall.VEOL":                                         "syscall",
+	"syscall.VEOL2":                                        "syscall",
+	"syscall.VERASE":                                       "syscall",
+	"syscall.VERASE2":                                      "syscall",
+	"syscall.VINTR":                                        "syscall",
+	"syscall.VKILL":                                        "syscall",
+	"syscall.VLNEXT":                                       "syscall",
+	"syscall.VMIN":                                         "syscall",
+	"syscall.VQUIT":                                        "syscall",
+	"syscall.VREPRINT":                                     "syscall",
+	"syscall.VSTART":                                       "syscall",
+	"syscall.VSTATUS":                                      "syscall",
+	"syscall.VSTOP":                                        "syscall",
+	"syscall.VSUSP":                                        "syscall",
+	"syscall.VSWTC":                                        "syscall",
+	"syscall.VT0":                                          "syscall",
+	"syscall.VT1":                                          "syscall",
+	"syscall.VTDLY":                                        "syscall",
+	"syscall.VTIME":                                        "syscall",
+	"syscall.VWERASE":                                      "syscall",
+	"syscall.VirtualLock":                                  "syscall",
+	"syscall.VirtualUnlock":                                "syscall",
+	"syscall.WAIT_ABANDONED":                               "syscall",
+	"syscall.WAIT_FAILED":                                  "syscall",
+	"syscall.WAIT_OBJECT_0":                                "syscall",
+	"syscall.WAIT_TIMEOUT":                                 "syscall",
+	"syscall.WALL":                                         "syscall",
+	"syscall.WALLSIG":                                      "syscall",
+	"syscall.WALTSIG":                                      "syscall",
+	"syscall.WCLONE":                                       "syscall",
+	"syscall.WCONTINUED":                                   "syscall",
+	"syscall.WCOREFLAG":                                    "syscall",
+	"syscall.WEXITED":                                      "syscall",
+	"syscall.WLINUXCLONE":                                  "syscall",
+	"syscall.WNOHANG":                                      "syscall",
+	"syscall.WNOTHREAD":                                    "syscall",
+	"syscall.WNOWAIT":                                      "syscall",
+	"syscall.WNOZOMBIE":                                    "syscall",
+	"syscall.WOPTSCHECKED":                                 "syscall",
+	"syscall.WORDSIZE":                                     "syscall",
+	"syscall.WSABuf":                                       "syscall",
+	"syscall.WSACleanup":                                   "syscall",
+	"syscall.WSADESCRIPTION_LEN":                           "syscall",
+	"syscall.WSAData":                                      "syscall",
+	"syscall.WSAEACCES":                                    "syscall",
+	"syscall.WSAECONNABORTED":                              "syscall",
+	"syscall.WSAECONNRESET":                                "syscall",
+	"syscall.WSAEnumProtocols":                             "syscall",
+	"syscall.WSAID_CONNECTEX":                              "syscall",
+	"syscall.WSAIoctl":                                     "syscall",
+	"syscall.WSAPROTOCOL_LEN":                              "syscall",
+	"syscall.WSAProtocolChain":                             "syscall",
+	"syscall.WSAProtocolInfo":                              "syscall",
+	"syscall.WSARecv":                                      "syscall",
+	"syscall.WSARecvFrom":                                  "syscall",
+	"syscall.WSASYS_STATUS_LEN":                            "syscall",
+	"syscall.WSASend":                                      "syscall",
+	"syscall.WSASendTo":                                    "syscall",
+	"syscall.WSASendto":                                    "syscall",
+	"syscall.WSAStartup":                                   "syscall",
+	"syscall.WSTOPPED":                                     "syscall",
+	"syscall.WTRAPPED":                                     "syscall",
+	"syscall.WUNTRACED":                                    "syscall",
+	"syscall.Wait4":                                        "syscall",
+	"syscall.WaitForSingleObject":                          "syscall",
+	"syscall.WaitStatus":                                   "syscall",
+	"syscall.Win32FileAttributeData":                       "syscall",
+	"syscall.Win32finddata":                                "syscall",
+	"syscall.Write":                                        "syscall",
+	"syscall.WriteConsole":                                 "syscall",
+	"syscall.WriteFile":                                    "syscall",
+	"syscall.X509_ASN_ENCODING":                            "syscall",
+	"syscall.XCASE":                                        "syscall",
+	"syscall.XP1_CONNECTIONLESS":                           "syscall",
+	"syscall.XP1_CONNECT_DATA":                             "syscall",
+	"syscall.XP1_DISCONNECT_DATA":                          "syscall",
+	"syscall.XP1_EXPEDITED_DATA":                           "syscall",
+	"syscall.XP1_GRACEFUL_CLOSE":                           "syscall",
+	"syscall.XP1_GUARANTEED_DELIVERY":                      "syscall",
+	"syscall.XP1_GUARANTEED_ORDER":                         "syscall",
+	"syscall.XP1_IFS_HANDLES":                              "syscall",
+	"syscall.XP1_MESSAGE_ORIENTED":                         "syscall",
+	"syscall.XP1_MULTIPOINT_CONTROL_PLANE":                 "syscall",
+	"syscall.XP1_MULTIPOINT_DATA_PLANE":                    "syscall",
+	"syscall.XP1_PARTIAL_MESSAGE":                          "syscall",
+	"syscall.XP1_PSEUDO_STREAM":                            "syscall",
+	"syscall.XP1_QOS_SUPPORTED":                            "syscall",
+	"syscall.XP1_SAN_SUPPORT_SDP":                          "syscall",
+	"syscall.XP1_SUPPORT_BROADCAST":                        "syscall",
+	"syscall.XP1_SUPPORT_MULTIPOINT":                       "syscall",
+	"syscall.XP1_UNI_RECV":                                 "syscall",
+	"syscall.XP1_UNI_SEND":                                 "syscall",
+	"syslog.Dial":                                          "log/syslog",
+	"syslog.LOG_ALERT":                                     "log/syslog",
+	"syslog.LOG_AUTH":                                      "log/syslog",
+	"syslog.LOG_AUTHPRIV":                                  "log/syslog",
+	"syslog.LOG_CRIT":                                      "log/syslog",
+	"syslog.LOG_CRON":                                      "log/syslog",
+	"syslog.LOG_DAEMON":                                    "log/syslog",
+	"syslog.LOG_DEBUG":                                     "log/syslog",
+	"syslog.LOG_EMERG":                                     "log/syslog",
+	"syslog.LOG_ERR":                                       "log/syslog",
+	"syslog.LOG_FTP":                                       "log/syslog",
+	"syslog.LOG_INFO":                                      "log/syslog",
+	"syslog.LOG_KERN":                                      "log/syslog",
+	"syslog.LOG_LOCAL0":                                    "log/syslog",
+	"syslog.LOG_LOCAL1":                                    "log/syslog",
+	"syslog.LOG_LOCAL2":                                    "log/syslog",
+	"syslog.LOG_LOCAL3":                                    "log/syslog",
+	"syslog.LOG_LOCAL4":                                    "log/syslog",
+	"syslog.LOG_LOCAL5":                                    "log/syslog",
+	"syslog.LOG_LOCAL6":                                    "log/syslog",
+	"syslog.LOG_LOCAL7":                                    "log/syslog",
+	"syslog.LOG_LPR":                                       "log/syslog",
+	"syslog.LOG_MAIL":                                      "log/syslog",
+	"syslog.LOG_NEWS":                                      "log/syslog",
+	"syslog.LOG_NOTICE":                                    "log/syslog",
+	"syslog.LOG_SYSLOG":                                    "log/syslog",
+	"syslog.LOG_USER":                                      "log/syslog",
+	"syslog.LOG_UUCP":                                      "log/syslog",
+	"syslog.LOG_WARNING":                                   "log/syslog",
+	"syslog.New":                                           "log/syslog",
+	"syslog.NewLogger":                                     "log/syslog",
+	"syslog.Priority":                                      "log/syslog",
+	"syslog.Writer":                                        "log/syslog",
+	"tabwriter.AlignRight":                                 "text/tabwriter",
+	"tabwriter.Debug":                                      "text/tabwriter",
+	"tabwriter.DiscardEmptyColumns":                        "text/tabwriter",
+	"tabwriter.Escape":                                     "text/tabwriter",
+	"tabwriter.FilterHTML":                                 "text/tabwriter",
+	"tabwriter.NewWriter":                                  "text/tabwriter",
+	"tabwriter.StripEscape":                                "text/tabwriter",
+	"tabwriter.TabIndent":                                  "text/tabwriter",
+	"tabwriter.Writer":                                     "text/tabwriter",
+	"tar.ErrFieldTooLong":                                  "archive/tar",
+	"tar.ErrHeader":                                        "archive/tar",
+	"tar.ErrWriteAfterClose":                               "archive/tar",
+	"tar.ErrWriteTooLong":                                  "archive/tar",
+	"tar.FileInfoHeader":                                   "archive/tar",
+	"tar.Header":                                           "archive/tar",
+	"tar.NewReader":                                        "archive/tar",
+	"tar.NewWriter":                                        "archive/tar",
+	"tar.Reader":                                           "archive/tar",
+	"tar.TypeBlock":                                        "archive/tar",
+	"tar.TypeChar":                                         "archive/tar",
+	"tar.TypeCont":                                         "archive/tar",
+	"tar.TypeDir":                                          "archive/tar",
+	"tar.TypeFifo":                                         "archive/tar",
+	"tar.TypeGNULongLink":                                  "archive/tar",
+	"tar.TypeGNULongName":                                  "archive/tar",
+	"tar.TypeGNUSparse":                                    "archive/tar",
+	"tar.TypeLink":                                         "archive/tar",
+	"tar.TypeReg":                                          "archive/tar",
+	"tar.TypeRegA":                                         "archive/tar",
+	"tar.TypeSymlink":                                      "archive/tar",
+	"tar.TypeXGlobalHeader":                                "archive/tar",
+	"tar.TypeXHeader":                                      "archive/tar",
+	"tar.Writer":                                           "archive/tar",
+	"template.CSS":                                         "html/template",
+	"template.ErrAmbigContext":                             "html/template",
+	"template.ErrBadHTML":                                  "html/template",
+	"template.ErrBranchEnd":                                "html/template",
+	"template.ErrEndContext":                               "html/template",
+	"template.ErrNoSuchTemplate":                           "html/template",
+	"template.ErrOutputContext":                            "html/template",
+	"template.ErrPartialCharset":                           "html/template",
+	"template.ErrPartialEscape":                            "html/template",
+	"template.ErrPredefinedEscaper":                        "html/template",
+	"template.ErrRangeLoopReentry":                         "html/template",
+	"template.ErrSlashAmbig":                               "html/template",
+	"template.Error":                                       "html/template",
+	"template.ErrorCode":                                   "html/template",
+	"template.ExecError":                                   "text/template",
+	// "template.FuncMap" is ambiguous
+	"template.HTML":     "html/template",
+	"template.HTMLAttr": "html/template",
+	// "template.HTMLEscape" is ambiguous
+	// "template.HTMLEscapeString" is ambiguous
+	// "template.HTMLEscaper" is ambiguous
+	// "template.IsTrue" is ambiguous
+	"template.JS": "html/template",
+	// "template.JSEscape" is ambiguous
+	// "template.JSEscapeString" is ambiguous
+	// "template.JSEscaper" is ambiguous
+	"template.JSStr": "html/template",
+	// "template.Must" is ambiguous
+	// "template.New" is ambiguous
+	"template.OK": "html/template",
+	// "template.ParseFiles" is ambiguous
+	// "template.ParseGlob" is ambiguous
+	// "template.Template" is ambiguous
+	"template.URL": "html/template",
+	// "template.URLQueryEscaper" is ambiguous
+	"testing.AllocsPerRun":                        "testing",
+	"testing.B":                                   "testing",
+	"testing.Benchmark":                           "testing",
+	"testing.BenchmarkResult":                     "testing",
+	"testing.Cover":                               "testing",
+	"testing.CoverBlock":                          "testing",
+	"testing.CoverMode":                           "testing",
+	"testing.Coverage":                            "testing",
+	"testing.InternalBenchmark":                   "testing",
+	"testing.InternalExample":                     "testing",
+	"testing.InternalTest":                        "testing",
+	"testing.M":                                   "testing",
+	"testing.Main":                                "testing",
+	"testing.MainStart":                           "testing",
+	"testing.PB":                                  "testing",
+	"testing.RegisterCover":                       "testing",
+	"testing.RunBenchmarks":                       "testing",
+	"testing.RunExamples":                         "testing",
+	"testing.RunTests":                            "testing",
+	"testing.Short":                               "testing",
+	"testing.T":                                   "testing",
+	"testing.Verbose":                             "testing",
+	"textproto.CanonicalMIMEHeaderKey":            "net/textproto",
+	"textproto.Conn":                              "net/textproto",
+	"textproto.Dial":                              "net/textproto",
+	"textproto.Error":                             "net/textproto",
+	"textproto.MIMEHeader":                        "net/textproto",
+	"textproto.NewConn":                           "net/textproto",
+	"textproto.NewReader":                         "net/textproto",
+	"textproto.NewWriter":                         "net/textproto",
+	"textproto.Pipeline":                          "net/textproto",
+	"textproto.ProtocolError":                     "net/textproto",
+	"textproto.Reader":                            "net/textproto",
+	"textproto.TrimBytes":                         "net/textproto",
+	"textproto.TrimString":                        "net/textproto",
+	"textproto.Writer":                            "net/textproto",
+	"time.ANSIC":                                  "time",
+	"time.After":                                  "time",
+	"time.AfterFunc":                              "time",
+	"time.April":                                  "time",
+	"time.August":                                 "time",
+	"time.Date":                                   "time",
+	"time.December":                               "time",
+	"time.Duration":                               "time",
+	"time.February":                               "time",
+	"time.FixedZone":                              "time",
+	"time.Friday":                                 "time",
+	"time.Hour":                                   "time",
+	"time.January":                                "time",
+	"time.July":                                   "time",
+	"time.June":                                   "time",
+	"time.Kitchen":                                "time",
+	"time.LoadLocation":                           "time",
+	"time.Local":                                  "time",
+	"time.Location":                               "time",
+	"time.March":                                  "time",
+	"time.May":                                    "time",
+	"time.Microsecond":                            "time",
+	"time.Millisecond":                            "time",
+	"time.Minute":                                 "time",
+	"time.Monday":                                 "time",
+	"time.Month":                                  "time",
+	"time.Nanosecond":                             "time",
+	"time.NewTicker":                              "time",
+	"time.NewTimer":                               "time",
+	"time.November":                               "time",
+	"time.Now":                                    "time",
+	"time.October":                                "time",
+	"time.Parse":                                  "time",
+	"time.ParseDuration":                          "time",
+	"time.ParseError":                             "time",
+	"time.ParseInLocation":                        "time",
+	"time.RFC1123":                                "time",
+	"time.RFC1123Z":                               "time",
+	"time.RFC3339":                                "time",
+	"time.RFC3339Nano":                            "time",
+	"time.RFC822":                                 "time",
+	"time.RFC822Z":                                "time",
+	"time.RFC850":                                 "time",
+	"time.RubyDate":                               "time",
+	"time.Saturday":                               "time",
+	"time.Second":                                 "time",
+	"time.September":                              "time",
+	"time.Since":                                  "time",
+	"time.Sleep":                                  "time",
+	"time.Stamp":                                  "time",
+	"time.StampMicro":                             "time",
+	"time.StampMilli":                             "time",
+	"time.StampNano":                              "time",
+	"time.Sunday":                                 "time",
+	"time.Thursday":                               "time",
+	"time.Tick":                                   "time",
+	"time.Ticker":                                 "time",
+	"time.Time":                                   "time",
+	"time.Timer":                                  "time",
+	"time.Tuesday":                                "time",
+	"time.UTC":                                    "time",
+	"time.Unix":                                   "time",
+	"time.UnixDate":                               "time",
+	"time.Until":                                  "time",
+	"time.Wednesday":                              "time",
+	"time.Weekday":                                "time",
+	"tls.Certificate":                             "crypto/tls",
+	"tls.CertificateRequestInfo":                  "crypto/tls",
+	"tls.Client":                                  "crypto/tls",
+	"tls.ClientAuthType":                          "crypto/tls",
+	"tls.ClientHelloInfo":                         "crypto/tls",
+	"tls.ClientSessionCache":                      "crypto/tls",
+	"tls.ClientSessionState":                      "crypto/tls",
+	"tls.Config":                                  "crypto/tls",
+	"tls.Conn":                                    "crypto/tls",
+	"tls.ConnectionState":                         "crypto/tls",
+	"tls.CurveID":                                 "crypto/tls",
+	"tls.CurveP256":                               "crypto/tls",
+	"tls.CurveP384":                               "crypto/tls",
+	"tls.CurveP521":                               "crypto/tls",
+	"tls.Dial":                                    "crypto/tls",
+	"tls.DialWithDialer":                          "crypto/tls",
+	"tls.ECDSAWithP256AndSHA256":                  "crypto/tls",
+	"tls.ECDSAWithP384AndSHA384":                  "crypto/tls",
+	"tls.ECDSAWithP521AndSHA512":                  "crypto/tls",
+	"tls.Listen":                                  "crypto/tls",
+	"tls.LoadX509KeyPair":                         "crypto/tls",
+	"tls.NewLRUClientSessionCache":                "crypto/tls",
+	"tls.NewListener":                             "crypto/tls",
+	"tls.NoClientCert":                            "crypto/tls",
+	"tls.PKCS1WithSHA1":                           "crypto/tls",
+	"tls.PKCS1WithSHA256":                         "crypto/tls",
+	"tls.PKCS1WithSHA384":                         "crypto/tls",
+	"tls.PKCS1WithSHA512":                         "crypto/tls",
+	"tls.PSSWithSHA256":                           "crypto/tls",
+	"tls.PSSWithSHA384":                           "crypto/tls",
+	"tls.PSSWithSHA512":                           "crypto/tls",
+	"tls.RecordHeaderError":                       "crypto/tls",
+	"tls.RenegotiateFreelyAsClient":               "crypto/tls",
+	"tls.RenegotiateNever":                        "crypto/tls",
+	"tls.RenegotiateOnceAsClient":                 "crypto/tls",
+	"tls.RenegotiationSupport":                    "crypto/tls",
+	"tls.RequestClientCert":                       "crypto/tls",
+	"tls.RequireAndVerifyClientCert":              "crypto/tls",
+	"tls.RequireAnyClientCert":                    "crypto/tls",
+	"tls.Server":                                  "crypto/tls",
+	"tls.SignatureScheme":                         "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA":    "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA":    "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305":  "crypto/tls",
+	"tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA":        "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA":     "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA":      "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256":   "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256":   "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA":      "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384":   "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305":    "crypto/tls",
+	"tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA":          "crypto/tls",
+	"tls.TLS_FALLBACK_SCSV":                       "crypto/tls",
+	"tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA":           "crypto/tls",
+	"tls.TLS_RSA_WITH_AES_128_CBC_SHA":            "crypto/tls",
+	"tls.TLS_RSA_WITH_AES_128_CBC_SHA256":         "crypto/tls",
+	"tls.TLS_RSA_WITH_AES_128_GCM_SHA256":         "crypto/tls",
+	"tls.TLS_RSA_WITH_AES_256_CBC_SHA":            "crypto/tls",
+	"tls.TLS_RSA_WITH_AES_256_GCM_SHA384":         "crypto/tls",
+	"tls.TLS_RSA_WITH_RC4_128_SHA":                "crypto/tls",
+	"tls.VerifyClientCertIfGiven":                 "crypto/tls",
+	"tls.VersionSSL30":                            "crypto/tls",
+	"tls.VersionTLS10":                            "crypto/tls",
+	"tls.VersionTLS11":                            "crypto/tls",
+	"tls.VersionTLS12":                            "crypto/tls",
+	"tls.X25519":                                  "crypto/tls",
+	"tls.X509KeyPair":                             "crypto/tls",
+	"token.ADD":                                   "go/token",
+	"token.ADD_ASSIGN":                            "go/token",
+	"token.AND":                                   "go/token",
+	"token.AND_ASSIGN":                            "go/token",
+	"token.AND_NOT":                               "go/token",
+	"token.AND_NOT_ASSIGN":                        "go/token",
+	"token.ARROW":                                 "go/token",
+	"token.ASSIGN":                                "go/token",
+	"token.BREAK":                                 "go/token",
+	"token.CASE":                                  "go/token",
+	"token.CHAN":                                  "go/token",
+	"token.CHAR":                                  "go/token",
+	"token.COLON":                                 "go/token",
+	"token.COMMA":                                 "go/token",
+	"token.COMMENT":                               "go/token",
+	"token.CONST":                                 "go/token",
+	"token.CONTINUE":                              "go/token",
+	"token.DEC":                                   "go/token",
+	"token.DEFAULT":                               "go/token",
+	"token.DEFER":                                 "go/token",
+	"token.DEFINE":                                "go/token",
+	"token.ELLIPSIS":                              "go/token",
+	"token.ELSE":                                  "go/token",
+	"token.EOF":                                   "go/token",
+	"token.EQL":                                   "go/token",
+	"token.FALLTHROUGH":                           "go/token",
+	"token.FLOAT":                                 "go/token",
+	"token.FOR":                                   "go/token",
+	"token.FUNC":                                  "go/token",
+	"token.File":                                  "go/token",
+	"token.FileSet":                               "go/token",
+	"token.GEQ":                                   "go/token",
+	"token.GO":                                    "go/token",
+	"token.GOTO":                                  "go/token",
+	"token.GTR":                                   "go/token",
+	"token.HighestPrec":                           "go/token",
+	"token.IDENT":                                 "go/token",
+	"token.IF":                                    "go/token",
+	"token.ILLEGAL":                               "go/token",
+	"token.IMAG":                                  "go/token",
+	"token.IMPORT":                                "go/token",
+	"token.INC":                                   "go/token",
+	"token.INT":                                   "go/token",
+	"token.INTERFACE":                             "go/token",
+	"token.LAND":                                  "go/token",
+	"token.LBRACE":                                "go/token",
+	"token.LBRACK":                                "go/token",
+	"token.LEQ":                                   "go/token",
+	"token.LOR":                                   "go/token",
+	"token.LPAREN":                                "go/token",
+	"token.LSS":                                   "go/token",
+	"token.Lookup":                                "go/token",
+	"token.LowestPrec":                            "go/token",
+	"token.MAP":                                   "go/token",
+	"token.MUL":                                   "go/token",
+	"token.MUL_ASSIGN":                            "go/token",
+	"token.NEQ":                                   "go/token",
+	"token.NOT":                                   "go/token",
+	"token.NewFileSet":                            "go/token",
+	"token.NoPos":                                 "go/token",
+	"token.OR":                                    "go/token",
+	"token.OR_ASSIGN":                             "go/token",
+	"token.PACKAGE":                               "go/token",
+	"token.PERIOD":                                "go/token",
+	"token.Pos":                                   "go/token",
+	"token.Position":                              "go/token",
+	"token.QUO":                                   "go/token",
+	"token.QUO_ASSIGN":                            "go/token",
+	"token.RANGE":                                 "go/token",
+	"token.RBRACE":                                "go/token",
+	"token.RBRACK":                                "go/token",
+	"token.REM":                                   "go/token",
+	"token.REM_ASSIGN":                            "go/token",
+	"token.RETURN":                                "go/token",
+	"token.RPAREN":                                "go/token",
+	"token.SELECT":                                "go/token",
+	"token.SEMICOLON":                             "go/token",
+	"token.SHL":                                   "go/token",
+	"token.SHL_ASSIGN":                            "go/token",
+	"token.SHR":                                   "go/token",
+	"token.SHR_ASSIGN":                            "go/token",
+	"token.STRING":                                "go/token",
+	"token.STRUCT":                                "go/token",
+	"token.SUB":                                   "go/token",
+	"token.SUB_ASSIGN":                            "go/token",
+	"token.SWITCH":                                "go/token",
+	"token.TYPE":                                  "go/token",
+	"token.Token":                                 "go/token",
+	"token.UnaryPrec":                             "go/token",
+	"token.VAR":                                   "go/token",
+	"token.XOR":                                   "go/token",
+	"token.XOR_ASSIGN":                            "go/token",
+	"trace.Start":                                 "runtime/trace",
+	"trace.Stop":                                  "runtime/trace",
+	"types.Array":                                 "go/types",
+	"types.AssertableTo":                          "go/types",
+	"types.AssignableTo":                          "go/types",
+	"types.Basic":                                 "go/types",
+	"types.BasicInfo":                             "go/types",
+	"types.BasicKind":                             "go/types",
+	"types.Bool":                                  "go/types",
+	"types.Builtin":                               "go/types",
+	"types.Byte":                                  "go/types",
+	"types.Chan":                                  "go/types",
+	"types.ChanDir":                               "go/types",
+	"types.Checker":                               "go/types",
+	"types.Comparable":                            "go/types",
+	"types.Complex128":                            "go/types",
+	"types.Complex64":                             "go/types",
+	"types.Config":                                "go/types",
+	"types.Const":                                 "go/types",
+	"types.ConvertibleTo":                         "go/types",
+	"types.DefPredeclaredTestFuncs":               "go/types",
+	"types.Default":                               "go/types",
+	"types.Error":                                 "go/types",
+	"types.Eval":                                  "go/types",
+	"types.ExprString":                            "go/types",
+	"types.FieldVal":                              "go/types",
+	"types.Float32":                               "go/types",
+	"types.Float64":                               "go/types",
+	"types.Func":                                  "go/types",
+	"types.Id":                                    "go/types",
+	"types.Identical":                             "go/types",
+	"types.IdenticalIgnoreTags":                   "go/types",
+	"types.Implements":                            "go/types",
+	"types.ImportMode":                            "go/types",
+	"types.Importer":                              "go/types",
+	"types.ImporterFrom":                          "go/types",
+	"types.Info":                                  "go/types",
+	"types.Initializer":                           "go/types",
+	"types.Int":                                   "go/types",
+	"types.Int16":                                 "go/types",
+	"types.Int32":                                 "go/types",
+	"types.Int64":                                 "go/types",
+	"types.Int8":                                  "go/types",
+	"types.Interface":                             "go/types",
+	"types.Invalid":                               "go/types",
+	"types.IsBoolean":                             "go/types",
+	"types.IsComplex":                             "go/types",
+	"types.IsConstType":                           "go/types",
+	"types.IsFloat":                               "go/types",
+	"types.IsInteger":                             "go/types",
+	"types.IsInterface":                           "go/types",
+	"types.IsNumeric":                             "go/types",
+	"types.IsOrdered":                             "go/types",
+	"types.IsString":                              "go/types",
+	"types.IsUnsigned":                            "go/types",
+	"types.IsUntyped":                             "go/types",
+	"types.Label":                                 "go/types",
+	"types.LookupFieldOrMethod":                   "go/types",
+	"types.Map":                                   "go/types",
+	"types.MethodExpr":                            "go/types",
+	"types.MethodSet":                             "go/types",
+	"types.MethodVal":                             "go/types",
+	"types.MissingMethod":                         "go/types",
+	"types.Named":                                 "go/types",
+	"types.NewArray":                              "go/types",
+	"types.NewChan":                               "go/types",
+	"types.NewChecker":                            "go/types",
+	"types.NewConst":                              "go/types",
+	"types.NewField":                              "go/types",
+	"types.NewFunc":                               "go/types",
+	"types.NewInterface":                          "go/types",
+	"types.NewLabel":                              "go/types",
+	"types.NewMap":                                "go/types",
+	"types.NewMethodSet":                          "go/types",
+	"types.NewNamed":                              "go/types",
+	"types.NewPackage":                            "go/types",
+	"types.NewParam":                              "go/types",
+	"types.NewPkgName":                            "go/types",
+	"types.NewPointer":                            "go/types",
+	"types.NewScope":                              "go/types",
+	"types.NewSignature":                          "go/types",
+	"types.NewSlice":                              "go/types",
+	"types.NewStruct":                             "go/types",
+	"types.NewTuple":                              "go/types",
+	"types.NewTypeName":                           "go/types",
+	"types.NewVar":                                "go/types",
+	"types.Nil":                                   "go/types",
+	"types.ObjectString":                          "go/types",
+	"types.Package":                               "go/types",
+	"types.PkgName":                               "go/types",
+	"types.Pointer":                               "go/types",
+	"types.Qualifier":                             "go/types",
+	"types.RecvOnly":                              "go/types",
+	"types.RelativeTo":                            "go/types",
+	"types.Rune":                                  "go/types",
+	"types.Scope":                                 "go/types",
+	"types.Selection":                             "go/types",
+	"types.SelectionKind":                         "go/types",
+	"types.SelectionString":                       "go/types",
+	"types.SendOnly":                              "go/types",
+	"types.SendRecv":                              "go/types",
+	"types.Signature":                             "go/types",
+	"types.Sizes":                                 "go/types",
+	"types.SizesFor":                              "go/types",
+	"types.Slice":                                 "go/types",
+	"types.StdSizes":                              "go/types",
+	"types.String":                                "go/types",
+	"types.Struct":                                "go/types",
+	"types.Tuple":                                 "go/types",
+	"types.Typ":                                   "go/types",
+	"types.Type":                                  "go/types",
+	"types.TypeAndValue":                          "go/types",
+	"types.TypeName":                              "go/types",
+	"types.TypeString":                            "go/types",
+	"types.Uint":                                  "go/types",
+	"types.Uint16":                                "go/types",
+	"types.Uint32":                                "go/types",
+	"types.Uint64":                                "go/types",
+	"types.Uint8":                                 "go/types",
+	"types.Uintptr":                               "go/types",
+	"types.Universe":                              "go/types",
+	"types.Unsafe":                                "go/types",
+	"types.UnsafePointer":                         "go/types",
+	"types.UntypedBool":                           "go/types",
+	"types.UntypedComplex":                        "go/types",
+	"types.UntypedFloat":                          "go/types",
+	"types.UntypedInt":                            "go/types",
+	"types.UntypedNil":                            "go/types",
+	"types.UntypedRune":                           "go/types",
+	"types.UntypedString":                         "go/types",
+	"types.Var":                                   "go/types",
+	"types.WriteExpr":                             "go/types",
+	"types.WriteSignature":                        "go/types",
+	"types.WriteType":                             "go/types",
+	"unicode.ASCII_Hex_Digit":                     "unicode",
+	"unicode.Adlam":                               "unicode",
+	"unicode.Ahom":                                "unicode",
+	"unicode.Anatolian_Hieroglyphs":               "unicode",
+	"unicode.Arabic":                              "unicode",
+	"unicode.Armenian":                            "unicode",
+	"unicode.Avestan":                             "unicode",
+	"unicode.AzeriCase":                           "unicode",
+	"unicode.Balinese":                            "unicode",
+	"unicode.Bamum":                               "unicode",
+	"unicode.Bassa_Vah":                           "unicode",
+	"unicode.Batak":                               "unicode",
+	"unicode.Bengali":                             "unicode",
+	"unicode.Bhaiksuki":                           "unicode",
+	"unicode.Bidi_Control":                        "unicode",
+	"unicode.Bopomofo":                            "unicode",
+	"unicode.Brahmi":                              "unicode",
+	"unicode.Braille":                             "unicode",
+	"unicode.Buginese":                            "unicode",
+	"unicode.Buhid":                               "unicode",
+	"unicode.C":                                   "unicode",
+	"unicode.Canadian_Aboriginal":                 "unicode",
+	"unicode.Carian":                              "unicode",
+	"unicode.CaseRange":                           "unicode",
+	"unicode.CaseRanges":                          "unicode",
+	"unicode.Categories":                          "unicode",
+	"unicode.Caucasian_Albanian":                  "unicode",
+	"unicode.Cc":                                  "unicode",
+	"unicode.Cf":                                  "unicode",
+	"unicode.Chakma":                              "unicode",
+	"unicode.Cham":                                "unicode",
+	"unicode.Cherokee":                            "unicode",
+	"unicode.Co":                                  "unicode",
+	"unicode.Common":                              "unicode",
+	"unicode.Coptic":                              "unicode",
+	"unicode.Cs":                                  "unicode",
+	"unicode.Cuneiform":                           "unicode",
+	"unicode.Cypriot":                             "unicode",
+	"unicode.Cyrillic":                            "unicode",
+	"unicode.Dash":                                "unicode",
+	"unicode.Deprecated":                          "unicode",
+	"unicode.Deseret":                             "unicode",
+	"unicode.Devanagari":                          "unicode",
+	"unicode.Diacritic":                           "unicode",
+	"unicode.Digit":                               "unicode",
+	"unicode.Duployan":                            "unicode",
+	"unicode.Egyptian_Hieroglyphs":                "unicode",
+	"unicode.Elbasan":                             "unicode",
+	"unicode.Ethiopic":                            "unicode",
+	"unicode.Extender":                            "unicode",
+	"unicode.FoldCategory":                        "unicode",
+	"unicode.FoldScript":                          "unicode",
+	"unicode.Georgian":                            "unicode",
+	"unicode.Glagolitic":                          "unicode",
+	"unicode.Gothic":                              "unicode",
+	"unicode.Grantha":                             "unicode",
+	"unicode.GraphicRanges":                       "unicode",
+	"unicode.Greek":                               "unicode",
+	"unicode.Gujarati":                            "unicode",
+	"unicode.Gurmukhi":                            "unicode",
+	"unicode.Han":                                 "unicode",
+	"unicode.Hangul":                              "unicode",
+	"unicode.Hanunoo":                             "unicode",
+	"unicode.Hatran":                              "unicode",
+	"unicode.Hebrew":                              "unicode",
+	"unicode.Hex_Digit":                           "unicode",
+	"unicode.Hiragana":                            "unicode",
+	"unicode.Hyphen":                              "unicode",
+	"unicode.IDS_Binary_Operator":                 "unicode",
+	"unicode.IDS_Trinary_Operator":                "unicode",
+	"unicode.Ideographic":                         "unicode",
+	"unicode.Imperial_Aramaic":                    "unicode",
+	"unicode.In":                                  "unicode",
+	"unicode.Inherited":                           "unicode",
+	"unicode.Inscriptional_Pahlavi":               "unicode",
+	"unicode.Inscriptional_Parthian":              "unicode",
+	"unicode.Is":                                  "unicode",
+	"unicode.IsControl":                           "unicode",
+	"unicode.IsDigit":                             "unicode",
+	"unicode.IsGraphic":                           "unicode",
+	"unicode.IsLetter":                            "unicode",
+	"unicode.IsLower":                             "unicode",
+	"unicode.IsMark":                              "unicode",
+	"unicode.IsNumber":                            "unicode",
+	"unicode.IsOneOf":                             "unicode",
+	"unicode.IsPrint":                             "unicode",
+	"unicode.IsPunct":                             "unicode",
+	"unicode.IsSpace":                             "unicode",
+	"unicode.IsSymbol":                            "unicode",
+	"unicode.IsTitle":                             "unicode",
+	"unicode.IsUpper":                             "unicode",
+	"unicode.Javanese":                            "unicode",
+	"unicode.Join_Control":                        "unicode",
+	"unicode.Kaithi":                              "unicode",
+	"unicode.Kannada":                             "unicode",
+	"unicode.Katakana":                            "unicode",
+	"unicode.Kayah_Li":                            "unicode",
+	"unicode.Kharoshthi":                          "unicode",
+	"unicode.Khmer":                               "unicode",
+	"unicode.Khojki":                              "unicode",
+	"unicode.Khudawadi":                           "unicode",
+	"unicode.L":                                   "unicode",
+	"unicode.Lao":                                 "unicode",
+	"unicode.Latin":                               "unicode",
+	"unicode.Lepcha":                              "unicode",
+	"unicode.Letter":                              "unicode",
+	"unicode.Limbu":                               "unicode",
+	"unicode.Linear_A":                            "unicode",
+	"unicode.Linear_B":                            "unicode",
+	"unicode.Lisu":                                "unicode",
+	"unicode.Ll":                                  "unicode",
+	"unicode.Lm":                                  "unicode",
+	"unicode.Lo":                                  "unicode",
+	"unicode.Logical_Order_Exception":             "unicode",
+	"unicode.Lower":                               "unicode",
+	"unicode.LowerCase":                           "unicode",
+	"unicode.Lt":                                  "unicode",
+	"unicode.Lu":                                  "unicode",
+	"unicode.Lycian":                              "unicode",
+	"unicode.Lydian":                              "unicode",
+	"unicode.M":                                   "unicode",
+	"unicode.Mahajani":                            "unicode",
+	"unicode.Malayalam":                           "unicode",
+	"unicode.Mandaic":                             "unicode",
+	"unicode.Manichaean":                          "unicode",
+	"unicode.Marchen":                             "unicode",
+	"unicode.Mark":                                "unicode",
+	"unicode.MaxASCII":                            "unicode",
+	"unicode.MaxCase":                             "unicode",
+	"unicode.MaxLatin1":                           "unicode",
+	"unicode.MaxRune":                             "unicode",
+	"unicode.Mc":                                  "unicode",
+	"unicode.Me":                                  "unicode",
+	"unicode.Meetei_Mayek":                        "unicode",
+	"unicode.Mende_Kikakui":                       "unicode",
+	"unicode.Meroitic_Cursive":                    "unicode",
+	"unicode.Meroitic_Hieroglyphs":                "unicode",
+	"unicode.Miao":                                "unicode",
+	"unicode.Mn":                                  "unicode",
+	"unicode.Modi":                                "unicode",
+	"unicode.Mongolian":                           "unicode",
+	"unicode.Mro":                                 "unicode",
+	"unicode.Multani":                             "unicode",
+	"unicode.Myanmar":                             "unicode",
+	"unicode.N":                                   "unicode",
+	"unicode.Nabataean":                           "unicode",
+	"unicode.Nd":                                  "unicode",
+	"unicode.New_Tai_Lue":                         "unicode",
+	"unicode.Newa":                                "unicode",
+	"unicode.Nko":                                 "unicode",
+	"unicode.Nl":                                  "unicode",
+	"unicode.No":                                  "unicode",
+	"unicode.Noncharacter_Code_Point":             "unicode",
+	"unicode.Number":                              "unicode",
+	"unicode.Ogham":                               "unicode",
+	"unicode.Ol_Chiki":                            "unicode",
+	"unicode.Old_Hungarian":                       "unicode",
+	"unicode.Old_Italic":                          "unicode",
+	"unicode.Old_North_Arabian":                   "unicode",
+	"unicode.Old_Permic":                          "unicode",
+	"unicode.Old_Persian":                         "unicode",
+	"unicode.Old_South_Arabian":                   "unicode",
+	"unicode.Old_Turkic":                          "unicode",
+	"unicode.Oriya":                               "unicode",
+	"unicode.Osage":                               "unicode",
+	"unicode.Osmanya":                             "unicode",
+	"unicode.Other":                               "unicode",
+	"unicode.Other_Alphabetic":                    "unicode",
+	"unicode.Other_Default_Ignorable_Code_Point":  "unicode",
+	"unicode.Other_Grapheme_Extend":               "unicode",
+	"unicode.Other_ID_Continue":                   "unicode",
+	"unicode.Other_ID_Start":                      "unicode",
+	"unicode.Other_Lowercase":                     "unicode",
+	"unicode.Other_Math":                          "unicode",
+	"unicode.Other_Uppercase":                     "unicode",
+	"unicode.P":                                   "unicode",
+	"unicode.Pahawh_Hmong":                        "unicode",
+	"unicode.Palmyrene":                           "unicode",
+	"unicode.Pattern_Syntax":                      "unicode",
+	"unicode.Pattern_White_Space":                 "unicode",
+	"unicode.Pau_Cin_Hau":                         "unicode",
+	"unicode.Pc":                                  "unicode",
+	"unicode.Pd":                                  "unicode",
+	"unicode.Pe":                                  "unicode",
+	"unicode.Pf":                                  "unicode",
+	"unicode.Phags_Pa":                            "unicode",
+	"unicode.Phoenician":                          "unicode",
+	"unicode.Pi":                                  "unicode",
+	"unicode.Po":                                  "unicode",
+	"unicode.Prepended_Concatenation_Mark":        "unicode",
+	"unicode.PrintRanges":                         "unicode",
+	"unicode.Properties":                          "unicode",
+	"unicode.Ps":                                  "unicode",
+	"unicode.Psalter_Pahlavi":                     "unicode",
+	"unicode.Punct":                               "unicode",
+	"unicode.Quotation_Mark":                      "unicode",
+	"unicode.Radical":                             "unicode",
+	"unicode.Range16":                             "unicode",
+	"unicode.Range32":                             "unicode",
+	"unicode.RangeTable":                          "unicode",
+	"unicode.Rejang":                              "unicode",
+	"unicode.ReplacementChar":                     "unicode",
+	"unicode.Runic":                               "unicode",
+	"unicode.S":                                   "unicode",
+	"unicode.STerm":                               "unicode",
+	"unicode.Samaritan":                           "unicode",
+	"unicode.Saurashtra":                          "unicode",
+	"unicode.Sc":                                  "unicode",
+	"unicode.Scripts":                             "unicode",
+	"unicode.Sentence_Terminal":                   "unicode",
+	"unicode.Sharada":                             "unicode",
+	"unicode.Shavian":                             "unicode",
+	"unicode.Siddham":                             "unicode",
+	"unicode.SignWriting":                         "unicode",
+	"unicode.SimpleFold":                          "unicode",
+	"unicode.Sinhala":                             "unicode",
+	"unicode.Sk":                                  "unicode",
+	"unicode.Sm":                                  "unicode",
+	"unicode.So":                                  "unicode",
+	"unicode.Soft_Dotted":                         "unicode",
+	"unicode.Sora_Sompeng":                        "unicode",
+	"unicode.Space":                               "unicode",
+	"unicode.SpecialCase":                         "unicode",
+	"unicode.Sundanese":                           "unicode",
+	"unicode.Syloti_Nagri":                        "unicode",
+	"unicode.Symbol":                              "unicode",
+	"unicode.Syriac":                              "unicode",
+	"unicode.Tagalog":                             "unicode",
+	"unicode.Tagbanwa":                            "unicode",
+	"unicode.Tai_Le":                              "unicode",
+	"unicode.Tai_Tham":                            "unicode",
+	"unicode.Tai_Viet":                            "unicode",
+	"unicode.Takri":                               "unicode",
+	"unicode.Tamil":                               "unicode",
+	"unicode.Tangut":                              "unicode",
+	"unicode.Telugu":                              "unicode",
+	"unicode.Terminal_Punctuation":                "unicode",
+	"unicode.Thaana":                              "unicode",
+	"unicode.Thai":                                "unicode",
+	"unicode.Tibetan":                             "unicode",
+	"unicode.Tifinagh":                            "unicode",
+	"unicode.Tirhuta":                             "unicode",
+	"unicode.Title":                               "unicode",
+	"unicode.TitleCase":                           "unicode",
+	"unicode.To":                                  "unicode",
+	"unicode.ToLower":                             "unicode",
+	"unicode.ToTitle":                             "unicode",
+	"unicode.ToUpper":                             "unicode",
+	"unicode.TurkishCase":                         "unicode",
+	"unicode.Ugaritic":                            "unicode",
+	"unicode.Unified_Ideograph":                   "unicode",
+	"unicode.Upper":                               "unicode",
+	"unicode.UpperCase":                           "unicode",
+	"unicode.UpperLower":                          "unicode",
+	"unicode.Vai":                                 "unicode",
+	"unicode.Variation_Selector":                  "unicode",
+	"unicode.Version":                             "unicode",
+	"unicode.Warang_Citi":                         "unicode",
+	"unicode.White_Space":                         "unicode",
+	"unicode.Yi":                                  "unicode",
+	"unicode.Z":                                   "unicode",
+	"unicode.Zl":                                  "unicode",
+	"unicode.Zp":                                  "unicode",
+	"unicode.Zs":                                  "unicode",
+	"url.Error":                                   "net/url",
+	"url.EscapeError":                             "net/url",
+	"url.InvalidHostError":                        "net/url",
+	"url.Parse":                                   "net/url",
+	"url.ParseQuery":                              "net/url",
+	"url.ParseRequestURI":                         "net/url",
+	"url.PathEscape":                              "net/url",
+	"url.PathUnescape":                            "net/url",
+	"url.QueryEscape":                             "net/url",
+	"url.QueryUnescape":                           "net/url",
+	"url.URL":                                     "net/url",
+	"url.User":                                    "net/url",
+	"url.UserPassword":                            "net/url",
+	"url.Userinfo":                                "net/url",
+	"url.Values":                                  "net/url",
+	"user.Current":                                "os/user",
+	"user.Group":                                  "os/user",
+	"user.Lookup":                                 "os/user",
+	"user.LookupGroup":                            "os/user",
+	"user.LookupGroupId":                          "os/user",
+	"user.LookupId":                               "os/user",
+	"user.UnknownGroupError":                      "os/user",
+	"user.UnknownGroupIdError":                    "os/user",
+	"user.UnknownUserError":                       "os/user",
+	"user.UnknownUserIdError":                     "os/user",
+	"user.User":                                   "os/user",
+	"utf16.Decode":                                "unicode/utf16",
+	"utf16.DecodeRune":                            "unicode/utf16",
+	"utf16.Encode":                                "unicode/utf16",
+	"utf16.EncodeRune":                            "unicode/utf16",
+	"utf16.IsSurrogate":                           "unicode/utf16",
+	"utf8.DecodeLastRune":                         "unicode/utf8",
+	"utf8.DecodeLastRuneInString":                 "unicode/utf8",
+	"utf8.DecodeRune":                             "unicode/utf8",
+	"utf8.DecodeRuneInString":                     "unicode/utf8",
+	"utf8.EncodeRune":                             "unicode/utf8",
+	"utf8.FullRune":                               "unicode/utf8",
+	"utf8.FullRuneInString":                       "unicode/utf8",
+	"utf8.MaxRune":                                "unicode/utf8",
+	"utf8.RuneCount":                              "unicode/utf8",
+	"utf8.RuneCountInString":                      "unicode/utf8",
+	"utf8.RuneError":                              "unicode/utf8",
+	"utf8.RuneLen":                                "unicode/utf8",
+	"utf8.RuneSelf":                               "unicode/utf8",
+	"utf8.RuneStart":                              "unicode/utf8",
+	"utf8.UTFMax":                                 "unicode/utf8",
+	"utf8.Valid":                                  "unicode/utf8",
+	"utf8.ValidRune":                              "unicode/utf8",
+	"utf8.ValidString":                            "unicode/utf8",
+	"x509.CANotAuthorizedForThisName":             "crypto/x509",
+	"x509.CertPool":                               "crypto/x509",
+	"x509.Certificate":                            "crypto/x509",
+	"x509.CertificateInvalidError":                "crypto/x509",
+	"x509.CertificateRequest":                     "crypto/x509",
+	"x509.ConstraintViolationError":               "crypto/x509",
+	"x509.CreateCertificate":                      "crypto/x509",
+	"x509.CreateCertificateRequest":               "crypto/x509",
+	"x509.DSA":                                    "crypto/x509",
+	"x509.DSAWithSHA1":                            "crypto/x509",
+	"x509.DSAWithSHA256":                          "crypto/x509",
+	"x509.DecryptPEMBlock":                        "crypto/x509",
+	"x509.ECDSA":                                  "crypto/x509",
+	"x509.ECDSAWithSHA1":                          "crypto/x509",
+	"x509.ECDSAWithSHA256":                        "crypto/x509",
+	"x509.ECDSAWithSHA384":                        "crypto/x509",
+	"x509.ECDSAWithSHA512":                        "crypto/x509",
+	"x509.EncryptPEMBlock":                        "crypto/x509",
+	"x509.ErrUnsupportedAlgorithm":                "crypto/x509",
+	"x509.Expired":                                "crypto/x509",
+	"x509.ExtKeyUsage":                            "crypto/x509",
+	"x509.ExtKeyUsageAny":                         "crypto/x509",
+	"x509.ExtKeyUsageClientAuth":                  "crypto/x509",
+	"x509.ExtKeyUsageCodeSigning":                 "crypto/x509",
+	"x509.ExtKeyUsageEmailProtection":             "crypto/x509",
+	"x509.ExtKeyUsageIPSECEndSystem":              "crypto/x509",
+	"x509.ExtKeyUsageIPSECTunnel":                 "crypto/x509",
+	"x509.ExtKeyUsageIPSECUser":                   "crypto/x509",
+	"x509.ExtKeyUsageMicrosoftServerGatedCrypto":  "crypto/x509",
+	"x509.ExtKeyUsageNetscapeServerGatedCrypto":   "crypto/x509",
+	"x509.ExtKeyUsageOCSPSigning":                 "crypto/x509",
+	"x509.ExtKeyUsageServerAuth":                  "crypto/x509",
+	"x509.ExtKeyUsageTimeStamping":                "crypto/x509",
+	"x509.HostnameError":                          "crypto/x509",
+	"x509.IncompatibleUsage":                      "crypto/x509",
+	"x509.IncorrectPasswordError":                 "crypto/x509",
+	"x509.InsecureAlgorithmError":                 "crypto/x509",
+	"x509.InvalidReason":                          "crypto/x509",
+	"x509.IsEncryptedPEMBlock":                    "crypto/x509",
+	"x509.KeyUsage":                               "crypto/x509",
+	"x509.KeyUsageCRLSign":                        "crypto/x509",
+	"x509.KeyUsageCertSign":                       "crypto/x509",
+	"x509.KeyUsageContentCommitment":              "crypto/x509",
+	"x509.KeyUsageDataEncipherment":               "crypto/x509",
+	"x509.KeyUsageDecipherOnly":                   "crypto/x509",
+	"x509.KeyUsageDigitalSignature":               "crypto/x509",
+	"x509.KeyUsageEncipherOnly":                   "crypto/x509",
+	"x509.KeyUsageKeyAgreement":                   "crypto/x509",
+	"x509.KeyUsageKeyEncipherment":                "crypto/x509",
+	"x509.MD2WithRSA":                             "crypto/x509",
+	"x509.MD5WithRSA":                             "crypto/x509",
+	"x509.MarshalECPrivateKey":                    "crypto/x509",
+	"x509.MarshalPKCS1PrivateKey":                 "crypto/x509",
+	"x509.MarshalPKIXPublicKey":                   "crypto/x509",
+	"x509.NameMismatch":                           "crypto/x509",
+	"x509.NewCertPool":                            "crypto/x509",
+	"x509.NotAuthorizedToSign":                    "crypto/x509",
+	"x509.PEMCipher":                              "crypto/x509",
+	"x509.PEMCipher3DES":                          "crypto/x509",
+	"x509.PEMCipherAES128":                        "crypto/x509",
+	"x509.PEMCipherAES192":                        "crypto/x509",
+	"x509.PEMCipherAES256":                        "crypto/x509",
+	"x509.PEMCipherDES":                           "crypto/x509",
+	"x509.ParseCRL":                               "crypto/x509",
+	"x509.ParseCertificate":                       "crypto/x509",
+	"x509.ParseCertificateRequest":                "crypto/x509",
+	"x509.ParseCertificates":                      "crypto/x509",
+	"x509.ParseDERCRL":                            "crypto/x509",
+	"x509.ParseECPrivateKey":                      "crypto/x509",
+	"x509.ParsePKCS1PrivateKey":                   "crypto/x509",
+	"x509.ParsePKCS8PrivateKey":                   "crypto/x509",
+	"x509.ParsePKIXPublicKey":                     "crypto/x509",
+	"x509.PublicKeyAlgorithm":                     "crypto/x509",
+	"x509.RSA":                                    "crypto/x509",
+	"x509.SHA1WithRSA":                            "crypto/x509",
+	"x509.SHA256WithRSA":                          "crypto/x509",
+	"x509.SHA256WithRSAPSS":                       "crypto/x509",
+	"x509.SHA384WithRSA":                          "crypto/x509",
+	"x509.SHA384WithRSAPSS":                       "crypto/x509",
+	"x509.SHA512WithRSA":                          "crypto/x509",
+	"x509.SHA512WithRSAPSS":                       "crypto/x509",
+	"x509.SignatureAlgorithm":                     "crypto/x509",
+	"x509.SystemCertPool":                         "crypto/x509",
+	"x509.SystemRootsError":                       "crypto/x509",
+	"x509.TooManyIntermediates":                   "crypto/x509",
+	"x509.UnhandledCriticalExtension":             "crypto/x509",
+	"x509.UnknownAuthorityError":                  "crypto/x509",
+	"x509.UnknownPublicKeyAlgorithm":              "crypto/x509",
+	"x509.UnknownSignatureAlgorithm":              "crypto/x509",
+	"x509.VerifyOptions":                          "crypto/x509",
+	"xml.Attr":                                    "encoding/xml",
+	"xml.CharData":                                "encoding/xml",
+	"xml.Comment":                                 "encoding/xml",
+	"xml.CopyToken":                               "encoding/xml",
+	"xml.Decoder":                                 "encoding/xml",
+	"xml.Directive":                               "encoding/xml",
+	"xml.Encoder":                                 "encoding/xml",
+	"xml.EndElement":                              "encoding/xml",
+	"xml.Escape":                                  "encoding/xml",
+	"xml.EscapeText":                              "encoding/xml",
+	"xml.HTMLAutoClose":                           "encoding/xml",
+	"xml.HTMLEntity":                              "encoding/xml",
+	"xml.Header":                                  "encoding/xml",
+	"xml.Marshal":                                 "encoding/xml",
+	"xml.MarshalIndent":                           "encoding/xml",
+	"xml.Marshaler":                               "encoding/xml",
+	"xml.MarshalerAttr":                           "encoding/xml",
+	"xml.Name":                                    "encoding/xml",
+	"xml.NewDecoder":                              "encoding/xml",
+	"xml.NewEncoder":                              "encoding/xml",
+	"xml.ProcInst":                                "encoding/xml",
+	"xml.StartElement":                            "encoding/xml",
+	"xml.SyntaxError":                             "encoding/xml",
+	"xml.TagPathError":                            "encoding/xml",
+	"xml.Token":                                   "encoding/xml",
+	"xml.Unmarshal":                               "encoding/xml",
+	"xml.UnmarshalError":                          "encoding/xml",
+	"xml.Unmarshaler":                             "encoding/xml",
+	"xml.UnmarshalerAttr":                         "encoding/xml",
+	"xml.UnsupportedTypeError":                    "encoding/xml",
+	"zip.Compressor":                              "archive/zip",
+	"zip.Decompressor":                            "archive/zip",
+	"zip.Deflate":                                 "archive/zip",
+	"zip.ErrAlgorithm":                            "archive/zip",
+	"zip.ErrChecksum":                             "archive/zip",
+	"zip.ErrFormat":                               "archive/zip",
+	"zip.File":                                    "archive/zip",
+	"zip.FileHeader":                              "archive/zip",
+	"zip.FileInfoHeader":                          "archive/zip",
+	"zip.NewReader":                               "archive/zip",
+	"zip.NewWriter":                               "archive/zip",
+	"zip.OpenReader":                              "archive/zip",
+	"zip.ReadCloser":                              "archive/zip",
+	"zip.Reader":                                  "archive/zip",
+	"zip.RegisterCompressor":                      "archive/zip",
+	"zip.RegisterDecompressor":                    "archive/zip",
+	"zip.Store":                                   "archive/zip",
+	"zip.Writer":                                  "archive/zip",
+	"zlib.BestCompression":                        "compress/zlib",
+	"zlib.BestSpeed":                              "compress/zlib",
+	"zlib.DefaultCompression":                     "compress/zlib",
+	"zlib.ErrChecksum":                            "compress/zlib",
+	"zlib.ErrDictionary":                          "compress/zlib",
+	"zlib.ErrHeader":                              "compress/zlib",
+	"zlib.HuffmanOnly":                            "compress/zlib",
+	"zlib.NewReader":                              "compress/zlib",
+	"zlib.NewReaderDict":                          "compress/zlib",
+	"zlib.NewWriter":                              "compress/zlib",
+	"zlib.NewWriterLevel":                         "compress/zlib",
+	"zlib.NewWriterLevelDict":                     "compress/zlib",
+	"zlib.NoCompression":                          "compress/zlib",
+	"zlib.Resetter":                               "compress/zlib",
+	"zlib.Writer":                                 "compress/zlib",
+
+	"unsafe.Alignof":       "unsafe",
+	"unsafe.ArbitraryType": "unsafe",
+	"unsafe.Offsetof":      "unsafe",
+	"unsafe.Pointer":       "unsafe",
+	"unsafe.Sizeof":        "unsafe",
+}
diff --git a/vendor/google.golang.org/appengine/CONTRIBUTING.md b/vendor/google.golang.org/appengine/CONTRIBUTING.md
deleted file mode 100644
index ffc298520856c81429f7731cacdf0cf08314cad8..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/CONTRIBUTING.md
+++ /dev/null
@@ -1,90 +0,0 @@
-# Contributing
-
-1. Sign one of the contributor license agreements below.
-1. Get the package:
-
-    `go get -d google.golang.org/appengine`
-1. Change into the checked out source:
-
-    `cd $GOPATH/src/google.golang.org/appengine`
-1. Fork the repo.
-1. Set your fork as a remote:
-
-    `git remote add fork git@github.com:GITHUB_USERNAME/appengine.git`
-1. Make changes, commit to your fork.
-1. Send a pull request with your changes. 
-   The first line of your commit message is conventionally a one-line summary of the change, prefixed by the primary affected package, and is used as the title of your pull request.
-
-# Testing
-
-## Running system tests
-
-Download and install the [Go App Engine SDK](https://cloud.google.com/appengine/docs/go/download). Make sure the `go_appengine` dir is in your `PATH`.
-
-Set the `APPENGINE_DEV_APPSERVER` environment variable to `/path/to/go_appengine/dev_appserver.py`.
-
-Run tests with `goapp test`:
-
-```
-goapp test -v google.golang.org/appengine/...
-```
-
-## Contributor License Agreements
-
-Before we can accept your pull requests you'll need to sign a Contributor
-License Agreement (CLA):
-
-- **If you are an individual writing original source code** and **you own the
-intellectual property**, then you'll need to sign an [individual CLA][indvcla].
-- **If you work for a company that wants to allow you to contribute your work**,
-then you'll need to sign a [corporate CLA][corpcla].
-
-You can sign these electronically (just scroll to the bottom). After that,
-we'll be able to accept your pull requests.
-
-## Contributor Code of Conduct
-
-As contributors and maintainers of this project,
-and in the interest of fostering an open and welcoming community,
-we pledge to respect all people who contribute through reporting issues,
-posting feature requests, updating documentation,
-submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project
-a harassment-free experience for everyone,
-regardless of level of experience, gender, gender identity and expression,
-sexual orientation, disability, personal appearance,
-body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information,
-such as physical or electronic
-addresses, without explicit permission
-* Other unethical or unprofessional conduct.
-
-Project maintainers have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct.
-By adopting this Code of Conduct,
-project maintainers commit themselves to fairly and consistently
-applying these principles to every aspect of managing this project.
-Project maintainers who do not follow or enforce the Code of Conduct
-may be permanently removed from the project team.
-
-This code of conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior
-may be reported by opening an issue
-or contacting one or more of the project maintainers.
-
-This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0,
-available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)
-
-[indvcla]: https://developers.google.com/open-source/cla/individual
-[corpcla]: https://developers.google.com/open-source/cla/corporate
diff --git a/vendor/google.golang.org/appengine/LICENSE b/vendor/google.golang.org/appengine/LICENSE
deleted file mode 100644
index d645695673349e3947e8e5ae42332d0ac3164cd7..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/google.golang.org/appengine/README.md b/vendor/google.golang.org/appengine/README.md
deleted file mode 100644
index d86768a2c665b7a299f5e74c7f1bd69f79d308ae..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Go App Engine packages
-
-[![Build Status](https://travis-ci.org/golang/appengine.svg)](https://travis-ci.org/golang/appengine)
-
-This repository supports the Go runtime on *App Engine standard*.
-It provides APIs for interacting with App Engine services.
-Its canonical import path is `google.golang.org/appengine`.
-
-See https://cloud.google.com/appengine/docs/go/
-for more information.
-
-File issue reports and feature requests on the [GitHub's issue
-tracker](https://github.com/golang/appengine/issues).
-
-## Upgrading an App Engine app to the flexible environment
-
-This package does not work on *App Engine flexible*.
-
-There are many differences between the App Engine standard environment and
-the flexible environment.
-
-See the [documentation on upgrading to the flexible environment](https://cloud.google.com/appengine/docs/flexible/go/upgrading).
-
-## Directory structure
-
-The top level directory of this repository is the `appengine` package. It
-contains the
-basic APIs (e.g. `appengine.NewContext`) that apply across APIs. Specific API
-packages are in subdirectories (e.g. `datastore`).
-
-There is an `internal` subdirectory that contains service protocol buffers,
-plus packages required for connectivity to make API calls. App Engine apps
-should not directly import any package under `internal`.
-
-## Updating from legacy (`import "appengine"`) packages
-
-If you're currently using the bare `appengine` packages
-(that is, not these ones, imported via `google.golang.org/appengine`),
-then you can use the `aefix` tool to help automate an upgrade to these packages.
-
-Run `go get google.golang.org/appengine/cmd/aefix` to install it.
-
-### 1. Update import paths
-
-The import paths for App Engine packages are now fully qualified, based at `google.golang.org/appengine`.
-You will need to update your code to use import paths starting with that; for instance,
-code importing `appengine/datastore` will now need to import `google.golang.org/appengine/datastore`.
-
-### 2. Update code using deprecated, removed or modified APIs
-
-Most App Engine services are available with exactly the same API.
-A few APIs were cleaned up, and there are some differences:
-
-* `appengine.Context` has been replaced with the `Context` type from `golang.org/x/net/context`.
-* Logging methods that were on `appengine.Context` are now functions in `google.golang.org/appengine/log`.
-* `appengine.Timeout` has been removed. Use `context.WithTimeout` instead.
-* `appengine.Datacenter` now takes a `context.Context` argument.
-* `datastore.PropertyLoadSaver` has been simplified to use slices in place of channels.
-* `delay.Call` now returns an error.
-* `search.FieldLoadSaver` now handles document metadata.
-* `urlfetch.Transport` no longer has a Deadline field; set a deadline on the
-  `context.Context` instead.
-* `aetest` no longer declares its own Context type, and uses the standard one instead.
-* `taskqueue.QueueStats` no longer takes a maxTasks argument. That argument has been
-  deprecated and unused for a long time.
-* `appengine.BackendHostname` and `appengine.BackendInstance` were for the deprecated backends feature.
-  Use `appengine.ModuleHostname`and `appengine.ModuleName` instead.
-* Most of `appengine/file` and parts of `appengine/blobstore` are deprecated.
-  Use [Google Cloud Storage](https://godoc.org/cloud.google.com/go/storage) if the
-  feature you require is not present in the new
-  [blobstore package](https://google.golang.org/appengine/blobstore).
-* `appengine/socket` is not required on App Engine flexible environment / Managed VMs.
-  Use the standard `net` package instead.
diff --git a/vendor/google.golang.org/appengine/appengine.go b/vendor/google.golang.org/appengine/appengine.go
deleted file mode 100644
index d4f808442b7a735816ab36a987a705352d70eac5..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/appengine.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// Package appengine provides basic functionality for Google App Engine.
-//
-// For more information on how to write Go apps for Google App Engine, see:
-// https://cloud.google.com/appengine/docs/go/
-package appengine // import "google.golang.org/appengine"
-
-import (
-	"net/http"
-
-	"github.com/golang/protobuf/proto"
-	"golang.org/x/net/context"
-
-	"google.golang.org/appengine/internal"
-)
-
-// The gophers party all night; the rabbits provide the beats.
-
-// Main is the principal entry point for an app running in App Engine.
-//
-// On App Engine Flexible it installs a trivial health checker if one isn't
-// already registered, and starts listening on port 8080 (overridden by the
-// $PORT environment variable).
-//
-// See https://cloud.google.com/appengine/docs/flexible/custom-runtimes#health_check_requests
-// for details on how to do your own health checking.
-//
-// On App Engine Standard it ensures the server has started and is prepared to
-// receive requests.
-//
-// Main never returns.
-//
-// Main is designed so that the app's main package looks like this:
-//
-//      package main
-//
-//      import (
-//              "google.golang.org/appengine"
-//
-//              _ "myapp/package0"
-//              _ "myapp/package1"
-//      )
-//
-//      func main() {
-//              appengine.Main()
-//      }
-//
-// The "myapp/packageX" packages are expected to register HTTP handlers
-// in their init functions.
-func Main() {
-	internal.Main()
-}
-
-// IsDevAppServer reports whether the App Engine app is running in the
-// development App Server.
-func IsDevAppServer() bool {
-	return internal.IsDevAppServer()
-}
-
-// NewContext returns a context for an in-flight HTTP request.
-// This function is cheap.
-func NewContext(req *http.Request) context.Context {
-	return WithContext(context.Background(), req)
-}
-
-// WithContext returns a copy of the parent context
-// and associates it with an in-flight HTTP request.
-// This function is cheap.
-func WithContext(parent context.Context, req *http.Request) context.Context {
-	return internal.WithContext(parent, req)
-}
-
-// TODO(dsymonds): Add a Call function here? Otherwise other packages can't access internal.Call.
-
-// BlobKey is a key for a blobstore blob.
-//
-// Conceptually, this type belongs in the blobstore package, but it lives in
-// the appengine package to avoid a circular dependency: blobstore depends on
-// datastore, and datastore needs to refer to the BlobKey type.
-type BlobKey string
-
-// GeoPoint represents a location as latitude/longitude in degrees.
-type GeoPoint struct {
-	Lat, Lng float64
-}
-
-// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude.
-func (g GeoPoint) Valid() bool {
-	return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180
-}
-
-// APICallFunc defines a function type for handling an API call.
-// See WithCallOverride.
-type APICallFunc func(ctx context.Context, service, method string, in, out proto.Message) error
-
-// WithAPICallFunc returns a copy of the parent context
-// that will cause API calls to invoke f instead of their normal operation.
-//
-// This is intended for advanced users only.
-func WithAPICallFunc(ctx context.Context, f APICallFunc) context.Context {
-	return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f))
-}
-
-// APICall performs an API call.
-//
-// This is not intended for general use; it is exported for use in conjunction
-// with WithAPICallFunc.
-func APICall(ctx context.Context, service, method string, in, out proto.Message) error {
-	return internal.Call(ctx, service, method, in, out)
-}
diff --git a/vendor/google.golang.org/appengine/appengine_vm.go b/vendor/google.golang.org/appengine/appengine_vm.go
deleted file mode 100644
index f4b645aad3bec2253adcceb962d661ad87b4e298..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/appengine_vm.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// +build !appengine
-
-package appengine
-
-import (
-	"golang.org/x/net/context"
-
-	"google.golang.org/appengine/internal"
-)
-
-// BackgroundContext returns a context not associated with a request.
-// This should only be used when not servicing a request.
-// This only works in App Engine "flexible environment".
-func BackgroundContext() context.Context {
-	return internal.BackgroundContext()
-}
diff --git a/vendor/google.golang.org/appengine/errors.go b/vendor/google.golang.org/appengine/errors.go
deleted file mode 100644
index 16d0772e2a46b834472dd984aa515a6a05699b90..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/errors.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// This file provides error functions for common API failure modes.
-
-package appengine
-
-import (
-	"fmt"
-
-	"google.golang.org/appengine/internal"
-)
-
-// IsOverQuota reports whether err represents an API call failure
-// due to insufficient available quota.
-func IsOverQuota(err error) bool {
-	callErr, ok := err.(*internal.CallError)
-	return ok && callErr.Code == 4
-}
-
-// MultiError is returned by batch operations when there are errors with
-// particular elements. Errors will be in a one-to-one correspondence with
-// the input elements; successful elements will have a nil entry.
-type MultiError []error
-
-func (m MultiError) Error() string {
-	s, n := "", 0
-	for _, e := range m {
-		if e != nil {
-			if n == 0 {
-				s = e.Error()
-			}
-			n++
-		}
-	}
-	switch n {
-	case 0:
-		return "(0 errors)"
-	case 1:
-		return s
-	case 2:
-		return s + " (and 1 other error)"
-	}
-	return fmt.Sprintf("%s (and %d other errors)", s, n-1)
-}
diff --git a/vendor/google.golang.org/appengine/identity.go b/vendor/google.golang.org/appengine/identity.go
deleted file mode 100644
index b8dcf8f361989d2e89aee584ab8b79088c918fe4..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/identity.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package appengine
-
-import (
-	"time"
-
-	"golang.org/x/net/context"
-
-	"google.golang.org/appengine/internal"
-	pb "google.golang.org/appengine/internal/app_identity"
-	modpb "google.golang.org/appengine/internal/modules"
-)
-
-// AppID returns the application ID for the current application.
-// The string will be a plain application ID (e.g. "appid"), with a
-// domain prefix for custom domain deployments (e.g. "example.com:appid").
-func AppID(c context.Context) string { return internal.AppID(c) }
-
-// DefaultVersionHostname returns the standard hostname of the default version
-// of the current application (e.g. "my-app.appspot.com"). This is suitable for
-// use in constructing URLs.
-func DefaultVersionHostname(c context.Context) string {
-	return internal.DefaultVersionHostname(c)
-}
-
-// ModuleName returns the module name of the current instance.
-func ModuleName(c context.Context) string {
-	return internal.ModuleName(c)
-}
-
-// ModuleHostname returns a hostname of a module instance.
-// If module is the empty string, it refers to the module of the current instance.
-// If version is empty, it refers to the version of the current instance if valid,
-// or the default version of the module of the current instance.
-// If instance is empty, ModuleHostname returns the load-balancing hostname.
-func ModuleHostname(c context.Context, module, version, instance string) (string, error) {
-	req := &modpb.GetHostnameRequest{}
-	if module != "" {
-		req.Module = &module
-	}
-	if version != "" {
-		req.Version = &version
-	}
-	if instance != "" {
-		req.Instance = &instance
-	}
-	res := &modpb.GetHostnameResponse{}
-	if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {
-		return "", err
-	}
-	return *res.Hostname, nil
-}
-
-// VersionID returns the version ID for the current application.
-// It will be of the form "X.Y", where X is specified in app.yaml,
-// and Y is a number generated when each version of the app is uploaded.
-// It does not include a module name.
-func VersionID(c context.Context) string { return internal.VersionID(c) }
-
-// InstanceID returns a mostly-unique identifier for this instance.
-func InstanceID() string { return internal.InstanceID() }
-
-// Datacenter returns an identifier for the datacenter that the instance is running in.
-func Datacenter(c context.Context) string { return internal.Datacenter(c) }
-
-// ServerSoftware returns the App Engine release version.
-// In production, it looks like "Google App Engine/X.Y.Z".
-// In the development appserver, it looks like "Development/X.Y".
-func ServerSoftware() string { return internal.ServerSoftware() }
-
-// RequestID returns a string that uniquely identifies the request.
-func RequestID(c context.Context) string { return internal.RequestID(c) }
-
-// AccessToken generates an OAuth2 access token for the specified scopes on
-// behalf of service account of this application. This token will expire after
-// the returned time.
-func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) {
-	req := &pb.GetAccessTokenRequest{Scope: scopes}
-	res := &pb.GetAccessTokenResponse{}
-
-	err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res)
-	if err != nil {
-		return "", time.Time{}, err
-	}
-	return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil
-}
-
-// Certificate represents a public certificate for the app.
-type Certificate struct {
-	KeyName string
-	Data    []byte // PEM-encoded X.509 certificate
-}
-
-// PublicCertificates retrieves the public certificates for the app.
-// They can be used to verify a signature returned by SignBytes.
-func PublicCertificates(c context.Context) ([]Certificate, error) {
-	req := &pb.GetPublicCertificateForAppRequest{}
-	res := &pb.GetPublicCertificateForAppResponse{}
-	if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil {
-		return nil, err
-	}
-	var cs []Certificate
-	for _, pc := range res.PublicCertificateList {
-		cs = append(cs, Certificate{
-			KeyName: pc.GetKeyName(),
-			Data:    []byte(pc.GetX509CertificatePem()),
-		})
-	}
-	return cs, nil
-}
-
-// ServiceAccount returns a string representing the service account name, in
-// the form of an email address (typically app_id@appspot.gserviceaccount.com).
-func ServiceAccount(c context.Context) (string, error) {
-	req := &pb.GetServiceAccountNameRequest{}
-	res := &pb.GetServiceAccountNameResponse{}
-
-	err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)
-	if err != nil {
-		return "", err
-	}
-	return res.GetServiceAccountName(), err
-}
-
-// SignBytes signs bytes using a private key unique to your application.
-func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) {
-	req := &pb.SignForAppRequest{BytesToSign: bytes}
-	res := &pb.SignForAppResponse{}
-
-	if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {
-		return "", nil, err
-	}
-	return res.GetKeyName(), res.GetSignatureBytes(), nil
-}
-
-func init() {
-	internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name)
-	internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name)
-}
diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go
deleted file mode 100644
index efee06090fc0d0e6776ba97c4541618626ae2601..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/api.go
+++ /dev/null
@@ -1,677 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// +build !appengine
-
-package internal
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/golang/protobuf/proto"
-	netcontext "golang.org/x/net/context"
-
-	basepb "google.golang.org/appengine/internal/base"
-	logpb "google.golang.org/appengine/internal/log"
-	remotepb "google.golang.org/appengine/internal/remote_api"
-)
-
-const (
-	apiPath             = "/rpc_http"
-	defaultTicketSuffix = "/default.20150612t184001.0"
-)
-
-var (
-	// Incoming headers.
-	ticketHeader       = http.CanonicalHeaderKey("X-AppEngine-API-Ticket")
-	dapperHeader       = http.CanonicalHeaderKey("X-Google-DapperTraceInfo")
-	traceHeader        = http.CanonicalHeaderKey("X-Cloud-Trace-Context")
-	curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
-	userIPHeader       = http.CanonicalHeaderKey("X-AppEngine-User-IP")
-	remoteAddrHeader   = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr")
-
-	// Outgoing headers.
-	apiEndpointHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint")
-	apiEndpointHeaderValue = []string{"app-engine-apis"}
-	apiMethodHeader        = http.CanonicalHeaderKey("X-Google-RPC-Service-Method")
-	apiMethodHeaderValue   = []string{"/VMRemoteAPI.CallRemoteAPI"}
-	apiDeadlineHeader      = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline")
-	apiContentType         = http.CanonicalHeaderKey("Content-Type")
-	apiContentTypeValue    = []string{"application/octet-stream"}
-	logFlushHeader         = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count")
-
-	apiHTTPClient = &http.Client{
-		Transport: &http.Transport{
-			Proxy: http.ProxyFromEnvironment,
-			Dial:  limitDial,
-		},
-	}
-
-	defaultTicketOnce sync.Once
-	defaultTicket     string
-)
-
-func apiURL() *url.URL {
-	host, port := "appengine.googleapis.internal", "10001"
-	if h := os.Getenv("API_HOST"); h != "" {
-		host = h
-	}
-	if p := os.Getenv("API_PORT"); p != "" {
-		port = p
-	}
-	return &url.URL{
-		Scheme: "http",
-		Host:   host + ":" + port,
-		Path:   apiPath,
-	}
-}
-
-func handleHTTP(w http.ResponseWriter, r *http.Request) {
-	c := &context{
-		req:       r,
-		outHeader: w.Header(),
-		apiURL:    apiURL(),
-	}
-	stopFlushing := make(chan int)
-
-	ctxs.Lock()
-	ctxs.m[r] = c
-	ctxs.Unlock()
-	defer func() {
-		ctxs.Lock()
-		delete(ctxs.m, r)
-		ctxs.Unlock()
-	}()
-
-	// Patch up RemoteAddr so it looks reasonable.
-	if addr := r.Header.Get(userIPHeader); addr != "" {
-		r.RemoteAddr = addr
-	} else if addr = r.Header.Get(remoteAddrHeader); addr != "" {
-		r.RemoteAddr = addr
-	} else {
-		// Should not normally reach here, but pick a sensible default anyway.
-		r.RemoteAddr = "127.0.0.1"
-	}
-	// The address in the headers will most likely be of these forms:
-	//	123.123.123.123
-	//	2001:db8::1
-	// net/http.Request.RemoteAddr is specified to be in "IP:port" form.
-	if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil {
-		// Assume the remote address is only a host; add a default port.
-		r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80")
-	}
-
-	// Start goroutine responsible for flushing app logs.
-	// This is done after adding c to ctx.m (and stopped before removing it)
-	// because flushing logs requires making an API call.
-	go c.logFlusher(stopFlushing)
-
-	executeRequestSafely(c, r)
-	c.outHeader = nil // make sure header changes aren't respected any more
-
-	stopFlushing <- 1 // any logging beyond this point will be dropped
-
-	// Flush any pending logs asynchronously.
-	c.pendingLogs.Lock()
-	flushes := c.pendingLogs.flushes
-	if len(c.pendingLogs.lines) > 0 {
-		flushes++
-	}
-	c.pendingLogs.Unlock()
-	go c.flushLog(false)
-	w.Header().Set(logFlushHeader, strconv.Itoa(flushes))
-
-	// Avoid nil Write call if c.Write is never called.
-	if c.outCode != 0 {
-		w.WriteHeader(c.outCode)
-	}
-	if c.outBody != nil {
-		w.Write(c.outBody)
-	}
-}
-
-func executeRequestSafely(c *context, r *http.Request) {
-	defer func() {
-		if x := recover(); x != nil {
-			logf(c, 4, "%s", renderPanic(x)) // 4 == critical
-			c.outCode = 500
-		}
-	}()
-
-	http.DefaultServeMux.ServeHTTP(c, r)
-}
-
-func renderPanic(x interface{}) string {
-	buf := make([]byte, 16<<10) // 16 KB should be plenty
-	buf = buf[:runtime.Stack(buf, false)]
-
-	// Remove the first few stack frames:
-	//   this func
-	//   the recover closure in the caller
-	// That will root the stack trace at the site of the panic.
-	const (
-		skipStart  = "internal.renderPanic"
-		skipFrames = 2
-	)
-	start := bytes.Index(buf, []byte(skipStart))
-	p := start
-	for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ {
-		p = bytes.IndexByte(buf[p+1:], '\n') + p + 1
-		if p < 0 {
-			break
-		}
-	}
-	if p >= 0 {
-		// buf[start:p+1] is the block to remove.
-		// Copy buf[p+1:] over buf[start:] and shrink buf.
-		copy(buf[start:], buf[p+1:])
-		buf = buf[:len(buf)-(p+1-start)]
-	}
-
-	// Add panic heading.
-	head := fmt.Sprintf("panic: %v\n\n", x)
-	if len(head) > len(buf) {
-		// Extremely unlikely to happen.
-		return head
-	}
-	copy(buf[len(head):], buf)
-	copy(buf, head)
-
-	return string(buf)
-}
-
-var ctxs = struct {
-	sync.Mutex
-	m  map[*http.Request]*context
-	bg *context // background context, lazily initialized
-	// dec is used by tests to decorate the netcontext.Context returned
-	// for a given request. This allows tests to add overrides (such as
-	// WithAppIDOverride) to the context. The map is nil outside tests.
-	dec map[*http.Request]func(netcontext.Context) netcontext.Context
-}{
-	m: make(map[*http.Request]*context),
-}
-
-// context represents the context of an in-flight HTTP request.
-// It implements the appengine.Context and http.ResponseWriter interfaces.
-type context struct {
-	req *http.Request
-
-	outCode   int
-	outHeader http.Header
-	outBody   []byte
-
-	pendingLogs struct {
-		sync.Mutex
-		lines   []*logpb.UserAppLogLine
-		flushes int
-	}
-
-	apiURL *url.URL
-}
-
-var contextKey = "holds a *context"
-
-// fromContext returns the App Engine context or nil if ctx is not
-// derived from an App Engine context.
-func fromContext(ctx netcontext.Context) *context {
-	c, _ := ctx.Value(&contextKey).(*context)
-	return c
-}
-
-func withContext(parent netcontext.Context, c *context) netcontext.Context {
-	ctx := netcontext.WithValue(parent, &contextKey, c)
-	if ns := c.req.Header.Get(curNamespaceHeader); ns != "" {
-		ctx = withNamespace(ctx, ns)
-	}
-	return ctx
-}
-
-func toContext(c *context) netcontext.Context {
-	return withContext(netcontext.Background(), c)
-}
-
-func IncomingHeaders(ctx netcontext.Context) http.Header {
-	if c := fromContext(ctx); c != nil {
-		return c.req.Header
-	}
-	return nil
-}
-
-func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
-	ctxs.Lock()
-	c := ctxs.m[req]
-	d := ctxs.dec[req]
-	ctxs.Unlock()
-
-	if d != nil {
-		parent = d(parent)
-	}
-
-	if c == nil {
-		// Someone passed in an http.Request that is not in-flight.
-		// We panic here rather than panicking at a later point
-		// so that stack traces will be more sensible.
-		log.Panic("appengine: NewContext passed an unknown http.Request")
-	}
-	return withContext(parent, c)
-}
-
-// DefaultTicket returns a ticket used for background context or dev_appserver.
-func DefaultTicket() string {
-	defaultTicketOnce.Do(func() {
-		if IsDevAppServer() {
-			defaultTicket = "testapp" + defaultTicketSuffix
-			return
-		}
-		appID := partitionlessAppID()
-		escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1)
-		majVersion := VersionID(nil)
-		if i := strings.Index(majVersion, "."); i > 0 {
-			majVersion = majVersion[:i]
-		}
-		defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID())
-	})
-	return defaultTicket
-}
-
-func BackgroundContext() netcontext.Context {
-	ctxs.Lock()
-	defer ctxs.Unlock()
-
-	if ctxs.bg != nil {
-		return toContext(ctxs.bg)
-	}
-
-	// Compute background security ticket.
-	ticket := DefaultTicket()
-
-	ctxs.bg = &context{
-		req: &http.Request{
-			Header: http.Header{
-				ticketHeader: []string{ticket},
-			},
-		},
-		apiURL: apiURL(),
-	}
-
-	// TODO(dsymonds): Wire up the shutdown handler to do a final flush.
-	go ctxs.bg.logFlusher(make(chan int))
-
-	return toContext(ctxs.bg)
-}
-
-// RegisterTestRequest registers the HTTP request req for testing, such that
-// any API calls are sent to the provided URL. It returns a closure to delete
-// the registration.
-// It should only be used by aetest package.
-func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) func() {
-	c := &context{
-		req:    req,
-		apiURL: apiURL,
-	}
-	ctxs.Lock()
-	defer ctxs.Unlock()
-	if _, ok := ctxs.m[req]; ok {
-		log.Panic("req already associated with context")
-	}
-	if _, ok := ctxs.dec[req]; ok {
-		log.Panic("req already associated with context")
-	}
-	if ctxs.dec == nil {
-		ctxs.dec = make(map[*http.Request]func(netcontext.Context) netcontext.Context)
-	}
-	ctxs.m[req] = c
-	ctxs.dec[req] = decorate
-
-	return func() {
-		ctxs.Lock()
-		delete(ctxs.m, req)
-		delete(ctxs.dec, req)
-		ctxs.Unlock()
-	}
-}
-
-var errTimeout = &CallError{
-	Detail:  "Deadline exceeded",
-	Code:    int32(remotepb.RpcError_CANCELLED),
-	Timeout: true,
-}
-
-func (c *context) Header() http.Header { return c.outHeader }
-
-// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status
-// codes do not permit a response body (nor response entity headers such as
-// Content-Length, Content-Type, etc).
-func bodyAllowedForStatus(status int) bool {
-	switch {
-	case status >= 100 && status <= 199:
-		return false
-	case status == 204:
-		return false
-	case status == 304:
-		return false
-	}
-	return true
-}
-
-func (c *context) Write(b []byte) (int, error) {
-	if c.outCode == 0 {
-		c.WriteHeader(http.StatusOK)
-	}
-	if len(b) > 0 && !bodyAllowedForStatus(c.outCode) {
-		return 0, http.ErrBodyNotAllowed
-	}
-	c.outBody = append(c.outBody, b...)
-	return len(b), nil
-}
-
-func (c *context) WriteHeader(code int) {
-	if c.outCode != 0 {
-		logf(c, 3, "WriteHeader called multiple times on request.") // error level
-		return
-	}
-	c.outCode = code
-}
-
-func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) {
-	hreq := &http.Request{
-		Method: "POST",
-		URL:    c.apiURL,
-		Header: http.Header{
-			apiEndpointHeader: apiEndpointHeaderValue,
-			apiMethodHeader:   apiMethodHeaderValue,
-			apiContentType:    apiContentTypeValue,
-			apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
-		},
-		Body:          ioutil.NopCloser(bytes.NewReader(body)),
-		ContentLength: int64(len(body)),
-		Host:          c.apiURL.Host,
-	}
-	if info := c.req.Header.Get(dapperHeader); info != "" {
-		hreq.Header.Set(dapperHeader, info)
-	}
-	if info := c.req.Header.Get(traceHeader); info != "" {
-		hreq.Header.Set(traceHeader, info)
-	}
-
-	tr := apiHTTPClient.Transport.(*http.Transport)
-
-	var timedOut int32 // atomic; set to 1 if timed out
-	t := time.AfterFunc(timeout, func() {
-		atomic.StoreInt32(&timedOut, 1)
-		tr.CancelRequest(hreq)
-	})
-	defer t.Stop()
-	defer func() {
-		// Check if timeout was exceeded.
-		if atomic.LoadInt32(&timedOut) != 0 {
-			err = errTimeout
-		}
-	}()
-
-	hresp, err := apiHTTPClient.Do(hreq)
-	if err != nil {
-		return nil, &CallError{
-			Detail: fmt.Sprintf("service bridge HTTP failed: %v", err),
-			Code:   int32(remotepb.RpcError_UNKNOWN),
-		}
-	}
-	defer hresp.Body.Close()
-	hrespBody, err := ioutil.ReadAll(hresp.Body)
-	if hresp.StatusCode != 200 {
-		return nil, &CallError{
-			Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody),
-			Code:   int32(remotepb.RpcError_UNKNOWN),
-		}
-	}
-	if err != nil {
-		return nil, &CallError{
-			Detail: fmt.Sprintf("service bridge response bad: %v", err),
-			Code:   int32(remotepb.RpcError_UNKNOWN),
-		}
-	}
-	return hrespBody, nil
-}
-
-func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
-	if ns := NamespaceFromContext(ctx); ns != "" {
-		if fn, ok := NamespaceMods[service]; ok {
-			fn(in, ns)
-		}
-	}
-
-	if f, ctx, ok := callOverrideFromContext(ctx); ok {
-		return f(ctx, service, method, in, out)
-	}
-
-	// Handle already-done contexts quickly.
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
-	c := fromContext(ctx)
-	if c == nil {
-		// Give a good error message rather than a panic lower down.
-		return errNotAppEngineContext
-	}
-
-	// Apply transaction modifications if we're in a transaction.
-	if t := transactionFromContext(ctx); t != nil {
-		if t.finished {
-			return errors.New("transaction context has expired")
-		}
-		applyTransaction(in, &t.transaction)
-	}
-
-	// Default RPC timeout is 60s.
-	timeout := 60 * time.Second
-	if deadline, ok := ctx.Deadline(); ok {
-		timeout = deadline.Sub(time.Now())
-	}
-
-	data, err := proto.Marshal(in)
-	if err != nil {
-		return err
-	}
-
-	ticket := c.req.Header.Get(ticketHeader)
-	// Use a test ticket under test environment.
-	if ticket == "" {
-		if appid := ctx.Value(&appIDOverrideKey); appid != nil {
-			ticket = appid.(string) + defaultTicketSuffix
-		}
-	}
-	// Fall back to use background ticket when the request ticket is not available in Flex or dev_appserver.
-	if ticket == "" {
-		ticket = DefaultTicket()
-	}
-	req := &remotepb.Request{
-		ServiceName: &service,
-		Method:      &method,
-		Request:     data,
-		RequestId:   &ticket,
-	}
-	hreqBody, err := proto.Marshal(req)
-	if err != nil {
-		return err
-	}
-
-	hrespBody, err := c.post(hreqBody, timeout)
-	if err != nil {
-		return err
-	}
-
-	res := &remotepb.Response{}
-	if err := proto.Unmarshal(hrespBody, res); err != nil {
-		return err
-	}
-	if res.RpcError != nil {
-		ce := &CallError{
-			Detail: res.RpcError.GetDetail(),
-			Code:   *res.RpcError.Code,
-		}
-		switch remotepb.RpcError_ErrorCode(ce.Code) {
-		case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED:
-			ce.Timeout = true
-		}
-		return ce
-	}
-	if res.ApplicationError != nil {
-		return &APIError{
-			Service: *req.ServiceName,
-			Detail:  res.ApplicationError.GetDetail(),
-			Code:    *res.ApplicationError.Code,
-		}
-	}
-	if res.Exception != nil || res.JavaException != nil {
-		// This shouldn't happen, but let's be defensive.
-		return &CallError{
-			Detail: "service bridge returned exception",
-			Code:   int32(remotepb.RpcError_UNKNOWN),
-		}
-	}
-	return proto.Unmarshal(res.Response, out)
-}
-
-func (c *context) Request() *http.Request {
-	return c.req
-}
-
-func (c *context) addLogLine(ll *logpb.UserAppLogLine) {
-	// Truncate long log lines.
-	// TODO(dsymonds): Check if this is still necessary.
-	const lim = 8 << 10
-	if len(*ll.Message) > lim {
-		suffix := fmt.Sprintf("...(length %d)", len(*ll.Message))
-		ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix)
-	}
-
-	c.pendingLogs.Lock()
-	c.pendingLogs.lines = append(c.pendingLogs.lines, ll)
-	c.pendingLogs.Unlock()
-}
-
-var logLevelName = map[int64]string{
-	0: "DEBUG",
-	1: "INFO",
-	2: "WARNING",
-	3: "ERROR",
-	4: "CRITICAL",
-}
-
-func logf(c *context, level int64, format string, args ...interface{}) {
-	if c == nil {
-		panic("not an App Engine context")
-	}
-	s := fmt.Sprintf(format, args...)
-	s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
-	c.addLogLine(&logpb.UserAppLogLine{
-		TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3),
-		Level:         &level,
-		Message:       &s,
-	})
-	log.Print(logLevelName[level] + ": " + s)
-}
-
-// flushLog attempts to flush any pending logs to the appserver.
-// It should not be called concurrently.
-func (c *context) flushLog(force bool) (flushed bool) {
-	c.pendingLogs.Lock()
-	// Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious.
-	n, rem := 0, 30<<20
-	for ; n < len(c.pendingLogs.lines); n++ {
-		ll := c.pendingLogs.lines[n]
-		// Each log line will require about 3 bytes of overhead.
-		nb := proto.Size(ll) + 3
-		if nb > rem {
-			break
-		}
-		rem -= nb
-	}
-	lines := c.pendingLogs.lines[:n]
-	c.pendingLogs.lines = c.pendingLogs.lines[n:]
-	c.pendingLogs.Unlock()
-
-	if len(lines) == 0 && !force {
-		// Nothing to flush.
-		return false
-	}
-
-	rescueLogs := false
-	defer func() {
-		if rescueLogs {
-			c.pendingLogs.Lock()
-			c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
-			c.pendingLogs.Unlock()
-		}
-	}()
-
-	buf, err := proto.Marshal(&logpb.UserAppLogGroup{
-		LogLine: lines,
-	})
-	if err != nil {
-		log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
-		rescueLogs = true
-		return false
-	}
-
-	req := &logpb.FlushRequest{
-		Logs: buf,
-	}
-	res := &basepb.VoidProto{}
-	c.pendingLogs.Lock()
-	c.pendingLogs.flushes++
-	c.pendingLogs.Unlock()
-	if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
-		log.Printf("internal.flushLog: Flush RPC: %v", err)
-		rescueLogs = true
-		return false
-	}
-	return true
-}
-
-const (
-	// Log flushing parameters.
-	flushInterval      = 1 * time.Second
-	forceFlushInterval = 60 * time.Second
-)
-
-func (c *context) logFlusher(stop <-chan int) {
-	lastFlush := time.Now()
-	tick := time.NewTicker(flushInterval)
-	for {
-		select {
-		case <-stop:
-			// Request finished.
-			tick.Stop()
-			return
-		case <-tick.C:
-			force := time.Now().Sub(lastFlush) > forceFlushInterval
-			if c.flushLog(force) {
-				lastFlush = time.Now()
-			}
-		}
-	}
-}
-
-func ContextForTesting(req *http.Request) netcontext.Context {
-	return toContext(&context{req: req})
-}
diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go
deleted file mode 100644
index e0c0b214b724212071f072eadd289c73af3d154b..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/api_common.go
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
-	"errors"
-	"os"
-
-	"github.com/golang/protobuf/proto"
-	netcontext "golang.org/x/net/context"
-)
-
-var errNotAppEngineContext = errors.New("not an App Engine context")
-
-type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error
-
-var callOverrideKey = "holds []CallOverrideFunc"
-
-func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context {
-	// We avoid appending to any existing call override
-	// so we don't risk overwriting a popped stack below.
-	var cofs []CallOverrideFunc
-	if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok {
-		cofs = append(cofs, uf...)
-	}
-	cofs = append(cofs, f)
-	return netcontext.WithValue(ctx, &callOverrideKey, cofs)
-}
-
-func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) {
-	cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc)
-	if len(cofs) == 0 {
-		return nil, nil, false
-	}
-	// We found a list of overrides; grab the last, and reconstitute a
-	// context that will hide it.
-	f := cofs[len(cofs)-1]
-	ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1])
-	return f, ctx, true
-}
-
-type logOverrideFunc func(level int64, format string, args ...interface{})
-
-var logOverrideKey = "holds a logOverrideFunc"
-
-func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context {
-	return netcontext.WithValue(ctx, &logOverrideKey, f)
-}
-
-var appIDOverrideKey = "holds a string, being the full app ID"
-
-func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context {
-	return netcontext.WithValue(ctx, &appIDOverrideKey, appID)
-}
-
-var namespaceKey = "holds the namespace string"
-
-func withNamespace(ctx netcontext.Context, ns string) netcontext.Context {
-	return netcontext.WithValue(ctx, &namespaceKey, ns)
-}
-
-func NamespaceFromContext(ctx netcontext.Context) string {
-	// If there's no namespace, return the empty string.
-	ns, _ := ctx.Value(&namespaceKey).(string)
-	return ns
-}
-
-// FullyQualifiedAppID returns the fully-qualified application ID.
-// This may contain a partition prefix (e.g. "s~" for High Replication apps),
-// or a domain prefix (e.g. "example.com:").
-func FullyQualifiedAppID(ctx netcontext.Context) string {
-	if id, ok := ctx.Value(&appIDOverrideKey).(string); ok {
-		return id
-	}
-	return fullyQualifiedAppID(ctx)
-}
-
-func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) {
-	if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok {
-		f(level, format, args...)
-		return
-	}
-	c := fromContext(ctx)
-	if c == nil {
-		panic(errNotAppEngineContext)
-	}
-	logf(c, level, format, args...)
-}
-
-// NamespacedContext wraps a Context to support namespaces.
-func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context {
-	return withNamespace(ctx, namespace)
-}
-
-// SetTestEnv sets the env variables for testing background ticket in Flex.
-func SetTestEnv() func() {
-	var environ = []struct {
-		key, value string
-	}{
-		{"GAE_LONG_APP_ID", "my-app-id"},
-		{"GAE_MINOR_VERSION", "067924799508853122"},
-		{"GAE_MODULE_INSTANCE", "0"},
-		{"GAE_MODULE_NAME", "default"},
-		{"GAE_MODULE_VERSION", "20150612t184001"},
-	}
-
-	for _, v := range environ {
-		old := os.Getenv(v.key)
-		os.Setenv(v.key, v.value)
-		v.value = old
-	}
-	return func() { // Restore old environment after the test completes.
-		for _, v := range environ {
-			if v.value == "" {
-				os.Unsetenv(v.key)
-				continue
-			}
-			os.Setenv(v.key, v.value)
-		}
-	}
-}
diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go
deleted file mode 100644
index 11df8c07b53863dc159518a47ee5b906bdc7c4f1..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/app_id.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
-	"strings"
-)
-
-func parseFullAppID(appid string) (partition, domain, displayID string) {
-	if i := strings.Index(appid, "~"); i != -1 {
-		partition, appid = appid[:i], appid[i+1:]
-	}
-	if i := strings.Index(appid, ":"); i != -1 {
-		domain, appid = appid[:i], appid[i+1:]
-	}
-	return partition, domain, appid
-}
-
-// appID returns "appid" or "domain.com:appid".
-func appID(fullAppID string) string {
-	_, dom, dis := parseFullAppID(fullAppID)
-	if dom != "" {
-		return dom + ":" + dis
-	}
-	return dis
-}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
deleted file mode 100644
index 87d9701b8df951453734099ac31f6c49f0a08d08..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
+++ /dev/null
@@ -1,296 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto
-// DO NOT EDIT!
-
-/*
-Package app_identity is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/app_identity/app_identity_service.proto
-
-It has these top-level messages:
-	AppIdentityServiceError
-	SignForAppRequest
-	SignForAppResponse
-	GetPublicCertificateForAppRequest
-	PublicCertificate
-	GetPublicCertificateForAppResponse
-	GetServiceAccountNameRequest
-	GetServiceAccountNameResponse
-	GetAccessTokenRequest
-	GetAccessTokenResponse
-	GetDefaultGcsBucketNameRequest
-	GetDefaultGcsBucketNameResponse
-*/
-package app_identity
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type AppIdentityServiceError_ErrorCode int32
-
-const (
-	AppIdentityServiceError_SUCCESS           AppIdentityServiceError_ErrorCode = 0
-	AppIdentityServiceError_UNKNOWN_SCOPE     AppIdentityServiceError_ErrorCode = 9
-	AppIdentityServiceError_BLOB_TOO_LARGE    AppIdentityServiceError_ErrorCode = 1000
-	AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001
-	AppIdentityServiceError_NOT_A_VALID_APP   AppIdentityServiceError_ErrorCode = 1002
-	AppIdentityServiceError_UNKNOWN_ERROR     AppIdentityServiceError_ErrorCode = 1003
-	AppIdentityServiceError_NOT_ALLOWED       AppIdentityServiceError_ErrorCode = 1005
-	AppIdentityServiceError_NOT_IMPLEMENTED   AppIdentityServiceError_ErrorCode = 1006
-)
-
-var AppIdentityServiceError_ErrorCode_name = map[int32]string{
-	0:    "SUCCESS",
-	9:    "UNKNOWN_SCOPE",
-	1000: "BLOB_TOO_LARGE",
-	1001: "DEADLINE_EXCEEDED",
-	1002: "NOT_A_VALID_APP",
-	1003: "UNKNOWN_ERROR",
-	1005: "NOT_ALLOWED",
-	1006: "NOT_IMPLEMENTED",
-}
-var AppIdentityServiceError_ErrorCode_value = map[string]int32{
-	"SUCCESS":           0,
-	"UNKNOWN_SCOPE":     9,
-	"BLOB_TOO_LARGE":    1000,
-	"DEADLINE_EXCEEDED": 1001,
-	"NOT_A_VALID_APP":   1002,
-	"UNKNOWN_ERROR":     1003,
-	"NOT_ALLOWED":       1005,
-	"NOT_IMPLEMENTED":   1006,
-}
-
-func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode {
-	p := new(AppIdentityServiceError_ErrorCode)
-	*p = x
-	return p
-}
-func (x AppIdentityServiceError_ErrorCode) String() string {
-	return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x))
-}
-func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode")
-	if err != nil {
-		return err
-	}
-	*x = AppIdentityServiceError_ErrorCode(value)
-	return nil
-}
-
-type AppIdentityServiceError struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *AppIdentityServiceError) Reset()         { *m = AppIdentityServiceError{} }
-func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) }
-func (*AppIdentityServiceError) ProtoMessage()    {}
-
-type SignForAppRequest struct {
-	BytesToSign      []byte `protobuf:"bytes,1,opt,name=bytes_to_sign" json:"bytes_to_sign,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *SignForAppRequest) Reset()         { *m = SignForAppRequest{} }
-func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) }
-func (*SignForAppRequest) ProtoMessage()    {}
-
-func (m *SignForAppRequest) GetBytesToSign() []byte {
-	if m != nil {
-		return m.BytesToSign
-	}
-	return nil
-}
-
-type SignForAppResponse struct {
-	KeyName          *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`
-	SignatureBytes   []byte  `protobuf:"bytes,2,opt,name=signature_bytes" json:"signature_bytes,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SignForAppResponse) Reset()         { *m = SignForAppResponse{} }
-func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) }
-func (*SignForAppResponse) ProtoMessage()    {}
-
-func (m *SignForAppResponse) GetKeyName() string {
-	if m != nil && m.KeyName != nil {
-		return *m.KeyName
-	}
-	return ""
-}
-
-func (m *SignForAppResponse) GetSignatureBytes() []byte {
-	if m != nil {
-		return m.SignatureBytes
-	}
-	return nil
-}
-
-type GetPublicCertificateForAppRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetPublicCertificateForAppRequest) Reset()         { *m = GetPublicCertificateForAppRequest{} }
-func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) }
-func (*GetPublicCertificateForAppRequest) ProtoMessage()    {}
-
-type PublicCertificate struct {
-	KeyName            *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`
-	X509CertificatePem *string `protobuf:"bytes,2,opt,name=x509_certificate_pem" json:"x509_certificate_pem,omitempty"`
-	XXX_unrecognized   []byte  `json:"-"`
-}
-
-func (m *PublicCertificate) Reset()         { *m = PublicCertificate{} }
-func (m *PublicCertificate) String() string { return proto.CompactTextString(m) }
-func (*PublicCertificate) ProtoMessage()    {}
-
-func (m *PublicCertificate) GetKeyName() string {
-	if m != nil && m.KeyName != nil {
-		return *m.KeyName
-	}
-	return ""
-}
-
-func (m *PublicCertificate) GetX509CertificatePem() string {
-	if m != nil && m.X509CertificatePem != nil {
-		return *m.X509CertificatePem
-	}
-	return ""
-}
-
-type GetPublicCertificateForAppResponse struct {
-	PublicCertificateList      []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list" json:"public_certificate_list,omitempty"`
-	MaxClientCacheTimeInSecond *int64               `protobuf:"varint,2,opt,name=max_client_cache_time_in_second" json:"max_client_cache_time_in_second,omitempty"`
-	XXX_unrecognized           []byte               `json:"-"`
-}
-
-func (m *GetPublicCertificateForAppResponse) Reset()         { *m = GetPublicCertificateForAppResponse{} }
-func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) }
-func (*GetPublicCertificateForAppResponse) ProtoMessage()    {}
-
-func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate {
-	if m != nil {
-		return m.PublicCertificateList
-	}
-	return nil
-}
-
-func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 {
-	if m != nil && m.MaxClientCacheTimeInSecond != nil {
-		return *m.MaxClientCacheTimeInSecond
-	}
-	return 0
-}
-
-type GetServiceAccountNameRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetServiceAccountNameRequest) Reset()         { *m = GetServiceAccountNameRequest{} }
-func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) }
-func (*GetServiceAccountNameRequest) ProtoMessage()    {}
-
-type GetServiceAccountNameResponse struct {
-	ServiceAccountName *string `protobuf:"bytes,1,opt,name=service_account_name" json:"service_account_name,omitempty"`
-	XXX_unrecognized   []byte  `json:"-"`
-}
-
-func (m *GetServiceAccountNameResponse) Reset()         { *m = GetServiceAccountNameResponse{} }
-func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) }
-func (*GetServiceAccountNameResponse) ProtoMessage()    {}
-
-func (m *GetServiceAccountNameResponse) GetServiceAccountName() string {
-	if m != nil && m.ServiceAccountName != nil {
-		return *m.ServiceAccountName
-	}
-	return ""
-}
-
-type GetAccessTokenRequest struct {
-	Scope              []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"`
-	ServiceAccountId   *int64   `protobuf:"varint,2,opt,name=service_account_id" json:"service_account_id,omitempty"`
-	ServiceAccountName *string  `protobuf:"bytes,3,opt,name=service_account_name" json:"service_account_name,omitempty"`
-	XXX_unrecognized   []byte   `json:"-"`
-}
-
-func (m *GetAccessTokenRequest) Reset()         { *m = GetAccessTokenRequest{} }
-func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) }
-func (*GetAccessTokenRequest) ProtoMessage()    {}
-
-func (m *GetAccessTokenRequest) GetScope() []string {
-	if m != nil {
-		return m.Scope
-	}
-	return nil
-}
-
-func (m *GetAccessTokenRequest) GetServiceAccountId() int64 {
-	if m != nil && m.ServiceAccountId != nil {
-		return *m.ServiceAccountId
-	}
-	return 0
-}
-
-func (m *GetAccessTokenRequest) GetServiceAccountName() string {
-	if m != nil && m.ServiceAccountName != nil {
-		return *m.ServiceAccountName
-	}
-	return ""
-}
-
-type GetAccessTokenResponse struct {
-	AccessToken      *string `protobuf:"bytes,1,opt,name=access_token" json:"access_token,omitempty"`
-	ExpirationTime   *int64  `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetAccessTokenResponse) Reset()         { *m = GetAccessTokenResponse{} }
-func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) }
-func (*GetAccessTokenResponse) ProtoMessage()    {}
-
-func (m *GetAccessTokenResponse) GetAccessToken() string {
-	if m != nil && m.AccessToken != nil {
-		return *m.AccessToken
-	}
-	return ""
-}
-
-func (m *GetAccessTokenResponse) GetExpirationTime() int64 {
-	if m != nil && m.ExpirationTime != nil {
-		return *m.ExpirationTime
-	}
-	return 0
-}
-
-type GetDefaultGcsBucketNameRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetDefaultGcsBucketNameRequest) Reset()         { *m = GetDefaultGcsBucketNameRequest{} }
-func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) }
-func (*GetDefaultGcsBucketNameRequest) ProtoMessage()    {}
-
-type GetDefaultGcsBucketNameResponse struct {
-	DefaultGcsBucketName *string `protobuf:"bytes,1,opt,name=default_gcs_bucket_name" json:"default_gcs_bucket_name,omitempty"`
-	XXX_unrecognized     []byte  `json:"-"`
-}
-
-func (m *GetDefaultGcsBucketNameResponse) Reset()         { *m = GetDefaultGcsBucketNameResponse{} }
-func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) }
-func (*GetDefaultGcsBucketNameResponse) ProtoMessage()    {}
-
-func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string {
-	if m != nil && m.DefaultGcsBucketName != nil {
-		return *m.DefaultGcsBucketName
-	}
-	return ""
-}
-
-func init() {
-}
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
deleted file mode 100644
index 19610ca5b753fb4ff69a8c6a565fa192827b571c..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
+++ /dev/null
@@ -1,64 +0,0 @@
-syntax = "proto2";
-option go_package = "app_identity";
-
-package appengine;
-
-message AppIdentityServiceError {
-  enum ErrorCode {
-    SUCCESS = 0;
-    UNKNOWN_SCOPE = 9;
-    BLOB_TOO_LARGE = 1000;
-    DEADLINE_EXCEEDED = 1001;
-    NOT_A_VALID_APP = 1002;
-    UNKNOWN_ERROR = 1003;
-    NOT_ALLOWED = 1005;
-    NOT_IMPLEMENTED = 1006;
-  }
-}
-
-message SignForAppRequest {
-  optional bytes bytes_to_sign = 1;
-}
-
-message SignForAppResponse {
-  optional string key_name = 1;
-  optional bytes signature_bytes = 2;
-}
-
-message GetPublicCertificateForAppRequest {
-}
-
-message PublicCertificate {
-  optional string key_name = 1;
-  optional string x509_certificate_pem = 2;
-}
-
-message GetPublicCertificateForAppResponse {
-  repeated PublicCertificate public_certificate_list = 1;
-  optional int64 max_client_cache_time_in_second = 2;
-}
-
-message GetServiceAccountNameRequest {
-}
-
-message GetServiceAccountNameResponse {
-  optional string service_account_name = 1;
-}
-
-message GetAccessTokenRequest {
-  repeated string scope = 1;
-  optional int64 service_account_id = 2;
-  optional string service_account_name = 3;
-}
-
-message GetAccessTokenResponse {
-  optional string access_token = 1;
-  optional int64 expiration_time = 2;
-}
-
-message GetDefaultGcsBucketNameRequest {
-}
-
-message GetDefaultGcsBucketNameResponse {
-  optional string default_gcs_bucket_name = 1;
-}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
deleted file mode 100644
index 36a195650a951d8f604737cfb71af716a533f2ef..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/base/api_base.proto
-// DO NOT EDIT!
-
-/*
-Package base is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/base/api_base.proto
-
-It has these top-level messages:
-	StringProto
-	Integer32Proto
-	Integer64Proto
-	BoolProto
-	DoubleProto
-	BytesProto
-	VoidProto
-*/
-package base
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type StringProto struct {
-	Value            *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *StringProto) Reset()         { *m = StringProto{} }
-func (m *StringProto) String() string { return proto.CompactTextString(m) }
-func (*StringProto) ProtoMessage()    {}
-
-func (m *StringProto) GetValue() string {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return ""
-}
-
-type Integer32Proto struct {
-	Value            *int32 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Integer32Proto) Reset()         { *m = Integer32Proto{} }
-func (m *Integer32Proto) String() string { return proto.CompactTextString(m) }
-func (*Integer32Proto) ProtoMessage()    {}
-
-func (m *Integer32Proto) GetValue() int32 {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return 0
-}
-
-type Integer64Proto struct {
-	Value            *int64 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Integer64Proto) Reset()         { *m = Integer64Proto{} }
-func (m *Integer64Proto) String() string { return proto.CompactTextString(m) }
-func (*Integer64Proto) ProtoMessage()    {}
-
-func (m *Integer64Proto) GetValue() int64 {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return 0
-}
-
-type BoolProto struct {
-	Value            *bool  `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *BoolProto) Reset()         { *m = BoolProto{} }
-func (m *BoolProto) String() string { return proto.CompactTextString(m) }
-func (*BoolProto) ProtoMessage()    {}
-
-func (m *BoolProto) GetValue() bool {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return false
-}
-
-type DoubleProto struct {
-	Value            *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *DoubleProto) Reset()         { *m = DoubleProto{} }
-func (m *DoubleProto) String() string { return proto.CompactTextString(m) }
-func (*DoubleProto) ProtoMessage()    {}
-
-func (m *DoubleProto) GetValue() float64 {
-	if m != nil && m.Value != nil {
-		return *m.Value
-	}
-	return 0
-}
-
-type BytesProto struct {
-	Value            []byte `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *BytesProto) Reset()         { *m = BytesProto{} }
-func (m *BytesProto) String() string { return proto.CompactTextString(m) }
-func (*BytesProto) ProtoMessage()    {}
-
-func (m *BytesProto) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-type VoidProto struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *VoidProto) Reset()         { *m = VoidProto{} }
-func (m *VoidProto) String() string { return proto.CompactTextString(m) }
-func (*VoidProto) ProtoMessage()    {}
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.proto b/vendor/google.golang.org/appengine/internal/base/api_base.proto
deleted file mode 100644
index 56cd7a3cad05e290f84a97ce8d55ffd4d1a6e299..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/base/api_base.proto
+++ /dev/null
@@ -1,33 +0,0 @@
-// Built-in base types for API calls. Primarily useful as return types.
-
-syntax = "proto2";
-option go_package = "base";
-
-package appengine.base;
-
-message StringProto {
-  required string value = 1;
-}
-
-message Integer32Proto {
-  required int32 value = 1;
-}
-
-message Integer64Proto {
-  required int64 value = 1;
-}
-
-message BoolProto {
-  required bool value = 1;
-}
-
-message DoubleProto {
-  required double value = 1;
-}
-
-message BytesProto {
-  required bytes value = 1 [ctype=CORD];
-}
-
-message VoidProto {
-}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
deleted file mode 100644
index 8613cb7311af8dc3faf23755caacab8b1a66ed9c..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
+++ /dev/null
@@ -1,2778 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
-// DO NOT EDIT!
-
-/*
-Package datastore is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/datastore/datastore_v3.proto
-
-It has these top-level messages:
-	Action
-	PropertyValue
-	Property
-	Path
-	Reference
-	User
-	EntityProto
-	CompositeProperty
-	Index
-	CompositeIndex
-	IndexPostfix
-	IndexPosition
-	Snapshot
-	InternalHeader
-	Transaction
-	Query
-	CompiledQuery
-	CompiledCursor
-	Cursor
-	Error
-	Cost
-	GetRequest
-	GetResponse
-	PutRequest
-	PutResponse
-	TouchRequest
-	TouchResponse
-	DeleteRequest
-	DeleteResponse
-	NextRequest
-	QueryResult
-	AllocateIdsRequest
-	AllocateIdsResponse
-	CompositeIndices
-	AddActionsRequest
-	AddActionsResponse
-	BeginTransactionRequest
-	CommitResponse
-*/
-package datastore
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type Property_Meaning int32
-
-const (
-	Property_NO_MEANING       Property_Meaning = 0
-	Property_BLOB             Property_Meaning = 14
-	Property_TEXT             Property_Meaning = 15
-	Property_BYTESTRING       Property_Meaning = 16
-	Property_ATOM_CATEGORY    Property_Meaning = 1
-	Property_ATOM_LINK        Property_Meaning = 2
-	Property_ATOM_TITLE       Property_Meaning = 3
-	Property_ATOM_CONTENT     Property_Meaning = 4
-	Property_ATOM_SUMMARY     Property_Meaning = 5
-	Property_ATOM_AUTHOR      Property_Meaning = 6
-	Property_GD_WHEN          Property_Meaning = 7
-	Property_GD_EMAIL         Property_Meaning = 8
-	Property_GEORSS_POINT     Property_Meaning = 9
-	Property_GD_IM            Property_Meaning = 10
-	Property_GD_PHONENUMBER   Property_Meaning = 11
-	Property_GD_POSTALADDRESS Property_Meaning = 12
-	Property_GD_RATING        Property_Meaning = 13
-	Property_BLOBKEY          Property_Meaning = 17
-	Property_ENTITY_PROTO     Property_Meaning = 19
-	Property_INDEX_VALUE      Property_Meaning = 18
-)
-
-var Property_Meaning_name = map[int32]string{
-	0:  "NO_MEANING",
-	14: "BLOB",
-	15: "TEXT",
-	16: "BYTESTRING",
-	1:  "ATOM_CATEGORY",
-	2:  "ATOM_LINK",
-	3:  "ATOM_TITLE",
-	4:  "ATOM_CONTENT",
-	5:  "ATOM_SUMMARY",
-	6:  "ATOM_AUTHOR",
-	7:  "GD_WHEN",
-	8:  "GD_EMAIL",
-	9:  "GEORSS_POINT",
-	10: "GD_IM",
-	11: "GD_PHONENUMBER",
-	12: "GD_POSTALADDRESS",
-	13: "GD_RATING",
-	17: "BLOBKEY",
-	19: "ENTITY_PROTO",
-	18: "INDEX_VALUE",
-}
-var Property_Meaning_value = map[string]int32{
-	"NO_MEANING":       0,
-	"BLOB":             14,
-	"TEXT":             15,
-	"BYTESTRING":       16,
-	"ATOM_CATEGORY":    1,
-	"ATOM_LINK":        2,
-	"ATOM_TITLE":       3,
-	"ATOM_CONTENT":     4,
-	"ATOM_SUMMARY":     5,
-	"ATOM_AUTHOR":      6,
-	"GD_WHEN":          7,
-	"GD_EMAIL":         8,
-	"GEORSS_POINT":     9,
-	"GD_IM":            10,
-	"GD_PHONENUMBER":   11,
-	"GD_POSTALADDRESS": 12,
-	"GD_RATING":        13,
-	"BLOBKEY":          17,
-	"ENTITY_PROTO":     19,
-	"INDEX_VALUE":      18,
-}
-
-func (x Property_Meaning) Enum() *Property_Meaning {
-	p := new(Property_Meaning)
-	*p = x
-	return p
-}
-func (x Property_Meaning) String() string {
-	return proto.EnumName(Property_Meaning_name, int32(x))
-}
-func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
-	if err != nil {
-		return err
-	}
-	*x = Property_Meaning(value)
-	return nil
-}
-
-type Property_FtsTokenizationOption int32
-
-const (
-	Property_HTML Property_FtsTokenizationOption = 1
-	Property_ATOM Property_FtsTokenizationOption = 2
-)
-
-var Property_FtsTokenizationOption_name = map[int32]string{
-	1: "HTML",
-	2: "ATOM",
-}
-var Property_FtsTokenizationOption_value = map[string]int32{
-	"HTML": 1,
-	"ATOM": 2,
-}
-
-func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
-	p := new(Property_FtsTokenizationOption)
-	*p = x
-	return p
-}
-func (x Property_FtsTokenizationOption) String() string {
-	return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
-}
-func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
-	if err != nil {
-		return err
-	}
-	*x = Property_FtsTokenizationOption(value)
-	return nil
-}
-
-type EntityProto_Kind int32
-
-const (
-	EntityProto_GD_CONTACT EntityProto_Kind = 1
-	EntityProto_GD_EVENT   EntityProto_Kind = 2
-	EntityProto_GD_MESSAGE EntityProto_Kind = 3
-)
-
-var EntityProto_Kind_name = map[int32]string{
-	1: "GD_CONTACT",
-	2: "GD_EVENT",
-	3: "GD_MESSAGE",
-}
-var EntityProto_Kind_value = map[string]int32{
-	"GD_CONTACT": 1,
-	"GD_EVENT":   2,
-	"GD_MESSAGE": 3,
-}
-
-func (x EntityProto_Kind) Enum() *EntityProto_Kind {
-	p := new(EntityProto_Kind)
-	*p = x
-	return p
-}
-func (x EntityProto_Kind) String() string {
-	return proto.EnumName(EntityProto_Kind_name, int32(x))
-}
-func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
-	if err != nil {
-		return err
-	}
-	*x = EntityProto_Kind(value)
-	return nil
-}
-
-type Index_Property_Direction int32
-
-const (
-	Index_Property_ASCENDING  Index_Property_Direction = 1
-	Index_Property_DESCENDING Index_Property_Direction = 2
-)
-
-var Index_Property_Direction_name = map[int32]string{
-	1: "ASCENDING",
-	2: "DESCENDING",
-}
-var Index_Property_Direction_value = map[string]int32{
-	"ASCENDING":  1,
-	"DESCENDING": 2,
-}
-
-func (x Index_Property_Direction) Enum() *Index_Property_Direction {
-	p := new(Index_Property_Direction)
-	*p = x
-	return p
-}
-func (x Index_Property_Direction) String() string {
-	return proto.EnumName(Index_Property_Direction_name, int32(x))
-}
-func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
-	if err != nil {
-		return err
-	}
-	*x = Index_Property_Direction(value)
-	return nil
-}
-
-type CompositeIndex_State int32
-
-const (
-	CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
-	CompositeIndex_READ_WRITE CompositeIndex_State = 2
-	CompositeIndex_DELETED    CompositeIndex_State = 3
-	CompositeIndex_ERROR      CompositeIndex_State = 4
-)
-
-var CompositeIndex_State_name = map[int32]string{
-	1: "WRITE_ONLY",
-	2: "READ_WRITE",
-	3: "DELETED",
-	4: "ERROR",
-}
-var CompositeIndex_State_value = map[string]int32{
-	"WRITE_ONLY": 1,
-	"READ_WRITE": 2,
-	"DELETED":    3,
-	"ERROR":      4,
-}
-
-func (x CompositeIndex_State) Enum() *CompositeIndex_State {
-	p := new(CompositeIndex_State)
-	*p = x
-	return p
-}
-func (x CompositeIndex_State) String() string {
-	return proto.EnumName(CompositeIndex_State_name, int32(x))
-}
-func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
-	if err != nil {
-		return err
-	}
-	*x = CompositeIndex_State(value)
-	return nil
-}
-
-type Snapshot_Status int32
-
-const (
-	Snapshot_INACTIVE Snapshot_Status = 0
-	Snapshot_ACTIVE   Snapshot_Status = 1
-)
-
-var Snapshot_Status_name = map[int32]string{
-	0: "INACTIVE",
-	1: "ACTIVE",
-}
-var Snapshot_Status_value = map[string]int32{
-	"INACTIVE": 0,
-	"ACTIVE":   1,
-}
-
-func (x Snapshot_Status) Enum() *Snapshot_Status {
-	p := new(Snapshot_Status)
-	*p = x
-	return p
-}
-func (x Snapshot_Status) String() string {
-	return proto.EnumName(Snapshot_Status_name, int32(x))
-}
-func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
-	if err != nil {
-		return err
-	}
-	*x = Snapshot_Status(value)
-	return nil
-}
-
-type Query_Hint int32
-
-const (
-	Query_ORDER_FIRST    Query_Hint = 1
-	Query_ANCESTOR_FIRST Query_Hint = 2
-	Query_FILTER_FIRST   Query_Hint = 3
-)
-
-var Query_Hint_name = map[int32]string{
-	1: "ORDER_FIRST",
-	2: "ANCESTOR_FIRST",
-	3: "FILTER_FIRST",
-}
-var Query_Hint_value = map[string]int32{
-	"ORDER_FIRST":    1,
-	"ANCESTOR_FIRST": 2,
-	"FILTER_FIRST":   3,
-}
-
-func (x Query_Hint) Enum() *Query_Hint {
-	p := new(Query_Hint)
-	*p = x
-	return p
-}
-func (x Query_Hint) String() string {
-	return proto.EnumName(Query_Hint_name, int32(x))
-}
-func (x *Query_Hint) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
-	if err != nil {
-		return err
-	}
-	*x = Query_Hint(value)
-	return nil
-}
-
-type Query_Filter_Operator int32
-
-const (
-	Query_Filter_LESS_THAN             Query_Filter_Operator = 1
-	Query_Filter_LESS_THAN_OR_EQUAL    Query_Filter_Operator = 2
-	Query_Filter_GREATER_THAN          Query_Filter_Operator = 3
-	Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
-	Query_Filter_EQUAL                 Query_Filter_Operator = 5
-	Query_Filter_IN                    Query_Filter_Operator = 6
-	Query_Filter_EXISTS                Query_Filter_Operator = 7
-)
-
-var Query_Filter_Operator_name = map[int32]string{
-	1: "LESS_THAN",
-	2: "LESS_THAN_OR_EQUAL",
-	3: "GREATER_THAN",
-	4: "GREATER_THAN_OR_EQUAL",
-	5: "EQUAL",
-	6: "IN",
-	7: "EXISTS",
-}
-var Query_Filter_Operator_value = map[string]int32{
-	"LESS_THAN":             1,
-	"LESS_THAN_OR_EQUAL":    2,
-	"GREATER_THAN":          3,
-	"GREATER_THAN_OR_EQUAL": 4,
-	"EQUAL":                 5,
-	"IN":                    6,
-	"EXISTS":                7,
-}
-
-func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
-	p := new(Query_Filter_Operator)
-	*p = x
-	return p
-}
-func (x Query_Filter_Operator) String() string {
-	return proto.EnumName(Query_Filter_Operator_name, int32(x))
-}
-func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
-	if err != nil {
-		return err
-	}
-	*x = Query_Filter_Operator(value)
-	return nil
-}
-
-type Query_Order_Direction int32
-
-const (
-	Query_Order_ASCENDING  Query_Order_Direction = 1
-	Query_Order_DESCENDING Query_Order_Direction = 2
-)
-
-var Query_Order_Direction_name = map[int32]string{
-	1: "ASCENDING",
-	2: "DESCENDING",
-}
-var Query_Order_Direction_value = map[string]int32{
-	"ASCENDING":  1,
-	"DESCENDING": 2,
-}
-
-func (x Query_Order_Direction) Enum() *Query_Order_Direction {
-	p := new(Query_Order_Direction)
-	*p = x
-	return p
-}
-func (x Query_Order_Direction) String() string {
-	return proto.EnumName(Query_Order_Direction_name, int32(x))
-}
-func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
-	if err != nil {
-		return err
-	}
-	*x = Query_Order_Direction(value)
-	return nil
-}
-
-type Error_ErrorCode int32
-
-const (
-	Error_BAD_REQUEST                  Error_ErrorCode = 1
-	Error_CONCURRENT_TRANSACTION       Error_ErrorCode = 2
-	Error_INTERNAL_ERROR               Error_ErrorCode = 3
-	Error_NEED_INDEX                   Error_ErrorCode = 4
-	Error_TIMEOUT                      Error_ErrorCode = 5
-	Error_PERMISSION_DENIED            Error_ErrorCode = 6
-	Error_BIGTABLE_ERROR               Error_ErrorCode = 7
-	Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
-	Error_CAPABILITY_DISABLED          Error_ErrorCode = 9
-	Error_TRY_ALTERNATE_BACKEND        Error_ErrorCode = 10
-	Error_SAFE_TIME_TOO_OLD            Error_ErrorCode = 11
-)
-
-var Error_ErrorCode_name = map[int32]string{
-	1:  "BAD_REQUEST",
-	2:  "CONCURRENT_TRANSACTION",
-	3:  "INTERNAL_ERROR",
-	4:  "NEED_INDEX",
-	5:  "TIMEOUT",
-	6:  "PERMISSION_DENIED",
-	7:  "BIGTABLE_ERROR",
-	8:  "COMMITTED_BUT_STILL_APPLYING",
-	9:  "CAPABILITY_DISABLED",
-	10: "TRY_ALTERNATE_BACKEND",
-	11: "SAFE_TIME_TOO_OLD",
-}
-var Error_ErrorCode_value = map[string]int32{
-	"BAD_REQUEST":                  1,
-	"CONCURRENT_TRANSACTION":       2,
-	"INTERNAL_ERROR":               3,
-	"NEED_INDEX":                   4,
-	"TIMEOUT":                      5,
-	"PERMISSION_DENIED":            6,
-	"BIGTABLE_ERROR":               7,
-	"COMMITTED_BUT_STILL_APPLYING": 8,
-	"CAPABILITY_DISABLED":          9,
-	"TRY_ALTERNATE_BACKEND":        10,
-	"SAFE_TIME_TOO_OLD":            11,
-}
-
-func (x Error_ErrorCode) Enum() *Error_ErrorCode {
-	p := new(Error_ErrorCode)
-	*p = x
-	return p
-}
-func (x Error_ErrorCode) String() string {
-	return proto.EnumName(Error_ErrorCode_name, int32(x))
-}
-func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
-	if err != nil {
-		return err
-	}
-	*x = Error_ErrorCode(value)
-	return nil
-}
-
-type PutRequest_AutoIdPolicy int32
-
-const (
-	PutRequest_CURRENT    PutRequest_AutoIdPolicy = 0
-	PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
-)
-
-var PutRequest_AutoIdPolicy_name = map[int32]string{
-	0: "CURRENT",
-	1: "SEQUENTIAL",
-}
-var PutRequest_AutoIdPolicy_value = map[string]int32{
-	"CURRENT":    0,
-	"SEQUENTIAL": 1,
-}
-
-func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
-	p := new(PutRequest_AutoIdPolicy)
-	*p = x
-	return p
-}
-func (x PutRequest_AutoIdPolicy) String() string {
-	return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
-}
-func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
-	if err != nil {
-		return err
-	}
-	*x = PutRequest_AutoIdPolicy(value)
-	return nil
-}
-
-type Action struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Action) Reset()         { *m = Action{} }
-func (m *Action) String() string { return proto.CompactTextString(m) }
-func (*Action) ProtoMessage()    {}
-
-type PropertyValue struct {
-	Int64Value       *int64                        `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
-	BooleanValue     *bool                         `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
-	StringValue      *string                       `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
-	DoubleValue      *float64                      `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
-	Pointvalue       *PropertyValue_PointValue     `protobuf:"group,5,opt,name=PointValue" json:"pointvalue,omitempty"`
-	Uservalue        *PropertyValue_UserValue      `protobuf:"group,8,opt,name=UserValue" json:"uservalue,omitempty"`
-	Referencevalue   *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue" json:"referencevalue,omitempty"`
-	XXX_unrecognized []byte                        `json:"-"`
-}
-
-func (m *PropertyValue) Reset()         { *m = PropertyValue{} }
-func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue) ProtoMessage()    {}
-
-func (m *PropertyValue) GetInt64Value() int64 {
-	if m != nil && m.Int64Value != nil {
-		return *m.Int64Value
-	}
-	return 0
-}
-
-func (m *PropertyValue) GetBooleanValue() bool {
-	if m != nil && m.BooleanValue != nil {
-		return *m.BooleanValue
-	}
-	return false
-}
-
-func (m *PropertyValue) GetStringValue() string {
-	if m != nil && m.StringValue != nil {
-		return *m.StringValue
-	}
-	return ""
-}
-
-func (m *PropertyValue) GetDoubleValue() float64 {
-	if m != nil && m.DoubleValue != nil {
-		return *m.DoubleValue
-	}
-	return 0
-}
-
-func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
-	if m != nil {
-		return m.Pointvalue
-	}
-	return nil
-}
-
-func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
-	if m != nil {
-		return m.Uservalue
-	}
-	return nil
-}
-
-func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
-	if m != nil {
-		return m.Referencevalue
-	}
-	return nil
-}
-
-type PropertyValue_PointValue struct {
-	X                *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
-	Y                *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *PropertyValue_PointValue) Reset()         { *m = PropertyValue_PointValue{} }
-func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_PointValue) ProtoMessage()    {}
-
-func (m *PropertyValue_PointValue) GetX() float64 {
-	if m != nil && m.X != nil {
-		return *m.X
-	}
-	return 0
-}
-
-func (m *PropertyValue_PointValue) GetY() float64 {
-	if m != nil && m.Y != nil {
-		return *m.Y
-	}
-	return 0
-}
-
-type PropertyValue_UserValue struct {
-	Email             *string `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
-	AuthDomain        *string `protobuf:"bytes,10,req,name=auth_domain" json:"auth_domain,omitempty"`
-	Nickname          *string `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
-	FederatedIdentity *string `protobuf:"bytes,21,opt,name=federated_identity" json:"federated_identity,omitempty"`
-	FederatedProvider *string `protobuf:"bytes,22,opt,name=federated_provider" json:"federated_provider,omitempty"`
-	XXX_unrecognized  []byte  `json:"-"`
-}
-
-func (m *PropertyValue_UserValue) Reset()         { *m = PropertyValue_UserValue{} }
-func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_UserValue) ProtoMessage()    {}
-
-func (m *PropertyValue_UserValue) GetEmail() string {
-	if m != nil && m.Email != nil {
-		return *m.Email
-	}
-	return ""
-}
-
-func (m *PropertyValue_UserValue) GetAuthDomain() string {
-	if m != nil && m.AuthDomain != nil {
-		return *m.AuthDomain
-	}
-	return ""
-}
-
-func (m *PropertyValue_UserValue) GetNickname() string {
-	if m != nil && m.Nickname != nil {
-		return *m.Nickname
-	}
-	return ""
-}
-
-func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
-	if m != nil && m.FederatedIdentity != nil {
-		return *m.FederatedIdentity
-	}
-	return ""
-}
-
-func (m *PropertyValue_UserValue) GetFederatedProvider() string {
-	if m != nil && m.FederatedProvider != nil {
-		return *m.FederatedProvider
-	}
-	return ""
-}
-
-type PropertyValue_ReferenceValue struct {
-	App              *string                                     `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
-	NameSpace        *string                                     `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"`
-	Pathelement      []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement" json:"pathelement,omitempty"`
-	XXX_unrecognized []byte                                      `json:"-"`
-}
-
-func (m *PropertyValue_ReferenceValue) Reset()         { *m = PropertyValue_ReferenceValue{} }
-func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_ReferenceValue) ProtoMessage()    {}
-
-func (m *PropertyValue_ReferenceValue) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
-	if m != nil && m.NameSpace != nil {
-		return *m.NameSpace
-	}
-	return ""
-}
-
-func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
-	if m != nil {
-		return m.Pathelement
-	}
-	return nil
-}
-
-type PropertyValue_ReferenceValue_PathElement struct {
-	Type             *string `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
-	Id               *int64  `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
-	Name             *string `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
-	*m = PropertyValue_ReferenceValue_PathElement{}
-}
-func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
-func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage()    {}
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return ""
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
-	if m != nil && m.Id != nil {
-		return *m.Id
-	}
-	return 0
-}
-
-func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-type Property struct {
-	Meaning               *Property_Meaning               `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
-	MeaningUri            *string                         `protobuf:"bytes,2,opt,name=meaning_uri" json:"meaning_uri,omitempty"`
-	Name                  *string                         `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
-	Value                 *PropertyValue                  `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
-	Multiple              *bool                           `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
-	Searchable            *bool                           `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
-	FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
-	Locale                *string                         `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
-	XXX_unrecognized      []byte                          `json:"-"`
-}
-
-func (m *Property) Reset()         { *m = Property{} }
-func (m *Property) String() string { return proto.CompactTextString(m) }
-func (*Property) ProtoMessage()    {}
-
-const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
-const Default_Property_Searchable bool = false
-const Default_Property_Locale string = "en"
-
-func (m *Property) GetMeaning() Property_Meaning {
-	if m != nil && m.Meaning != nil {
-		return *m.Meaning
-	}
-	return Default_Property_Meaning
-}
-
-func (m *Property) GetMeaningUri() string {
-	if m != nil && m.MeaningUri != nil {
-		return *m.MeaningUri
-	}
-	return ""
-}
-
-func (m *Property) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *Property) GetValue() *PropertyValue {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *Property) GetMultiple() bool {
-	if m != nil && m.Multiple != nil {
-		return *m.Multiple
-	}
-	return false
-}
-
-func (m *Property) GetSearchable() bool {
-	if m != nil && m.Searchable != nil {
-		return *m.Searchable
-	}
-	return Default_Property_Searchable
-}
-
-func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
-	if m != nil && m.FtsTokenizationOption != nil {
-		return *m.FtsTokenizationOption
-	}
-	return Property_HTML
-}
-
-func (m *Property) GetLocale() string {
-	if m != nil && m.Locale != nil {
-		return *m.Locale
-	}
-	return Default_Property_Locale
-}
-
-type Path struct {
-	Element          []*Path_Element `protobuf:"group,1,rep,name=Element" json:"element,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *Path) Reset()         { *m = Path{} }
-func (m *Path) String() string { return proto.CompactTextString(m) }
-func (*Path) ProtoMessage()    {}
-
-func (m *Path) GetElement() []*Path_Element {
-	if m != nil {
-		return m.Element
-	}
-	return nil
-}
-
-type Path_Element struct {
-	Type             *string `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
-	Id               *int64  `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
-	Name             *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Path_Element) Reset()         { *m = Path_Element{} }
-func (m *Path_Element) String() string { return proto.CompactTextString(m) }
-func (*Path_Element) ProtoMessage()    {}
-
-func (m *Path_Element) GetType() string {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return ""
-}
-
-func (m *Path_Element) GetId() int64 {
-	if m != nil && m.Id != nil {
-		return *m.Id
-	}
-	return 0
-}
-
-func (m *Path_Element) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-type Reference struct {
-	App              *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
-	NameSpace        *string `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"`
-	Path             *Path   `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Reference) Reset()         { *m = Reference{} }
-func (m *Reference) String() string { return proto.CompactTextString(m) }
-func (*Reference) ProtoMessage()    {}
-
-func (m *Reference) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-func (m *Reference) GetNameSpace() string {
-	if m != nil && m.NameSpace != nil {
-		return *m.NameSpace
-	}
-	return ""
-}
-
-func (m *Reference) GetPath() *Path {
-	if m != nil {
-		return m.Path
-	}
-	return nil
-}
-
-type User struct {
-	Email             *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
-	AuthDomain        *string `protobuf:"bytes,2,req,name=auth_domain" json:"auth_domain,omitempty"`
-	Nickname          *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
-	FederatedIdentity *string `protobuf:"bytes,6,opt,name=federated_identity" json:"federated_identity,omitempty"`
-	FederatedProvider *string `protobuf:"bytes,7,opt,name=federated_provider" json:"federated_provider,omitempty"`
-	XXX_unrecognized  []byte  `json:"-"`
-}
-
-func (m *User) Reset()         { *m = User{} }
-func (m *User) String() string { return proto.CompactTextString(m) }
-func (*User) ProtoMessage()    {}
-
-func (m *User) GetEmail() string {
-	if m != nil && m.Email != nil {
-		return *m.Email
-	}
-	return ""
-}
-
-func (m *User) GetAuthDomain() string {
-	if m != nil && m.AuthDomain != nil {
-		return *m.AuthDomain
-	}
-	return ""
-}
-
-func (m *User) GetNickname() string {
-	if m != nil && m.Nickname != nil {
-		return *m.Nickname
-	}
-	return ""
-}
-
-func (m *User) GetFederatedIdentity() string {
-	if m != nil && m.FederatedIdentity != nil {
-		return *m.FederatedIdentity
-	}
-	return ""
-}
-
-func (m *User) GetFederatedProvider() string {
-	if m != nil && m.FederatedProvider != nil {
-		return *m.FederatedProvider
-	}
-	return ""
-}
-
-type EntityProto struct {
-	Key              *Reference        `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
-	EntityGroup      *Path             `protobuf:"bytes,16,req,name=entity_group" json:"entity_group,omitempty"`
-	Owner            *User             `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
-	Kind             *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
-	KindUri          *string           `protobuf:"bytes,5,opt,name=kind_uri" json:"kind_uri,omitempty"`
-	Property         []*Property       `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
-	RawProperty      []*Property       `protobuf:"bytes,15,rep,name=raw_property" json:"raw_property,omitempty"`
-	Rank             *int32            `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *EntityProto) Reset()         { *m = EntityProto{} }
-func (m *EntityProto) String() string { return proto.CompactTextString(m) }
-func (*EntityProto) ProtoMessage()    {}
-
-func (m *EntityProto) GetKey() *Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *EntityProto) GetEntityGroup() *Path {
-	if m != nil {
-		return m.EntityGroup
-	}
-	return nil
-}
-
-func (m *EntityProto) GetOwner() *User {
-	if m != nil {
-		return m.Owner
-	}
-	return nil
-}
-
-func (m *EntityProto) GetKind() EntityProto_Kind {
-	if m != nil && m.Kind != nil {
-		return *m.Kind
-	}
-	return EntityProto_GD_CONTACT
-}
-
-func (m *EntityProto) GetKindUri() string {
-	if m != nil && m.KindUri != nil {
-		return *m.KindUri
-	}
-	return ""
-}
-
-func (m *EntityProto) GetProperty() []*Property {
-	if m != nil {
-		return m.Property
-	}
-	return nil
-}
-
-func (m *EntityProto) GetRawProperty() []*Property {
-	if m != nil {
-		return m.RawProperty
-	}
-	return nil
-}
-
-func (m *EntityProto) GetRank() int32 {
-	if m != nil && m.Rank != nil {
-		return *m.Rank
-	}
-	return 0
-}
-
-type CompositeProperty struct {
-	IndexId          *int64   `protobuf:"varint,1,req,name=index_id" json:"index_id,omitempty"`
-	Value            []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *CompositeProperty) Reset()         { *m = CompositeProperty{} }
-func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
-func (*CompositeProperty) ProtoMessage()    {}
-
-func (m *CompositeProperty) GetIndexId() int64 {
-	if m != nil && m.IndexId != nil {
-		return *m.IndexId
-	}
-	return 0
-}
-
-func (m *CompositeProperty) GetValue() []string {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-type Index struct {
-	EntityType       *string           `protobuf:"bytes,1,req,name=entity_type" json:"entity_type,omitempty"`
-	Ancestor         *bool             `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
-	Property         []*Index_Property `protobuf:"group,2,rep,name=Property" json:"property,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *Index) Reset()         { *m = Index{} }
-func (m *Index) String() string { return proto.CompactTextString(m) }
-func (*Index) ProtoMessage()    {}
-
-func (m *Index) GetEntityType() string {
-	if m != nil && m.EntityType != nil {
-		return *m.EntityType
-	}
-	return ""
-}
-
-func (m *Index) GetAncestor() bool {
-	if m != nil && m.Ancestor != nil {
-		return *m.Ancestor
-	}
-	return false
-}
-
-func (m *Index) GetProperty() []*Index_Property {
-	if m != nil {
-		return m.Property
-	}
-	return nil
-}
-
-type Index_Property struct {
-	Name             *string                   `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
-	Direction        *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
-	XXX_unrecognized []byte                    `json:"-"`
-}
-
-func (m *Index_Property) Reset()         { *m = Index_Property{} }
-func (m *Index_Property) String() string { return proto.CompactTextString(m) }
-func (*Index_Property) ProtoMessage()    {}
-
-const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
-
-func (m *Index_Property) GetName() string {
-	if m != nil && m.Name != nil {
-		return *m.Name
-	}
-	return ""
-}
-
-func (m *Index_Property) GetDirection() Index_Property_Direction {
-	if m != nil && m.Direction != nil {
-		return *m.Direction
-	}
-	return Default_Index_Property_Direction
-}
-
-type CompositeIndex struct {
-	AppId             *string               `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
-	Id                *int64                `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
-	Definition        *Index                `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
-	State             *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
-	OnlyUseIfRequired *bool                 `protobuf:"varint,6,opt,name=only_use_if_required,def=0" json:"only_use_if_required,omitempty"`
-	XXX_unrecognized  []byte                `json:"-"`
-}
-
-func (m *CompositeIndex) Reset()         { *m = CompositeIndex{} }
-func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
-func (*CompositeIndex) ProtoMessage()    {}
-
-const Default_CompositeIndex_OnlyUseIfRequired bool = false
-
-func (m *CompositeIndex) GetAppId() string {
-	if m != nil && m.AppId != nil {
-		return *m.AppId
-	}
-	return ""
-}
-
-func (m *CompositeIndex) GetId() int64 {
-	if m != nil && m.Id != nil {
-		return *m.Id
-	}
-	return 0
-}
-
-func (m *CompositeIndex) GetDefinition() *Index {
-	if m != nil {
-		return m.Definition
-	}
-	return nil
-}
-
-func (m *CompositeIndex) GetState() CompositeIndex_State {
-	if m != nil && m.State != nil {
-		return *m.State
-	}
-	return CompositeIndex_WRITE_ONLY
-}
-
-func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
-	if m != nil && m.OnlyUseIfRequired != nil {
-		return *m.OnlyUseIfRequired
-	}
-	return Default_CompositeIndex_OnlyUseIfRequired
-}
-
-type IndexPostfix struct {
-	IndexValue       []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value" json:"index_value,omitempty"`
-	Key              *Reference                 `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
-	Before           *bool                      `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
-	XXX_unrecognized []byte                     `json:"-"`
-}
-
-func (m *IndexPostfix) Reset()         { *m = IndexPostfix{} }
-func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
-func (*IndexPostfix) ProtoMessage()    {}
-
-const Default_IndexPostfix_Before bool = true
-
-func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
-	if m != nil {
-		return m.IndexValue
-	}
-	return nil
-}
-
-func (m *IndexPostfix) GetKey() *Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *IndexPostfix) GetBefore() bool {
-	if m != nil && m.Before != nil {
-		return *m.Before
-	}
-	return Default_IndexPostfix_Before
-}
-
-type IndexPostfix_IndexValue struct {
-	PropertyName     *string        `protobuf:"bytes,1,req,name=property_name" json:"property_name,omitempty"`
-	Value            *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte         `json:"-"`
-}
-
-func (m *IndexPostfix_IndexValue) Reset()         { *m = IndexPostfix_IndexValue{} }
-func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
-func (*IndexPostfix_IndexValue) ProtoMessage()    {}
-
-func (m *IndexPostfix_IndexValue) GetPropertyName() string {
-	if m != nil && m.PropertyName != nil {
-		return *m.PropertyName
-	}
-	return ""
-}
-
-func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-type IndexPosition struct {
-	Key              *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
-	Before           *bool   `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *IndexPosition) Reset()         { *m = IndexPosition{} }
-func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
-func (*IndexPosition) ProtoMessage()    {}
-
-const Default_IndexPosition_Before bool = true
-
-func (m *IndexPosition) GetKey() string {
-	if m != nil && m.Key != nil {
-		return *m.Key
-	}
-	return ""
-}
-
-func (m *IndexPosition) GetBefore() bool {
-	if m != nil && m.Before != nil {
-		return *m.Before
-	}
-	return Default_IndexPosition_Before
-}
-
-type Snapshot struct {
-	Ts               *int64 `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Snapshot) Reset()         { *m = Snapshot{} }
-func (m *Snapshot) String() string { return proto.CompactTextString(m) }
-func (*Snapshot) ProtoMessage()    {}
-
-func (m *Snapshot) GetTs() int64 {
-	if m != nil && m.Ts != nil {
-		return *m.Ts
-	}
-	return 0
-}
-
-type InternalHeader struct {
-	Qos              *string `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *InternalHeader) Reset()         { *m = InternalHeader{} }
-func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
-func (*InternalHeader) ProtoMessage()    {}
-
-func (m *InternalHeader) GetQos() string {
-	if m != nil && m.Qos != nil {
-		return *m.Qos
-	}
-	return ""
-}
-
-type Transaction struct {
-	Header           *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
-	Handle           *uint64         `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
-	App              *string         `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
-	MarkChanges      *bool           `protobuf:"varint,3,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *Transaction) Reset()         { *m = Transaction{} }
-func (m *Transaction) String() string { return proto.CompactTextString(m) }
-func (*Transaction) ProtoMessage()    {}
-
-const Default_Transaction_MarkChanges bool = false
-
-func (m *Transaction) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *Transaction) GetHandle() uint64 {
-	if m != nil && m.Handle != nil {
-		return *m.Handle
-	}
-	return 0
-}
-
-func (m *Transaction) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-func (m *Transaction) GetMarkChanges() bool {
-	if m != nil && m.MarkChanges != nil {
-		return *m.MarkChanges
-	}
-	return Default_Transaction_MarkChanges
-}
-
-type Query struct {
-	Header              *InternalHeader   `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
-	App                 *string           `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
-	NameSpace           *string           `protobuf:"bytes,29,opt,name=name_space" json:"name_space,omitempty"`
-	Kind                *string           `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
-	Ancestor            *Reference        `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
-	Filter              []*Query_Filter   `protobuf:"group,4,rep,name=Filter" json:"filter,omitempty"`
-	SearchQuery         *string           `protobuf:"bytes,8,opt,name=search_query" json:"search_query,omitempty"`
-	Order               []*Query_Order    `protobuf:"group,9,rep,name=Order" json:"order,omitempty"`
-	Hint                *Query_Hint       `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
-	Count               *int32            `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
-	Offset              *int32            `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
-	Limit               *int32            `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
-	CompiledCursor      *CompiledCursor   `protobuf:"bytes,30,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"`
-	EndCompiledCursor   *CompiledCursor   `protobuf:"bytes,31,opt,name=end_compiled_cursor" json:"end_compiled_cursor,omitempty"`
-	CompositeIndex      []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index" json:"composite_index,omitempty"`
-	RequirePerfectPlan  *bool             `protobuf:"varint,20,opt,name=require_perfect_plan,def=0" json:"require_perfect_plan,omitempty"`
-	KeysOnly            *bool             `protobuf:"varint,21,opt,name=keys_only,def=0" json:"keys_only,omitempty"`
-	Transaction         *Transaction      `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
-	Compile             *bool             `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
-	FailoverMs          *int64            `protobuf:"varint,26,opt,name=failover_ms" json:"failover_ms,omitempty"`
-	Strong              *bool             `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
-	PropertyName        []string          `protobuf:"bytes,33,rep,name=property_name" json:"property_name,omitempty"`
-	GroupByPropertyName []string          `protobuf:"bytes,34,rep,name=group_by_property_name" json:"group_by_property_name,omitempty"`
-	Distinct            *bool             `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
-	MinSafeTimeSeconds  *int64            `protobuf:"varint,35,opt,name=min_safe_time_seconds" json:"min_safe_time_seconds,omitempty"`
-	SafeReplicaName     []string          `protobuf:"bytes,36,rep,name=safe_replica_name" json:"safe_replica_name,omitempty"`
-	PersistOffset       *bool             `protobuf:"varint,37,opt,name=persist_offset,def=0" json:"persist_offset,omitempty"`
-	XXX_unrecognized    []byte            `json:"-"`
-}
-
-func (m *Query) Reset()         { *m = Query{} }
-func (m *Query) String() string { return proto.CompactTextString(m) }
-func (*Query) ProtoMessage()    {}
-
-const Default_Query_Offset int32 = 0
-const Default_Query_RequirePerfectPlan bool = false
-const Default_Query_KeysOnly bool = false
-const Default_Query_Compile bool = false
-const Default_Query_PersistOffset bool = false
-
-func (m *Query) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *Query) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-func (m *Query) GetNameSpace() string {
-	if m != nil && m.NameSpace != nil {
-		return *m.NameSpace
-	}
-	return ""
-}
-
-func (m *Query) GetKind() string {
-	if m != nil && m.Kind != nil {
-		return *m.Kind
-	}
-	return ""
-}
-
-func (m *Query) GetAncestor() *Reference {
-	if m != nil {
-		return m.Ancestor
-	}
-	return nil
-}
-
-func (m *Query) GetFilter() []*Query_Filter {
-	if m != nil {
-		return m.Filter
-	}
-	return nil
-}
-
-func (m *Query) GetSearchQuery() string {
-	if m != nil && m.SearchQuery != nil {
-		return *m.SearchQuery
-	}
-	return ""
-}
-
-func (m *Query) GetOrder() []*Query_Order {
-	if m != nil {
-		return m.Order
-	}
-	return nil
-}
-
-func (m *Query) GetHint() Query_Hint {
-	if m != nil && m.Hint != nil {
-		return *m.Hint
-	}
-	return Query_ORDER_FIRST
-}
-
-func (m *Query) GetCount() int32 {
-	if m != nil && m.Count != nil {
-		return *m.Count
-	}
-	return 0
-}
-
-func (m *Query) GetOffset() int32 {
-	if m != nil && m.Offset != nil {
-		return *m.Offset
-	}
-	return Default_Query_Offset
-}
-
-func (m *Query) GetLimit() int32 {
-	if m != nil && m.Limit != nil {
-		return *m.Limit
-	}
-	return 0
-}
-
-func (m *Query) GetCompiledCursor() *CompiledCursor {
-	if m != nil {
-		return m.CompiledCursor
-	}
-	return nil
-}
-
-func (m *Query) GetEndCompiledCursor() *CompiledCursor {
-	if m != nil {
-		return m.EndCompiledCursor
-	}
-	return nil
-}
-
-func (m *Query) GetCompositeIndex() []*CompositeIndex {
-	if m != nil {
-		return m.CompositeIndex
-	}
-	return nil
-}
-
-func (m *Query) GetRequirePerfectPlan() bool {
-	if m != nil && m.RequirePerfectPlan != nil {
-		return *m.RequirePerfectPlan
-	}
-	return Default_Query_RequirePerfectPlan
-}
-
-func (m *Query) GetKeysOnly() bool {
-	if m != nil && m.KeysOnly != nil {
-		return *m.KeysOnly
-	}
-	return Default_Query_KeysOnly
-}
-
-func (m *Query) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
-func (m *Query) GetCompile() bool {
-	if m != nil && m.Compile != nil {
-		return *m.Compile
-	}
-	return Default_Query_Compile
-}
-
-func (m *Query) GetFailoverMs() int64 {
-	if m != nil && m.FailoverMs != nil {
-		return *m.FailoverMs
-	}
-	return 0
-}
-
-func (m *Query) GetStrong() bool {
-	if m != nil && m.Strong != nil {
-		return *m.Strong
-	}
-	return false
-}
-
-func (m *Query) GetPropertyName() []string {
-	if m != nil {
-		return m.PropertyName
-	}
-	return nil
-}
-
-func (m *Query) GetGroupByPropertyName() []string {
-	if m != nil {
-		return m.GroupByPropertyName
-	}
-	return nil
-}
-
-func (m *Query) GetDistinct() bool {
-	if m != nil && m.Distinct != nil {
-		return *m.Distinct
-	}
-	return false
-}
-
-func (m *Query) GetMinSafeTimeSeconds() int64 {
-	if m != nil && m.MinSafeTimeSeconds != nil {
-		return *m.MinSafeTimeSeconds
-	}
-	return 0
-}
-
-func (m *Query) GetSafeReplicaName() []string {
-	if m != nil {
-		return m.SafeReplicaName
-	}
-	return nil
-}
-
-func (m *Query) GetPersistOffset() bool {
-	if m != nil && m.PersistOffset != nil {
-		return *m.PersistOffset
-	}
-	return Default_Query_PersistOffset
-}
-
-type Query_Filter struct {
-	Op               *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
-	Property         []*Property            `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
-	XXX_unrecognized []byte                 `json:"-"`
-}
-
-func (m *Query_Filter) Reset()         { *m = Query_Filter{} }
-func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
-func (*Query_Filter) ProtoMessage()    {}
-
-func (m *Query_Filter) GetOp() Query_Filter_Operator {
-	if m != nil && m.Op != nil {
-		return *m.Op
-	}
-	return Query_Filter_LESS_THAN
-}
-
-func (m *Query_Filter) GetProperty() []*Property {
-	if m != nil {
-		return m.Property
-	}
-	return nil
-}
-
-type Query_Order struct {
-	Property         *string                `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
-	Direction        *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
-	XXX_unrecognized []byte                 `json:"-"`
-}
-
-func (m *Query_Order) Reset()         { *m = Query_Order{} }
-func (m *Query_Order) String() string { return proto.CompactTextString(m) }
-func (*Query_Order) ProtoMessage()    {}
-
-const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
-
-func (m *Query_Order) GetProperty() string {
-	if m != nil && m.Property != nil {
-		return *m.Property
-	}
-	return ""
-}
-
-func (m *Query_Order) GetDirection() Query_Order_Direction {
-	if m != nil && m.Direction != nil {
-		return *m.Direction
-	}
-	return Default_Query_Order_Direction
-}
-
-type CompiledQuery struct {
-	Primaryscan       *CompiledQuery_PrimaryScan     `protobuf:"group,1,req,name=PrimaryScan" json:"primaryscan,omitempty"`
-	Mergejoinscan     []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan" json:"mergejoinscan,omitempty"`
-	IndexDef          *Index                         `protobuf:"bytes,21,opt,name=index_def" json:"index_def,omitempty"`
-	Offset            *int32                         `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
-	Limit             *int32                         `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
-	KeysOnly          *bool                          `protobuf:"varint,12,req,name=keys_only" json:"keys_only,omitempty"`
-	PropertyName      []string                       `protobuf:"bytes,24,rep,name=property_name" json:"property_name,omitempty"`
-	DistinctInfixSize *int32                         `protobuf:"varint,25,opt,name=distinct_infix_size" json:"distinct_infix_size,omitempty"`
-	Entityfilter      *CompiledQuery_EntityFilter    `protobuf:"group,13,opt,name=EntityFilter" json:"entityfilter,omitempty"`
-	XXX_unrecognized  []byte                         `json:"-"`
-}
-
-func (m *CompiledQuery) Reset()         { *m = CompiledQuery{} }
-func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery) ProtoMessage()    {}
-
-const Default_CompiledQuery_Offset int32 = 0
-
-func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
-	if m != nil {
-		return m.Primaryscan
-	}
-	return nil
-}
-
-func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
-	if m != nil {
-		return m.Mergejoinscan
-	}
-	return nil
-}
-
-func (m *CompiledQuery) GetIndexDef() *Index {
-	if m != nil {
-		return m.IndexDef
-	}
-	return nil
-}
-
-func (m *CompiledQuery) GetOffset() int32 {
-	if m != nil && m.Offset != nil {
-		return *m.Offset
-	}
-	return Default_CompiledQuery_Offset
-}
-
-func (m *CompiledQuery) GetLimit() int32 {
-	if m != nil && m.Limit != nil {
-		return *m.Limit
-	}
-	return 0
-}
-
-func (m *CompiledQuery) GetKeysOnly() bool {
-	if m != nil && m.KeysOnly != nil {
-		return *m.KeysOnly
-	}
-	return false
-}
-
-func (m *CompiledQuery) GetPropertyName() []string {
-	if m != nil {
-		return m.PropertyName
-	}
-	return nil
-}
-
-func (m *CompiledQuery) GetDistinctInfixSize() int32 {
-	if m != nil && m.DistinctInfixSize != nil {
-		return *m.DistinctInfixSize
-	}
-	return 0
-}
-
-func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
-	if m != nil {
-		return m.Entityfilter
-	}
-	return nil
-}
-
-type CompiledQuery_PrimaryScan struct {
-	IndexName                  *string  `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"`
-	StartKey                   *string  `protobuf:"bytes,3,opt,name=start_key" json:"start_key,omitempty"`
-	StartInclusive             *bool    `protobuf:"varint,4,opt,name=start_inclusive" json:"start_inclusive,omitempty"`
-	EndKey                     *string  `protobuf:"bytes,5,opt,name=end_key" json:"end_key,omitempty"`
-	EndInclusive               *bool    `protobuf:"varint,6,opt,name=end_inclusive" json:"end_inclusive,omitempty"`
-	StartPostfixValue          []string `protobuf:"bytes,22,rep,name=start_postfix_value" json:"start_postfix_value,omitempty"`
-	EndPostfixValue            []string `protobuf:"bytes,23,rep,name=end_postfix_value" json:"end_postfix_value,omitempty"`
-	EndUnappliedLogTimestampUs *int64   `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us" json:"end_unapplied_log_timestamp_us,omitempty"`
-	XXX_unrecognized           []byte   `json:"-"`
-}
-
-func (m *CompiledQuery_PrimaryScan) Reset()         { *m = CompiledQuery_PrimaryScan{} }
-func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_PrimaryScan) ProtoMessage()    {}
-
-func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
-	if m != nil && m.IndexName != nil {
-		return *m.IndexName
-	}
-	return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
-	if m != nil && m.StartKey != nil {
-		return *m.StartKey
-	}
-	return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
-	if m != nil && m.StartInclusive != nil {
-		return *m.StartInclusive
-	}
-	return false
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
-	if m != nil && m.EndKey != nil {
-		return *m.EndKey
-	}
-	return ""
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
-	if m != nil && m.EndInclusive != nil {
-		return *m.EndInclusive
-	}
-	return false
-}
-
-func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
-	if m != nil {
-		return m.StartPostfixValue
-	}
-	return nil
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
-	if m != nil {
-		return m.EndPostfixValue
-	}
-	return nil
-}
-
-func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
-	if m != nil && m.EndUnappliedLogTimestampUs != nil {
-		return *m.EndUnappliedLogTimestampUs
-	}
-	return 0
-}
-
-type CompiledQuery_MergeJoinScan struct {
-	IndexName        *string  `protobuf:"bytes,8,req,name=index_name" json:"index_name,omitempty"`
-	PrefixValue      []string `protobuf:"bytes,9,rep,name=prefix_value" json:"prefix_value,omitempty"`
-	ValuePrefix      *bool    `protobuf:"varint,20,opt,name=value_prefix,def=0" json:"value_prefix,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *CompiledQuery_MergeJoinScan) Reset()         { *m = CompiledQuery_MergeJoinScan{} }
-func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_MergeJoinScan) ProtoMessage()    {}
-
-const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
-
-func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
-	if m != nil && m.IndexName != nil {
-		return *m.IndexName
-	}
-	return ""
-}
-
-func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
-	if m != nil {
-		return m.PrefixValue
-	}
-	return nil
-}
-
-func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
-	if m != nil && m.ValuePrefix != nil {
-		return *m.ValuePrefix
-	}
-	return Default_CompiledQuery_MergeJoinScan_ValuePrefix
-}
-
-type CompiledQuery_EntityFilter struct {
-	Distinct         *bool      `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
-	Kind             *string    `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
-	Ancestor         *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
-	XXX_unrecognized []byte     `json:"-"`
-}
-
-func (m *CompiledQuery_EntityFilter) Reset()         { *m = CompiledQuery_EntityFilter{} }
-func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
-func (*CompiledQuery_EntityFilter) ProtoMessage()    {}
-
-const Default_CompiledQuery_EntityFilter_Distinct bool = false
-
-func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
-	if m != nil && m.Distinct != nil {
-		return *m.Distinct
-	}
-	return Default_CompiledQuery_EntityFilter_Distinct
-}
-
-func (m *CompiledQuery_EntityFilter) GetKind() string {
-	if m != nil && m.Kind != nil {
-		return *m.Kind
-	}
-	return ""
-}
-
-func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
-	if m != nil {
-		return m.Ancestor
-	}
-	return nil
-}
-
-type CompiledCursor struct {
-	Position         *CompiledCursor_Position `protobuf:"group,2,opt,name=Position" json:"position,omitempty"`
-	XXX_unrecognized []byte                   `json:"-"`
-}
-
-func (m *CompiledCursor) Reset()         { *m = CompiledCursor{} }
-func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor) ProtoMessage()    {}
-
-func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
-	if m != nil {
-		return m.Position
-	}
-	return nil
-}
-
-type CompiledCursor_Position struct {
-	StartKey         *string                               `protobuf:"bytes,27,opt,name=start_key" json:"start_key,omitempty"`
-	Indexvalue       []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue" json:"indexvalue,omitempty"`
-	Key              *Reference                            `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
-	StartInclusive   *bool                                 `protobuf:"varint,28,opt,name=start_inclusive,def=1" json:"start_inclusive,omitempty"`
-	XXX_unrecognized []byte                                `json:"-"`
-}
-
-func (m *CompiledCursor_Position) Reset()         { *m = CompiledCursor_Position{} }
-func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor_Position) ProtoMessage()    {}
-
-const Default_CompiledCursor_Position_StartInclusive bool = true
-
-func (m *CompiledCursor_Position) GetStartKey() string {
-	if m != nil && m.StartKey != nil {
-		return *m.StartKey
-	}
-	return ""
-}
-
-func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
-	if m != nil {
-		return m.Indexvalue
-	}
-	return nil
-}
-
-func (m *CompiledCursor_Position) GetKey() *Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *CompiledCursor_Position) GetStartInclusive() bool {
-	if m != nil && m.StartInclusive != nil {
-		return *m.StartInclusive
-	}
-	return Default_CompiledCursor_Position_StartInclusive
-}
-
-type CompiledCursor_Position_IndexValue struct {
-	Property         *string        `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
-	Value            *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
-	XXX_unrecognized []byte         `json:"-"`
-}
-
-func (m *CompiledCursor_Position_IndexValue) Reset()         { *m = CompiledCursor_Position_IndexValue{} }
-func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
-func (*CompiledCursor_Position_IndexValue) ProtoMessage()    {}
-
-func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
-	if m != nil && m.Property != nil {
-		return *m.Property
-	}
-	return ""
-}
-
-func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-type Cursor struct {
-	Cursor           *uint64 `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
-	App              *string `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Cursor) Reset()         { *m = Cursor{} }
-func (m *Cursor) String() string { return proto.CompactTextString(m) }
-func (*Cursor) ProtoMessage()    {}
-
-func (m *Cursor) GetCursor() uint64 {
-	if m != nil && m.Cursor != nil {
-		return *m.Cursor
-	}
-	return 0
-}
-
-func (m *Cursor) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-type Error struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *Error) Reset()         { *m = Error{} }
-func (m *Error) String() string { return proto.CompactTextString(m) }
-func (*Error) ProtoMessage()    {}
-
-type Cost struct {
-	IndexWrites             *int32           `protobuf:"varint,1,opt,name=index_writes" json:"index_writes,omitempty"`
-	IndexWriteBytes         *int32           `protobuf:"varint,2,opt,name=index_write_bytes" json:"index_write_bytes,omitempty"`
-	EntityWrites            *int32           `protobuf:"varint,3,opt,name=entity_writes" json:"entity_writes,omitempty"`
-	EntityWriteBytes        *int32           `protobuf:"varint,4,opt,name=entity_write_bytes" json:"entity_write_bytes,omitempty"`
-	Commitcost              *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost" json:"commitcost,omitempty"`
-	ApproximateStorageDelta *int32           `protobuf:"varint,8,opt,name=approximate_storage_delta" json:"approximate_storage_delta,omitempty"`
-	IdSequenceUpdates       *int32           `protobuf:"varint,9,opt,name=id_sequence_updates" json:"id_sequence_updates,omitempty"`
-	XXX_unrecognized        []byte           `json:"-"`
-}
-
-func (m *Cost) Reset()         { *m = Cost{} }
-func (m *Cost) String() string { return proto.CompactTextString(m) }
-func (*Cost) ProtoMessage()    {}
-
-func (m *Cost) GetIndexWrites() int32 {
-	if m != nil && m.IndexWrites != nil {
-		return *m.IndexWrites
-	}
-	return 0
-}
-
-func (m *Cost) GetIndexWriteBytes() int32 {
-	if m != nil && m.IndexWriteBytes != nil {
-		return *m.IndexWriteBytes
-	}
-	return 0
-}
-
-func (m *Cost) GetEntityWrites() int32 {
-	if m != nil && m.EntityWrites != nil {
-		return *m.EntityWrites
-	}
-	return 0
-}
-
-func (m *Cost) GetEntityWriteBytes() int32 {
-	if m != nil && m.EntityWriteBytes != nil {
-		return *m.EntityWriteBytes
-	}
-	return 0
-}
-
-func (m *Cost) GetCommitcost() *Cost_CommitCost {
-	if m != nil {
-		return m.Commitcost
-	}
-	return nil
-}
-
-func (m *Cost) GetApproximateStorageDelta() int32 {
-	if m != nil && m.ApproximateStorageDelta != nil {
-		return *m.ApproximateStorageDelta
-	}
-	return 0
-}
-
-func (m *Cost) GetIdSequenceUpdates() int32 {
-	if m != nil && m.IdSequenceUpdates != nil {
-		return *m.IdSequenceUpdates
-	}
-	return 0
-}
-
-type Cost_CommitCost struct {
-	RequestedEntityPuts    *int32 `protobuf:"varint,6,opt,name=requested_entity_puts" json:"requested_entity_puts,omitempty"`
-	RequestedEntityDeletes *int32 `protobuf:"varint,7,opt,name=requested_entity_deletes" json:"requested_entity_deletes,omitempty"`
-	XXX_unrecognized       []byte `json:"-"`
-}
-
-func (m *Cost_CommitCost) Reset()         { *m = Cost_CommitCost{} }
-func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
-func (*Cost_CommitCost) ProtoMessage()    {}
-
-func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
-	if m != nil && m.RequestedEntityPuts != nil {
-		return *m.RequestedEntityPuts
-	}
-	return 0
-}
-
-func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
-	if m != nil && m.RequestedEntityDeletes != nil {
-		return *m.RequestedEntityDeletes
-	}
-	return 0
-}
-
-type GetRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
-	Key              []*Reference    `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
-	Transaction      *Transaction    `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
-	FailoverMs       *int64          `protobuf:"varint,3,opt,name=failover_ms" json:"failover_ms,omitempty"`
-	Strong           *bool           `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
-	AllowDeferred    *bool           `protobuf:"varint,5,opt,name=allow_deferred,def=0" json:"allow_deferred,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *GetRequest) Reset()         { *m = GetRequest{} }
-func (m *GetRequest) String() string { return proto.CompactTextString(m) }
-func (*GetRequest) ProtoMessage()    {}
-
-const Default_GetRequest_AllowDeferred bool = false
-
-func (m *GetRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *GetRequest) GetKey() []*Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *GetRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
-func (m *GetRequest) GetFailoverMs() int64 {
-	if m != nil && m.FailoverMs != nil {
-		return *m.FailoverMs
-	}
-	return 0
-}
-
-func (m *GetRequest) GetStrong() bool {
-	if m != nil && m.Strong != nil {
-		return *m.Strong
-	}
-	return false
-}
-
-func (m *GetRequest) GetAllowDeferred() bool {
-	if m != nil && m.AllowDeferred != nil {
-		return *m.AllowDeferred
-	}
-	return Default_GetRequest_AllowDeferred
-}
-
-type GetResponse struct {
-	Entity           []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity" json:"entity,omitempty"`
-	Deferred         []*Reference          `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
-	InOrder          *bool                 `protobuf:"varint,6,opt,name=in_order,def=1" json:"in_order,omitempty"`
-	XXX_unrecognized []byte                `json:"-"`
-}
-
-func (m *GetResponse) Reset()         { *m = GetResponse{} }
-func (m *GetResponse) String() string { return proto.CompactTextString(m) }
-func (*GetResponse) ProtoMessage()    {}
-
-const Default_GetResponse_InOrder bool = true
-
-func (m *GetResponse) GetEntity() []*GetResponse_Entity {
-	if m != nil {
-		return m.Entity
-	}
-	return nil
-}
-
-func (m *GetResponse) GetDeferred() []*Reference {
-	if m != nil {
-		return m.Deferred
-	}
-	return nil
-}
-
-func (m *GetResponse) GetInOrder() bool {
-	if m != nil && m.InOrder != nil {
-		return *m.InOrder
-	}
-	return Default_GetResponse_InOrder
-}
-
-type GetResponse_Entity struct {
-	Entity           *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
-	Key              *Reference   `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
-	Version          *int64       `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte       `json:"-"`
-}
-
-func (m *GetResponse_Entity) Reset()         { *m = GetResponse_Entity{} }
-func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
-func (*GetResponse_Entity) ProtoMessage()    {}
-
-func (m *GetResponse_Entity) GetEntity() *EntityProto {
-	if m != nil {
-		return m.Entity
-	}
-	return nil
-}
-
-func (m *GetResponse_Entity) GetKey() *Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *GetResponse_Entity) GetVersion() int64 {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return 0
-}
-
-type PutRequest struct {
-	Header           *InternalHeader          `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
-	Entity           []*EntityProto           `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
-	Transaction      *Transaction             `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
-	CompositeIndex   []*CompositeIndex        `protobuf:"bytes,3,rep,name=composite_index" json:"composite_index,omitempty"`
-	Trusted          *bool                    `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
-	Force            *bool                    `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
-	MarkChanges      *bool                    `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
-	Snapshot         []*Snapshot              `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
-	AutoIdPolicy     *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
-	XXX_unrecognized []byte                   `json:"-"`
-}
-
-func (m *PutRequest) Reset()         { *m = PutRequest{} }
-func (m *PutRequest) String() string { return proto.CompactTextString(m) }
-func (*PutRequest) ProtoMessage()    {}
-
-const Default_PutRequest_Trusted bool = false
-const Default_PutRequest_Force bool = false
-const Default_PutRequest_MarkChanges bool = false
-const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
-
-func (m *PutRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *PutRequest) GetEntity() []*EntityProto {
-	if m != nil {
-		return m.Entity
-	}
-	return nil
-}
-
-func (m *PutRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
-func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
-	if m != nil {
-		return m.CompositeIndex
-	}
-	return nil
-}
-
-func (m *PutRequest) GetTrusted() bool {
-	if m != nil && m.Trusted != nil {
-		return *m.Trusted
-	}
-	return Default_PutRequest_Trusted
-}
-
-func (m *PutRequest) GetForce() bool {
-	if m != nil && m.Force != nil {
-		return *m.Force
-	}
-	return Default_PutRequest_Force
-}
-
-func (m *PutRequest) GetMarkChanges() bool {
-	if m != nil && m.MarkChanges != nil {
-		return *m.MarkChanges
-	}
-	return Default_PutRequest_MarkChanges
-}
-
-func (m *PutRequest) GetSnapshot() []*Snapshot {
-	if m != nil {
-		return m.Snapshot
-	}
-	return nil
-}
-
-func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
-	if m != nil && m.AutoIdPolicy != nil {
-		return *m.AutoIdPolicy
-	}
-	return Default_PutRequest_AutoIdPolicy
-}
-
-type PutResponse struct {
-	Key              []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
-	Cost             *Cost        `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
-	Version          []int64      `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte       `json:"-"`
-}
-
-func (m *PutResponse) Reset()         { *m = PutResponse{} }
-func (m *PutResponse) String() string { return proto.CompactTextString(m) }
-func (*PutResponse) ProtoMessage()    {}
-
-func (m *PutResponse) GetKey() []*Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *PutResponse) GetCost() *Cost {
-	if m != nil {
-		return m.Cost
-	}
-	return nil
-}
-
-func (m *PutResponse) GetVersion() []int64 {
-	if m != nil {
-		return m.Version
-	}
-	return nil
-}
-
-type TouchRequest struct {
-	Header           *InternalHeader   `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
-	Key              []*Reference      `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
-	CompositeIndex   []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index" json:"composite_index,omitempty"`
-	Force            *bool             `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
-	Snapshot         []*Snapshot       `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *TouchRequest) Reset()         { *m = TouchRequest{} }
-func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
-func (*TouchRequest) ProtoMessage()    {}
-
-const Default_TouchRequest_Force bool = false
-
-func (m *TouchRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *TouchRequest) GetKey() []*Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
-	if m != nil {
-		return m.CompositeIndex
-	}
-	return nil
-}
-
-func (m *TouchRequest) GetForce() bool {
-	if m != nil && m.Force != nil {
-		return *m.Force
-	}
-	return Default_TouchRequest_Force
-}
-
-func (m *TouchRequest) GetSnapshot() []*Snapshot {
-	if m != nil {
-		return m.Snapshot
-	}
-	return nil
-}
-
-type TouchResponse struct {
-	Cost             *Cost  `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *TouchResponse) Reset()         { *m = TouchResponse{} }
-func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
-func (*TouchResponse) ProtoMessage()    {}
-
-func (m *TouchResponse) GetCost() *Cost {
-	if m != nil {
-		return m.Cost
-	}
-	return nil
-}
-
-type DeleteRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
-	Key              []*Reference    `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
-	Transaction      *Transaction    `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
-	Trusted          *bool           `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
-	Force            *bool           `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
-	MarkChanges      *bool           `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
-	Snapshot         []*Snapshot     `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *DeleteRequest) Reset()         { *m = DeleteRequest{} }
-func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
-func (*DeleteRequest) ProtoMessage()    {}
-
-const Default_DeleteRequest_Trusted bool = false
-const Default_DeleteRequest_Force bool = false
-const Default_DeleteRequest_MarkChanges bool = false
-
-func (m *DeleteRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *DeleteRequest) GetKey() []*Reference {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *DeleteRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
-func (m *DeleteRequest) GetTrusted() bool {
-	if m != nil && m.Trusted != nil {
-		return *m.Trusted
-	}
-	return Default_DeleteRequest_Trusted
-}
-
-func (m *DeleteRequest) GetForce() bool {
-	if m != nil && m.Force != nil {
-		return *m.Force
-	}
-	return Default_DeleteRequest_Force
-}
-
-func (m *DeleteRequest) GetMarkChanges() bool {
-	if m != nil && m.MarkChanges != nil {
-		return *m.MarkChanges
-	}
-	return Default_DeleteRequest_MarkChanges
-}
-
-func (m *DeleteRequest) GetSnapshot() []*Snapshot {
-	if m != nil {
-		return m.Snapshot
-	}
-	return nil
-}
-
-type DeleteResponse struct {
-	Cost             *Cost   `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
-	Version          []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *DeleteResponse) Reset()         { *m = DeleteResponse{} }
-func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
-func (*DeleteResponse) ProtoMessage()    {}
-
-func (m *DeleteResponse) GetCost() *Cost {
-	if m != nil {
-		return m.Cost
-	}
-	return nil
-}
-
-func (m *DeleteResponse) GetVersion() []int64 {
-	if m != nil {
-		return m.Version
-	}
-	return nil
-}
-
-type NextRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
-	Cursor           *Cursor         `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
-	Count            *int32          `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
-	Offset           *int32          `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
-	Compile          *bool           `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *NextRequest) Reset()         { *m = NextRequest{} }
-func (m *NextRequest) String() string { return proto.CompactTextString(m) }
-func (*NextRequest) ProtoMessage()    {}
-
-const Default_NextRequest_Offset int32 = 0
-const Default_NextRequest_Compile bool = false
-
-func (m *NextRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *NextRequest) GetCursor() *Cursor {
-	if m != nil {
-		return m.Cursor
-	}
-	return nil
-}
-
-func (m *NextRequest) GetCount() int32 {
-	if m != nil && m.Count != nil {
-		return *m.Count
-	}
-	return 0
-}
-
-func (m *NextRequest) GetOffset() int32 {
-	if m != nil && m.Offset != nil {
-		return *m.Offset
-	}
-	return Default_NextRequest_Offset
-}
-
-func (m *NextRequest) GetCompile() bool {
-	if m != nil && m.Compile != nil {
-		return *m.Compile
-	}
-	return Default_NextRequest_Compile
-}
-
-type QueryResult struct {
-	Cursor           *Cursor           `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
-	Result           []*EntityProto    `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
-	SkippedResults   *int32            `protobuf:"varint,7,opt,name=skipped_results" json:"skipped_results,omitempty"`
-	MoreResults      *bool             `protobuf:"varint,3,req,name=more_results" json:"more_results,omitempty"`
-	KeysOnly         *bool             `protobuf:"varint,4,opt,name=keys_only" json:"keys_only,omitempty"`
-	IndexOnly        *bool             `protobuf:"varint,9,opt,name=index_only" json:"index_only,omitempty"`
-	SmallOps         *bool             `protobuf:"varint,10,opt,name=small_ops" json:"small_ops,omitempty"`
-	CompiledQuery    *CompiledQuery    `protobuf:"bytes,5,opt,name=compiled_query" json:"compiled_query,omitempty"`
-	CompiledCursor   *CompiledCursor   `protobuf:"bytes,6,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"`
-	Index            []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
-	Version          []int64           `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *QueryResult) Reset()         { *m = QueryResult{} }
-func (m *QueryResult) String() string { return proto.CompactTextString(m) }
-func (*QueryResult) ProtoMessage()    {}
-
-func (m *QueryResult) GetCursor() *Cursor {
-	if m != nil {
-		return m.Cursor
-	}
-	return nil
-}
-
-func (m *QueryResult) GetResult() []*EntityProto {
-	if m != nil {
-		return m.Result
-	}
-	return nil
-}
-
-func (m *QueryResult) GetSkippedResults() int32 {
-	if m != nil && m.SkippedResults != nil {
-		return *m.SkippedResults
-	}
-	return 0
-}
-
-func (m *QueryResult) GetMoreResults() bool {
-	if m != nil && m.MoreResults != nil {
-		return *m.MoreResults
-	}
-	return false
-}
-
-func (m *QueryResult) GetKeysOnly() bool {
-	if m != nil && m.KeysOnly != nil {
-		return *m.KeysOnly
-	}
-	return false
-}
-
-func (m *QueryResult) GetIndexOnly() bool {
-	if m != nil && m.IndexOnly != nil {
-		return *m.IndexOnly
-	}
-	return false
-}
-
-func (m *QueryResult) GetSmallOps() bool {
-	if m != nil && m.SmallOps != nil {
-		return *m.SmallOps
-	}
-	return false
-}
-
-func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
-	if m != nil {
-		return m.CompiledQuery
-	}
-	return nil
-}
-
-func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
-	if m != nil {
-		return m.CompiledCursor
-	}
-	return nil
-}
-
-func (m *QueryResult) GetIndex() []*CompositeIndex {
-	if m != nil {
-		return m.Index
-	}
-	return nil
-}
-
-func (m *QueryResult) GetVersion() []int64 {
-	if m != nil {
-		return m.Version
-	}
-	return nil
-}
-
-type AllocateIdsRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
-	ModelKey         *Reference      `protobuf:"bytes,1,opt,name=model_key" json:"model_key,omitempty"`
-	Size             *int64          `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
-	Max              *int64          `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
-	Reserve          []*Reference    `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *AllocateIdsRequest) Reset()         { *m = AllocateIdsRequest{} }
-func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
-func (*AllocateIdsRequest) ProtoMessage()    {}
-
-func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *AllocateIdsRequest) GetModelKey() *Reference {
-	if m != nil {
-		return m.ModelKey
-	}
-	return nil
-}
-
-func (m *AllocateIdsRequest) GetSize() int64 {
-	if m != nil && m.Size != nil {
-		return *m.Size
-	}
-	return 0
-}
-
-func (m *AllocateIdsRequest) GetMax() int64 {
-	if m != nil && m.Max != nil {
-		return *m.Max
-	}
-	return 0
-}
-
-func (m *AllocateIdsRequest) GetReserve() []*Reference {
-	if m != nil {
-		return m.Reserve
-	}
-	return nil
-}
-
-type AllocateIdsResponse struct {
-	Start            *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
-	End              *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
-	Cost             *Cost  `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *AllocateIdsResponse) Reset()         { *m = AllocateIdsResponse{} }
-func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
-func (*AllocateIdsResponse) ProtoMessage()    {}
-
-func (m *AllocateIdsResponse) GetStart() int64 {
-	if m != nil && m.Start != nil {
-		return *m.Start
-	}
-	return 0
-}
-
-func (m *AllocateIdsResponse) GetEnd() int64 {
-	if m != nil && m.End != nil {
-		return *m.End
-	}
-	return 0
-}
-
-func (m *AllocateIdsResponse) GetCost() *Cost {
-	if m != nil {
-		return m.Cost
-	}
-	return nil
-}
-
-type CompositeIndices struct {
-	Index            []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *CompositeIndices) Reset()         { *m = CompositeIndices{} }
-func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
-func (*CompositeIndices) ProtoMessage()    {}
-
-func (m *CompositeIndices) GetIndex() []*CompositeIndex {
-	if m != nil {
-		return m.Index
-	}
-	return nil
-}
-
-type AddActionsRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
-	Transaction      *Transaction    `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
-	Action           []*Action       `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *AddActionsRequest) Reset()         { *m = AddActionsRequest{} }
-func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
-func (*AddActionsRequest) ProtoMessage()    {}
-
-func (m *AddActionsRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *AddActionsRequest) GetTransaction() *Transaction {
-	if m != nil {
-		return m.Transaction
-	}
-	return nil
-}
-
-func (m *AddActionsRequest) GetAction() []*Action {
-	if m != nil {
-		return m.Action
-	}
-	return nil
-}
-
-type AddActionsResponse struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *AddActionsResponse) Reset()         { *m = AddActionsResponse{} }
-func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
-func (*AddActionsResponse) ProtoMessage()    {}
-
-type BeginTransactionRequest struct {
-	Header           *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
-	App              *string         `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
-	AllowMultipleEg  *bool           `protobuf:"varint,2,opt,name=allow_multiple_eg,def=0" json:"allow_multiple_eg,omitempty"`
-	XXX_unrecognized []byte          `json:"-"`
-}
-
-func (m *BeginTransactionRequest) Reset()         { *m = BeginTransactionRequest{} }
-func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
-func (*BeginTransactionRequest) ProtoMessage()    {}
-
-const Default_BeginTransactionRequest_AllowMultipleEg bool = false
-
-func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
-	if m != nil {
-		return m.Header
-	}
-	return nil
-}
-
-func (m *BeginTransactionRequest) GetApp() string {
-	if m != nil && m.App != nil {
-		return *m.App
-	}
-	return ""
-}
-
-func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
-	if m != nil && m.AllowMultipleEg != nil {
-		return *m.AllowMultipleEg
-	}
-	return Default_BeginTransactionRequest_AllowMultipleEg
-}
-
-type CommitResponse struct {
-	Cost             *Cost                     `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
-	Version          []*CommitResponse_Version `protobuf:"group,3,rep,name=Version" json:"version,omitempty"`
-	XXX_unrecognized []byte                    `json:"-"`
-}
-
-func (m *CommitResponse) Reset()         { *m = CommitResponse{} }
-func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
-func (*CommitResponse) ProtoMessage()    {}
-
-func (m *CommitResponse) GetCost() *Cost {
-	if m != nil {
-		return m.Cost
-	}
-	return nil
-}
-
-func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
-	if m != nil {
-		return m.Version
-	}
-	return nil
-}
-
-type CommitResponse_Version struct {
-	RootEntityKey    *Reference `protobuf:"bytes,4,req,name=root_entity_key" json:"root_entity_key,omitempty"`
-	Version          *int64     `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte     `json:"-"`
-}
-
-func (m *CommitResponse_Version) Reset()         { *m = CommitResponse_Version{} }
-func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
-func (*CommitResponse_Version) ProtoMessage()    {}
-
-func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
-	if m != nil {
-		return m.RootEntityKey
-	}
-	return nil
-}
-
-func (m *CommitResponse_Version) GetVersion() int64 {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return 0
-}
-
-func init() {
-}
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
deleted file mode 100755
index e76f126ff7c6a3dc58ff2e4e2d0323d93529cb10..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
+++ /dev/null
@@ -1,541 +0,0 @@
-syntax = "proto2";
-option go_package = "datastore";
-
-package appengine;
-
-message Action{}
-
-message PropertyValue {
-  optional int64 int64Value = 1;
-  optional bool booleanValue = 2;
-  optional string stringValue = 3;
-  optional double doubleValue = 4;
-
-  optional group PointValue = 5 {
-    required double x = 6;
-    required double y = 7;
-  }
-
-  optional group UserValue = 8 {
-    required string email = 9;
-    required string auth_domain = 10;
-    optional string nickname = 11;
-    optional string federated_identity = 21;
-    optional string federated_provider = 22;
-  }
-
-  optional group ReferenceValue = 12 {
-    required string app = 13;
-    optional string name_space = 20;
-    repeated group PathElement = 14 {
-      required string type = 15;
-      optional int64 id = 16;
-      optional string name = 17;
-    }
-  }
-}
-
-message Property {
-  enum Meaning {
-    NO_MEANING = 0;
-    BLOB = 14;
-    TEXT = 15;
-    BYTESTRING = 16;
-
-    ATOM_CATEGORY = 1;
-    ATOM_LINK = 2;
-    ATOM_TITLE = 3;
-    ATOM_CONTENT = 4;
-    ATOM_SUMMARY = 5;
-    ATOM_AUTHOR = 6;
-
-    GD_WHEN = 7;
-    GD_EMAIL = 8;
-    GEORSS_POINT = 9;
-    GD_IM = 10;
-
-    GD_PHONENUMBER = 11;
-    GD_POSTALADDRESS = 12;
-
-    GD_RATING = 13;
-
-    BLOBKEY = 17;
-    ENTITY_PROTO = 19;
-
-    INDEX_VALUE = 18;
-  };
-
-  optional Meaning meaning = 1 [default = NO_MEANING];
-  optional string meaning_uri = 2;
-
-  required string name = 3;
-
-  required PropertyValue value = 5;
-
-  required bool multiple = 4;
-
-  optional bool searchable = 6 [default=false];
-
-  enum FtsTokenizationOption {
-    HTML = 1;
-    ATOM = 2;
-  }
-
-  optional FtsTokenizationOption fts_tokenization_option = 8;
-
-  optional string locale = 9 [default = "en"];
-}
-
-message Path {
-  repeated group Element = 1 {
-    required string type = 2;
-    optional int64 id = 3;
-    optional string name = 4;
-  }
-}
-
-message Reference {
-  required string app = 13;
-  optional string name_space = 20;
-  required Path path = 14;
-}
-
-message User {
-  required string email = 1;
-  required string auth_domain = 2;
-  optional string nickname = 3;
-  optional string federated_identity = 6;
-  optional string federated_provider = 7;
-}
-
-message EntityProto {
-  required Reference key = 13;
-  required Path entity_group = 16;
-  optional User owner = 17;
-
-  enum Kind {
-    GD_CONTACT = 1;
-    GD_EVENT = 2;
-    GD_MESSAGE = 3;
-  }
-  optional Kind kind = 4;
-  optional string kind_uri = 5;
-
-  repeated Property property = 14;
-  repeated Property raw_property = 15;
-
-  optional int32 rank = 18;
-}
-
-message CompositeProperty {
-  required int64 index_id = 1;
-  repeated string value = 2;
-}
-
-message Index {
-  required string entity_type = 1;
-  required bool ancestor = 5;
-  repeated group Property = 2 {
-    required string name = 3;
-    enum Direction {
-      ASCENDING = 1;
-      DESCENDING = 2;
-    }
-    optional Direction direction = 4 [default = ASCENDING];
-  }
-}
-
-message CompositeIndex {
-  required string app_id = 1;
-  required int64 id = 2;
-  required Index definition = 3;
-
-  enum State {
-    WRITE_ONLY = 1;
-    READ_WRITE = 2;
-    DELETED = 3;
-    ERROR = 4;
-  }
-  required State state = 4;
-
-  optional bool only_use_if_required = 6 [default = false];
-}
-
-message IndexPostfix {
-  message IndexValue {
-    required string property_name = 1;
-    required PropertyValue value = 2;
-  }
-
-  repeated IndexValue index_value = 1;
-
-  optional Reference key = 2;
-
-  optional bool before = 3 [default=true];
-}
-
-message IndexPosition {
-  optional string key = 1;
-
-  optional bool before = 2 [default=true];
-}
-
-message Snapshot {
-  enum Status {
-    INACTIVE = 0;
-    ACTIVE = 1;
-  }
-
-  required int64 ts = 1;
-}
-
-message InternalHeader {
-  optional string qos = 1;
-}
-
-message Transaction {
-  optional InternalHeader header = 4;
-  required fixed64 handle = 1;
-  required string app = 2;
-  optional bool mark_changes = 3 [default = false];
-}
-
-message Query {
-  optional InternalHeader header = 39;
-
-  required string app = 1;
-  optional string name_space = 29;
-
-  optional string kind = 3;
-  optional Reference ancestor = 17;
-
-  repeated group Filter = 4 {
-    enum Operator {
-      LESS_THAN = 1;
-      LESS_THAN_OR_EQUAL = 2;
-      GREATER_THAN = 3;
-      GREATER_THAN_OR_EQUAL = 4;
-      EQUAL = 5;
-      IN = 6;
-      EXISTS = 7;
-    }
-
-    required Operator op = 6;
-    repeated Property property = 14;
-  }
-
-  optional string search_query = 8;
-
-  repeated group Order = 9 {
-    enum Direction {
-      ASCENDING = 1;
-      DESCENDING = 2;
-    }
-
-    required string property = 10;
-    optional Direction direction = 11 [default = ASCENDING];
-  }
-
-  enum Hint {
-    ORDER_FIRST = 1;
-    ANCESTOR_FIRST = 2;
-    FILTER_FIRST = 3;
-  }
-  optional Hint hint = 18;
-
-  optional int32 count = 23;
-
-  optional int32 offset = 12 [default = 0];
-
-  optional int32 limit = 16;
-
-  optional CompiledCursor compiled_cursor = 30;
-  optional CompiledCursor end_compiled_cursor = 31;
-
-  repeated CompositeIndex composite_index = 19;
-
-  optional bool require_perfect_plan = 20 [default = false];
-
-  optional bool keys_only = 21 [default = false];
-
-  optional Transaction transaction = 22;
-
-  optional bool compile = 25 [default = false];
-
-  optional int64 failover_ms = 26;
-
-  optional bool strong = 32;
-
-  repeated string property_name = 33;
-
-  repeated string group_by_property_name = 34;
-
-  optional bool distinct = 24;
-
-  optional int64 min_safe_time_seconds = 35;
-
-  repeated string safe_replica_name = 36;
-
-  optional bool persist_offset = 37 [default=false];
-}
-
-message CompiledQuery {
-  required group PrimaryScan = 1 {
-    optional string index_name = 2;
-
-    optional string start_key = 3;
-    optional bool start_inclusive = 4;
-    optional string end_key = 5;
-    optional bool end_inclusive = 6;
-
-    repeated string start_postfix_value = 22;
-    repeated string end_postfix_value = 23;
-
-    optional int64 end_unapplied_log_timestamp_us = 19;
-  }
-
-  repeated group MergeJoinScan = 7 {
-    required string index_name = 8;
-
-    repeated string prefix_value = 9;
-
-    optional bool value_prefix = 20 [default=false];
-  }
-
-  optional Index index_def = 21;
-
-  optional int32 offset = 10 [default = 0];
-
-  optional int32 limit = 11;
-
-  required bool keys_only = 12;
-
-  repeated string property_name = 24;
-
-  optional int32 distinct_infix_size = 25;
-
-  optional group EntityFilter = 13 {
-    optional bool distinct = 14 [default=false];
-
-    optional string kind = 17;
-    optional Reference ancestor = 18;
-  }
-}
-
-message CompiledCursor {
-  optional group Position = 2 {
-    optional string start_key = 27;
-
-    repeated group IndexValue = 29 {
-      optional string property = 30;
-      required PropertyValue value = 31;
-    }
-
-    optional Reference key = 32;
-
-    optional bool start_inclusive = 28 [default=true];
-  }
-}
-
-message Cursor {
-  required fixed64 cursor = 1;
-
-  optional string app = 2;
-}
-
-message Error {
-  enum ErrorCode {
-    BAD_REQUEST = 1;
-    CONCURRENT_TRANSACTION = 2;
-    INTERNAL_ERROR = 3;
-    NEED_INDEX = 4;
-    TIMEOUT = 5;
-    PERMISSION_DENIED = 6;
-    BIGTABLE_ERROR = 7;
-    COMMITTED_BUT_STILL_APPLYING = 8;
-    CAPABILITY_DISABLED = 9;
-    TRY_ALTERNATE_BACKEND = 10;
-    SAFE_TIME_TOO_OLD = 11;
-  }
-}
-
-message Cost {
-  optional int32 index_writes = 1;
-  optional int32 index_write_bytes = 2;
-  optional int32 entity_writes = 3;
-  optional int32 entity_write_bytes = 4;
-  optional group CommitCost = 5 {
-    optional int32 requested_entity_puts = 6;
-    optional int32 requested_entity_deletes = 7;
-  };
-  optional int32 approximate_storage_delta = 8;
-  optional int32 id_sequence_updates = 9;
-}
-
-message GetRequest {
-  optional InternalHeader header = 6;
-
-  repeated Reference key = 1;
-  optional Transaction transaction = 2;
-
-  optional int64 failover_ms = 3;
-
-  optional bool strong = 4;
-
-  optional bool allow_deferred = 5 [default=false];
-}
-
-message GetResponse {
-  repeated group Entity = 1 {
-    optional EntityProto entity = 2;
-    optional Reference key = 4;
-
-    optional int64 version = 3;
-  }
-
-  repeated Reference deferred = 5;
-
-  optional bool in_order = 6 [default=true];
-}
-
-message PutRequest {
-  optional InternalHeader header = 11;
-
-  repeated EntityProto entity = 1;
-  optional Transaction transaction = 2;
-  repeated CompositeIndex composite_index = 3;
-
-  optional bool trusted = 4 [default = false];
-
-  optional bool force = 7 [default = false];
-
-  optional bool mark_changes = 8 [default = false];
-  repeated Snapshot snapshot = 9;
-
-  enum AutoIdPolicy {
-    CURRENT = 0;
-    SEQUENTIAL = 1;
-  }
-  optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT];
-}
-
-message PutResponse {
-  repeated Reference key = 1;
-  optional Cost cost = 2;
-  repeated int64 version = 3;
-}
-
-message TouchRequest {
-  optional InternalHeader header = 10;
-
-  repeated Reference key = 1;
-  repeated CompositeIndex composite_index = 2;
-  optional bool force = 3 [default = false];
-  repeated Snapshot snapshot = 9;
-}
-
-message TouchResponse {
-  optional Cost cost = 1;
-}
-
-message DeleteRequest {
-  optional InternalHeader header = 10;
-
-  repeated Reference key = 6;
-  optional Transaction transaction = 5;
-
-  optional bool trusted = 4 [default = false];
-
-  optional bool force = 7 [default = false];
-
-  optional bool mark_changes = 8 [default = false];
-  repeated Snapshot snapshot = 9;
-}
-
-message DeleteResponse {
-  optional Cost cost = 1;
-  repeated int64 version = 3;
-}
-
-message NextRequest {
-  optional InternalHeader header = 5;
-
-  required Cursor cursor = 1;
-  optional int32 count = 2;
-
-  optional int32 offset = 4 [default = 0];
-
-  optional bool compile = 3 [default = false];
-}
-
-message QueryResult {
-  optional Cursor cursor = 1;
-
-  repeated EntityProto result = 2;
-
-  optional int32 skipped_results = 7;
-
-  required bool more_results = 3;
-
-  optional bool keys_only = 4;
-
-  optional bool index_only = 9;
-
-  optional bool small_ops = 10;
-
-  optional CompiledQuery compiled_query = 5;
-
-  optional CompiledCursor compiled_cursor = 6;
-
-  repeated CompositeIndex index = 8;
-
-  repeated int64 version = 11;
-}
-
-message AllocateIdsRequest {
-  optional InternalHeader header = 4;
-
-  optional Reference model_key = 1;
-
-  optional int64 size = 2;
-
-  optional int64 max = 3;
-
-  repeated Reference reserve = 5;
-}
-
-message AllocateIdsResponse {
-  required int64 start = 1;
-  required int64 end = 2;
-  optional Cost cost = 3;
-}
-
-message CompositeIndices {
-  repeated CompositeIndex index = 1;
-}
-
-message AddActionsRequest {
-  optional InternalHeader header = 3;
-
-  required Transaction transaction = 1;
-  repeated Action action = 2;
-}
-
-message AddActionsResponse {
-}
-
-message BeginTransactionRequest {
-  optional InternalHeader header = 3;
-
-  required string app = 1;
-  optional bool allow_multiple_eg = 2 [default = false];
-}
-
-message CommitResponse {
-  optional Cost cost = 1;
-
-  repeated group Version = 3 {
-    required Reference root_entity_key = 4;
-    required int64 version = 5;
-  }
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go
deleted file mode 100644
index d538701ab3b2bd817981abe4a1d7a111fdd72e41..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/identity.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-import netcontext "golang.org/x/net/context"
-
-// These functions are implementations of the wrapper functions
-// in ../appengine/identity.go. See that file for commentary.
-
-func AppID(c netcontext.Context) string {
-	return appID(FullyQualifiedAppID(c))
-}
diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go
deleted file mode 100644
index d5fa75be78eb31a709f5bae34a49453bfad1100e..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/identity_vm.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// +build !appengine
-
-package internal
-
-import (
-	"net/http"
-	"os"
-
-	netcontext "golang.org/x/net/context"
-)
-
-// These functions are implementations of the wrapper functions
-// in ../appengine/identity.go. See that file for commentary.
-
-const (
-	hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname"
-	hRequestLogId           = "X-AppEngine-Request-Log-Id"
-	hDatacenter             = "X-AppEngine-Datacenter"
-)
-
-func ctxHeaders(ctx netcontext.Context) http.Header {
-	c := fromContext(ctx)
-	if c == nil {
-		return nil
-	}
-	return c.Request().Header
-}
-
-func DefaultVersionHostname(ctx netcontext.Context) string {
-	return ctxHeaders(ctx).Get(hDefaultVersionHostname)
-}
-
-func RequestID(ctx netcontext.Context) string {
-	return ctxHeaders(ctx).Get(hRequestLogId)
-}
-
-func Datacenter(ctx netcontext.Context) string {
-	return ctxHeaders(ctx).Get(hDatacenter)
-}
-
-func ServerSoftware() string {
-	// TODO(dsymonds): Remove fallback when we've verified this.
-	if s := os.Getenv("SERVER_SOFTWARE"); s != "" {
-		return s
-	}
-	return "Google App Engine/1.x.x"
-}
-
-// TODO(dsymonds): Remove the metadata fetches.
-
-func ModuleName(_ netcontext.Context) string {
-	if s := os.Getenv("GAE_MODULE_NAME"); s != "" {
-		return s
-	}
-	return string(mustGetMetadata("instance/attributes/gae_backend_name"))
-}
-
-func VersionID(_ netcontext.Context) string {
-	if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" {
-		return s1 + "." + s2
-	}
-	return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version"))
-}
-
-func InstanceID() string {
-	if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" {
-		return s
-	}
-	return string(mustGetMetadata("instance/attributes/gae_backend_instance"))
-}
-
-func partitionlessAppID() string {
-	// gae_project has everything except the partition prefix.
-	appID := os.Getenv("GAE_LONG_APP_ID")
-	if appID == "" {
-		appID = string(mustGetMetadata("instance/attributes/gae_project"))
-	}
-	return appID
-}
-
-func fullyQualifiedAppID(_ netcontext.Context) string {
-	appID := partitionlessAppID()
-
-	part := os.Getenv("GAE_PARTITION")
-	if part == "" {
-		part = string(mustGetMetadata("instance/attributes/gae_partition"))
-	}
-
-	if part != "" {
-		appID = part + "~" + appID
-	}
-	return appID
-}
-
-func IsDevAppServer() bool {
-	return os.Getenv("RUN_WITH_DEVAPPSERVER") != ""
-}
diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go
deleted file mode 100644
index 051ea3980abe4d4e189dbc1b64b1c9c80a3844f4..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/internal.go
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// Package internal provides support for package appengine.
-//
-// Programs should not use this package directly. Its API is not stable.
-// Use packages appengine and appengine/* instead.
-package internal
-
-import (
-	"fmt"
-
-	"github.com/golang/protobuf/proto"
-
-	remotepb "google.golang.org/appengine/internal/remote_api"
-)
-
-// errorCodeMaps is a map of service name to the error code map for the service.
-var errorCodeMaps = make(map[string]map[int32]string)
-
-// RegisterErrorCodeMap is called from API implementations to register their
-// error code map. This should only be called from init functions.
-func RegisterErrorCodeMap(service string, m map[int32]string) {
-	errorCodeMaps[service] = m
-}
-
-type timeoutCodeKey struct {
-	service string
-	code    int32
-}
-
-// timeoutCodes is the set of service+code pairs that represent timeouts.
-var timeoutCodes = make(map[timeoutCodeKey]bool)
-
-func RegisterTimeoutErrorCode(service string, code int32) {
-	timeoutCodes[timeoutCodeKey{service, code}] = true
-}
-
-// APIError is the type returned by appengine.Context's Call method
-// when an API call fails in an API-specific way. This may be, for instance,
-// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
-type APIError struct {
-	Service string
-	Detail  string
-	Code    int32 // API-specific error code
-}
-
-func (e *APIError) Error() string {
-	if e.Code == 0 {
-		if e.Detail == "" {
-			return "APIError <empty>"
-		}
-		return e.Detail
-	}
-	s := fmt.Sprintf("API error %d", e.Code)
-	if m, ok := errorCodeMaps[e.Service]; ok {
-		s += " (" + e.Service + ": " + m[e.Code] + ")"
-	} else {
-		// Shouldn't happen, but provide a bit more detail if it does.
-		s = e.Service + " " + s
-	}
-	if e.Detail != "" {
-		s += ": " + e.Detail
-	}
-	return s
-}
-
-func (e *APIError) IsTimeout() bool {
-	return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
-}
-
-// CallError is the type returned by appengine.Context's Call method when an
-// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
-type CallError struct {
-	Detail string
-	Code   int32
-	// TODO: Remove this if we get a distinguishable error code.
-	Timeout bool
-}
-
-func (e *CallError) Error() string {
-	var msg string
-	switch remotepb.RpcError_ErrorCode(e.Code) {
-	case remotepb.RpcError_UNKNOWN:
-		return e.Detail
-	case remotepb.RpcError_OVER_QUOTA:
-		msg = "Over quota"
-	case remotepb.RpcError_CAPABILITY_DISABLED:
-		msg = "Capability disabled"
-	case remotepb.RpcError_CANCELLED:
-		msg = "Canceled"
-	default:
-		msg = fmt.Sprintf("Call error %d", e.Code)
-	}
-	s := msg + ": " + e.Detail
-	if e.Timeout {
-		s += " (timeout)"
-	}
-	return s
-}
-
-func (e *CallError) IsTimeout() bool {
-	return e.Timeout
-}
-
-// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
-// The function should be prepared to be called on the same message more than once; it should only modify the
-// RPC request the first time.
-var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
deleted file mode 100644
index 20c595be30a1a129b3936585f932dc5a06cfcfd0..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go
+++ /dev/null
@@ -1,899 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/log/log_service.proto
-// DO NOT EDIT!
-
-/*
-Package log is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/log/log_service.proto
-
-It has these top-level messages:
-	LogServiceError
-	UserAppLogLine
-	UserAppLogGroup
-	FlushRequest
-	SetStatusRequest
-	LogOffset
-	LogLine
-	RequestLog
-	LogModuleVersion
-	LogReadRequest
-	LogReadResponse
-	LogUsageRecord
-	LogUsageRequest
-	LogUsageResponse
-*/
-package log
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type LogServiceError_ErrorCode int32
-
-const (
-	LogServiceError_OK              LogServiceError_ErrorCode = 0
-	LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1
-	LogServiceError_STORAGE_ERROR   LogServiceError_ErrorCode = 2
-)
-
-var LogServiceError_ErrorCode_name = map[int32]string{
-	0: "OK",
-	1: "INVALID_REQUEST",
-	2: "STORAGE_ERROR",
-}
-var LogServiceError_ErrorCode_value = map[string]int32{
-	"OK":              0,
-	"INVALID_REQUEST": 1,
-	"STORAGE_ERROR":   2,
-}
-
-func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode {
-	p := new(LogServiceError_ErrorCode)
-	*p = x
-	return p
-}
-func (x LogServiceError_ErrorCode) String() string {
-	return proto.EnumName(LogServiceError_ErrorCode_name, int32(x))
-}
-func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode")
-	if err != nil {
-		return err
-	}
-	*x = LogServiceError_ErrorCode(value)
-	return nil
-}
-
-type LogServiceError struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *LogServiceError) Reset()         { *m = LogServiceError{} }
-func (m *LogServiceError) String() string { return proto.CompactTextString(m) }
-func (*LogServiceError) ProtoMessage()    {}
-
-type UserAppLogLine struct {
-	TimestampUsec    *int64  `protobuf:"varint,1,req,name=timestamp_usec" json:"timestamp_usec,omitempty"`
-	Level            *int64  `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
-	Message          *string `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *UserAppLogLine) Reset()         { *m = UserAppLogLine{} }
-func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) }
-func (*UserAppLogLine) ProtoMessage()    {}
-
-func (m *UserAppLogLine) GetTimestampUsec() int64 {
-	if m != nil && m.TimestampUsec != nil {
-		return *m.TimestampUsec
-	}
-	return 0
-}
-
-func (m *UserAppLogLine) GetLevel() int64 {
-	if m != nil && m.Level != nil {
-		return *m.Level
-	}
-	return 0
-}
-
-func (m *UserAppLogLine) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-type UserAppLogGroup struct {
-	LogLine          []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line" json:"log_line,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *UserAppLogGroup) Reset()         { *m = UserAppLogGroup{} }
-func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) }
-func (*UserAppLogGroup) ProtoMessage()    {}
-
-func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine {
-	if m != nil {
-		return m.LogLine
-	}
-	return nil
-}
-
-type FlushRequest struct {
-	Logs             []byte `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *FlushRequest) Reset()         { *m = FlushRequest{} }
-func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
-func (*FlushRequest) ProtoMessage()    {}
-
-func (m *FlushRequest) GetLogs() []byte {
-	if m != nil {
-		return m.Logs
-	}
-	return nil
-}
-
-type SetStatusRequest struct {
-	Status           *string `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SetStatusRequest) Reset()         { *m = SetStatusRequest{} }
-func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) }
-func (*SetStatusRequest) ProtoMessage()    {}
-
-func (m *SetStatusRequest) GetStatus() string {
-	if m != nil && m.Status != nil {
-		return *m.Status
-	}
-	return ""
-}
-
-type LogOffset struct {
-	RequestId        []byte `protobuf:"bytes,1,opt,name=request_id" json:"request_id,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *LogOffset) Reset()         { *m = LogOffset{} }
-func (m *LogOffset) String() string { return proto.CompactTextString(m) }
-func (*LogOffset) ProtoMessage()    {}
-
-func (m *LogOffset) GetRequestId() []byte {
-	if m != nil {
-		return m.RequestId
-	}
-	return nil
-}
-
-type LogLine struct {
-	Time             *int64  `protobuf:"varint,1,req,name=time" json:"time,omitempty"`
-	Level            *int32  `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
-	LogMessage       *string `protobuf:"bytes,3,req,name=log_message" json:"log_message,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *LogLine) Reset()         { *m = LogLine{} }
-func (m *LogLine) String() string { return proto.CompactTextString(m) }
-func (*LogLine) ProtoMessage()    {}
-
-func (m *LogLine) GetTime() int64 {
-	if m != nil && m.Time != nil {
-		return *m.Time
-	}
-	return 0
-}
-
-func (m *LogLine) GetLevel() int32 {
-	if m != nil && m.Level != nil {
-		return *m.Level
-	}
-	return 0
-}
-
-func (m *LogLine) GetLogMessage() string {
-	if m != nil && m.LogMessage != nil {
-		return *m.LogMessage
-	}
-	return ""
-}
-
-type RequestLog struct {
-	AppId                   *string    `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
-	ModuleId                *string    `protobuf:"bytes,37,opt,name=module_id,def=default" json:"module_id,omitempty"`
-	VersionId               *string    `protobuf:"bytes,2,req,name=version_id" json:"version_id,omitempty"`
-	RequestId               []byte     `protobuf:"bytes,3,req,name=request_id" json:"request_id,omitempty"`
-	Offset                  *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"`
-	Ip                      *string    `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"`
-	Nickname                *string    `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"`
-	StartTime               *int64     `protobuf:"varint,6,req,name=start_time" json:"start_time,omitempty"`
-	EndTime                 *int64     `protobuf:"varint,7,req,name=end_time" json:"end_time,omitempty"`
-	Latency                 *int64     `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"`
-	Mcycles                 *int64     `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"`
-	Method                  *string    `protobuf:"bytes,10,req,name=method" json:"method,omitempty"`
-	Resource                *string    `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"`
-	HttpVersion             *string    `protobuf:"bytes,12,req,name=http_version" json:"http_version,omitempty"`
-	Status                  *int32     `protobuf:"varint,13,req,name=status" json:"status,omitempty"`
-	ResponseSize            *int64     `protobuf:"varint,14,req,name=response_size" json:"response_size,omitempty"`
-	Referrer                *string    `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
-	UserAgent               *string    `protobuf:"bytes,16,opt,name=user_agent" json:"user_agent,omitempty"`
-	UrlMapEntry             *string    `protobuf:"bytes,17,req,name=url_map_entry" json:"url_map_entry,omitempty"`
-	Combined                *string    `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"`
-	ApiMcycles              *int64     `protobuf:"varint,19,opt,name=api_mcycles" json:"api_mcycles,omitempty"`
-	Host                    *string    `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
-	Cost                    *float64   `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
-	TaskQueueName           *string    `protobuf:"bytes,22,opt,name=task_queue_name" json:"task_queue_name,omitempty"`
-	TaskName                *string    `protobuf:"bytes,23,opt,name=task_name" json:"task_name,omitempty"`
-	WasLoadingRequest       *bool      `protobuf:"varint,24,opt,name=was_loading_request" json:"was_loading_request,omitempty"`
-	PendingTime             *int64     `protobuf:"varint,25,opt,name=pending_time" json:"pending_time,omitempty"`
-	ReplicaIndex            *int32     `protobuf:"varint,26,opt,name=replica_index,def=-1" json:"replica_index,omitempty"`
-	Finished                *bool      `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"`
-	CloneKey                []byte     `protobuf:"bytes,28,opt,name=clone_key" json:"clone_key,omitempty"`
-	Line                    []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
-	LinesIncomplete         *bool      `protobuf:"varint,36,opt,name=lines_incomplete" json:"lines_incomplete,omitempty"`
-	AppEngineRelease        []byte     `protobuf:"bytes,38,opt,name=app_engine_release" json:"app_engine_release,omitempty"`
-	ExitReason              *int32     `protobuf:"varint,30,opt,name=exit_reason" json:"exit_reason,omitempty"`
-	WasThrottledForTime     *bool      `protobuf:"varint,31,opt,name=was_throttled_for_time" json:"was_throttled_for_time,omitempty"`
-	WasThrottledForRequests *bool      `protobuf:"varint,32,opt,name=was_throttled_for_requests" json:"was_throttled_for_requests,omitempty"`
-	ThrottledTime           *int64     `protobuf:"varint,33,opt,name=throttled_time" json:"throttled_time,omitempty"`
-	ServerName              []byte     `protobuf:"bytes,34,opt,name=server_name" json:"server_name,omitempty"`
-	XXX_unrecognized        []byte     `json:"-"`
-}
-
-func (m *RequestLog) Reset()         { *m = RequestLog{} }
-func (m *RequestLog) String() string { return proto.CompactTextString(m) }
-func (*RequestLog) ProtoMessage()    {}
-
-const Default_RequestLog_ModuleId string = "default"
-const Default_RequestLog_ReplicaIndex int32 = -1
-const Default_RequestLog_Finished bool = true
-
-func (m *RequestLog) GetAppId() string {
-	if m != nil && m.AppId != nil {
-		return *m.AppId
-	}
-	return ""
-}
-
-func (m *RequestLog) GetModuleId() string {
-	if m != nil && m.ModuleId != nil {
-		return *m.ModuleId
-	}
-	return Default_RequestLog_ModuleId
-}
-
-func (m *RequestLog) GetVersionId() string {
-	if m != nil && m.VersionId != nil {
-		return *m.VersionId
-	}
-	return ""
-}
-
-func (m *RequestLog) GetRequestId() []byte {
-	if m != nil {
-		return m.RequestId
-	}
-	return nil
-}
-
-func (m *RequestLog) GetOffset() *LogOffset {
-	if m != nil {
-		return m.Offset
-	}
-	return nil
-}
-
-func (m *RequestLog) GetIp() string {
-	if m != nil && m.Ip != nil {
-		return *m.Ip
-	}
-	return ""
-}
-
-func (m *RequestLog) GetNickname() string {
-	if m != nil && m.Nickname != nil {
-		return *m.Nickname
-	}
-	return ""
-}
-
-func (m *RequestLog) GetStartTime() int64 {
-	if m != nil && m.StartTime != nil {
-		return *m.StartTime
-	}
-	return 0
-}
-
-func (m *RequestLog) GetEndTime() int64 {
-	if m != nil && m.EndTime != nil {
-		return *m.EndTime
-	}
-	return 0
-}
-
-func (m *RequestLog) GetLatency() int64 {
-	if m != nil && m.Latency != nil {
-		return *m.Latency
-	}
-	return 0
-}
-
-func (m *RequestLog) GetMcycles() int64 {
-	if m != nil && m.Mcycles != nil {
-		return *m.Mcycles
-	}
-	return 0
-}
-
-func (m *RequestLog) GetMethod() string {
-	if m != nil && m.Method != nil {
-		return *m.Method
-	}
-	return ""
-}
-
-func (m *RequestLog) GetResource() string {
-	if m != nil && m.Resource != nil {
-		return *m.Resource
-	}
-	return ""
-}
-
-func (m *RequestLog) GetHttpVersion() string {
-	if m != nil && m.HttpVersion != nil {
-		return *m.HttpVersion
-	}
-	return ""
-}
-
-func (m *RequestLog) GetStatus() int32 {
-	if m != nil && m.Status != nil {
-		return *m.Status
-	}
-	return 0
-}
-
-func (m *RequestLog) GetResponseSize() int64 {
-	if m != nil && m.ResponseSize != nil {
-		return *m.ResponseSize
-	}
-	return 0
-}
-
-func (m *RequestLog) GetReferrer() string {
-	if m != nil && m.Referrer != nil {
-		return *m.Referrer
-	}
-	return ""
-}
-
-func (m *RequestLog) GetUserAgent() string {
-	if m != nil && m.UserAgent != nil {
-		return *m.UserAgent
-	}
-	return ""
-}
-
-func (m *RequestLog) GetUrlMapEntry() string {
-	if m != nil && m.UrlMapEntry != nil {
-		return *m.UrlMapEntry
-	}
-	return ""
-}
-
-func (m *RequestLog) GetCombined() string {
-	if m != nil && m.Combined != nil {
-		return *m.Combined
-	}
-	return ""
-}
-
-func (m *RequestLog) GetApiMcycles() int64 {
-	if m != nil && m.ApiMcycles != nil {
-		return *m.ApiMcycles
-	}
-	return 0
-}
-
-func (m *RequestLog) GetHost() string {
-	if m != nil && m.Host != nil {
-		return *m.Host
-	}
-	return ""
-}
-
-func (m *RequestLog) GetCost() float64 {
-	if m != nil && m.Cost != nil {
-		return *m.Cost
-	}
-	return 0
-}
-
-func (m *RequestLog) GetTaskQueueName() string {
-	if m != nil && m.TaskQueueName != nil {
-		return *m.TaskQueueName
-	}
-	return ""
-}
-
-func (m *RequestLog) GetTaskName() string {
-	if m != nil && m.TaskName != nil {
-		return *m.TaskName
-	}
-	return ""
-}
-
-func (m *RequestLog) GetWasLoadingRequest() bool {
-	if m != nil && m.WasLoadingRequest != nil {
-		return *m.WasLoadingRequest
-	}
-	return false
-}
-
-func (m *RequestLog) GetPendingTime() int64 {
-	if m != nil && m.PendingTime != nil {
-		return *m.PendingTime
-	}
-	return 0
-}
-
-func (m *RequestLog) GetReplicaIndex() int32 {
-	if m != nil && m.ReplicaIndex != nil {
-		return *m.ReplicaIndex
-	}
-	return Default_RequestLog_ReplicaIndex
-}
-
-func (m *RequestLog) GetFinished() bool {
-	if m != nil && m.Finished != nil {
-		return *m.Finished
-	}
-	return Default_RequestLog_Finished
-}
-
-func (m *RequestLog) GetCloneKey() []byte {
-	if m != nil {
-		return m.CloneKey
-	}
-	return nil
-}
-
-func (m *RequestLog) GetLine() []*LogLine {
-	if m != nil {
-		return m.Line
-	}
-	return nil
-}
-
-func (m *RequestLog) GetLinesIncomplete() bool {
-	if m != nil && m.LinesIncomplete != nil {
-		return *m.LinesIncomplete
-	}
-	return false
-}
-
-func (m *RequestLog) GetAppEngineRelease() []byte {
-	if m != nil {
-		return m.AppEngineRelease
-	}
-	return nil
-}
-
-func (m *RequestLog) GetExitReason() int32 {
-	if m != nil && m.ExitReason != nil {
-		return *m.ExitReason
-	}
-	return 0
-}
-
-func (m *RequestLog) GetWasThrottledForTime() bool {
-	if m != nil && m.WasThrottledForTime != nil {
-		return *m.WasThrottledForTime
-	}
-	return false
-}
-
-func (m *RequestLog) GetWasThrottledForRequests() bool {
-	if m != nil && m.WasThrottledForRequests != nil {
-		return *m.WasThrottledForRequests
-	}
-	return false
-}
-
-func (m *RequestLog) GetThrottledTime() int64 {
-	if m != nil && m.ThrottledTime != nil {
-		return *m.ThrottledTime
-	}
-	return 0
-}
-
-func (m *RequestLog) GetServerName() []byte {
-	if m != nil {
-		return m.ServerName
-	}
-	return nil
-}
-
-type LogModuleVersion struct {
-	ModuleId         *string `protobuf:"bytes,1,opt,name=module_id,def=default" json:"module_id,omitempty"`
-	VersionId        *string `protobuf:"bytes,2,opt,name=version_id" json:"version_id,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *LogModuleVersion) Reset()         { *m = LogModuleVersion{} }
-func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) }
-func (*LogModuleVersion) ProtoMessage()    {}
-
-const Default_LogModuleVersion_ModuleId string = "default"
-
-func (m *LogModuleVersion) GetModuleId() string {
-	if m != nil && m.ModuleId != nil {
-		return *m.ModuleId
-	}
-	return Default_LogModuleVersion_ModuleId
-}
-
-func (m *LogModuleVersion) GetVersionId() string {
-	if m != nil && m.VersionId != nil {
-		return *m.VersionId
-	}
-	return ""
-}
-
-type LogReadRequest struct {
-	AppId             *string             `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
-	VersionId         []string            `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"`
-	ModuleVersion     []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version" json:"module_version,omitempty"`
-	StartTime         *int64              `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"`
-	EndTime           *int64              `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"`
-	Offset            *LogOffset          `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"`
-	RequestId         [][]byte            `protobuf:"bytes,6,rep,name=request_id" json:"request_id,omitempty"`
-	MinimumLogLevel   *int32              `protobuf:"varint,7,opt,name=minimum_log_level" json:"minimum_log_level,omitempty"`
-	IncludeIncomplete *bool               `protobuf:"varint,8,opt,name=include_incomplete" json:"include_incomplete,omitempty"`
-	Count             *int64              `protobuf:"varint,9,opt,name=count" json:"count,omitempty"`
-	CombinedLogRegex  *string             `protobuf:"bytes,14,opt,name=combined_log_regex" json:"combined_log_regex,omitempty"`
-	HostRegex         *string             `protobuf:"bytes,15,opt,name=host_regex" json:"host_regex,omitempty"`
-	ReplicaIndex      *int32              `protobuf:"varint,16,opt,name=replica_index" json:"replica_index,omitempty"`
-	IncludeAppLogs    *bool               `protobuf:"varint,10,opt,name=include_app_logs" json:"include_app_logs,omitempty"`
-	AppLogsPerRequest *int32              `protobuf:"varint,17,opt,name=app_logs_per_request" json:"app_logs_per_request,omitempty"`
-	IncludeHost       *bool               `protobuf:"varint,11,opt,name=include_host" json:"include_host,omitempty"`
-	IncludeAll        *bool               `protobuf:"varint,12,opt,name=include_all" json:"include_all,omitempty"`
-	CacheIterator     *bool               `protobuf:"varint,13,opt,name=cache_iterator" json:"cache_iterator,omitempty"`
-	NumShards         *int32              `protobuf:"varint,18,opt,name=num_shards" json:"num_shards,omitempty"`
-	XXX_unrecognized  []byte              `json:"-"`
-}
-
-func (m *LogReadRequest) Reset()         { *m = LogReadRequest{} }
-func (m *LogReadRequest) String() string { return proto.CompactTextString(m) }
-func (*LogReadRequest) ProtoMessage()    {}
-
-func (m *LogReadRequest) GetAppId() string {
-	if m != nil && m.AppId != nil {
-		return *m.AppId
-	}
-	return ""
-}
-
-func (m *LogReadRequest) GetVersionId() []string {
-	if m != nil {
-		return m.VersionId
-	}
-	return nil
-}
-
-func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion {
-	if m != nil {
-		return m.ModuleVersion
-	}
-	return nil
-}
-
-func (m *LogReadRequest) GetStartTime() int64 {
-	if m != nil && m.StartTime != nil {
-		return *m.StartTime
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetEndTime() int64 {
-	if m != nil && m.EndTime != nil {
-		return *m.EndTime
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetOffset() *LogOffset {
-	if m != nil {
-		return m.Offset
-	}
-	return nil
-}
-
-func (m *LogReadRequest) GetRequestId() [][]byte {
-	if m != nil {
-		return m.RequestId
-	}
-	return nil
-}
-
-func (m *LogReadRequest) GetMinimumLogLevel() int32 {
-	if m != nil && m.MinimumLogLevel != nil {
-		return *m.MinimumLogLevel
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetIncludeIncomplete() bool {
-	if m != nil && m.IncludeIncomplete != nil {
-		return *m.IncludeIncomplete
-	}
-	return false
-}
-
-func (m *LogReadRequest) GetCount() int64 {
-	if m != nil && m.Count != nil {
-		return *m.Count
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetCombinedLogRegex() string {
-	if m != nil && m.CombinedLogRegex != nil {
-		return *m.CombinedLogRegex
-	}
-	return ""
-}
-
-func (m *LogReadRequest) GetHostRegex() string {
-	if m != nil && m.HostRegex != nil {
-		return *m.HostRegex
-	}
-	return ""
-}
-
-func (m *LogReadRequest) GetReplicaIndex() int32 {
-	if m != nil && m.ReplicaIndex != nil {
-		return *m.ReplicaIndex
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetIncludeAppLogs() bool {
-	if m != nil && m.IncludeAppLogs != nil {
-		return *m.IncludeAppLogs
-	}
-	return false
-}
-
-func (m *LogReadRequest) GetAppLogsPerRequest() int32 {
-	if m != nil && m.AppLogsPerRequest != nil {
-		return *m.AppLogsPerRequest
-	}
-	return 0
-}
-
-func (m *LogReadRequest) GetIncludeHost() bool {
-	if m != nil && m.IncludeHost != nil {
-		return *m.IncludeHost
-	}
-	return false
-}
-
-func (m *LogReadRequest) GetIncludeAll() bool {
-	if m != nil && m.IncludeAll != nil {
-		return *m.IncludeAll
-	}
-	return false
-}
-
-func (m *LogReadRequest) GetCacheIterator() bool {
-	if m != nil && m.CacheIterator != nil {
-		return *m.CacheIterator
-	}
-	return false
-}
-
-func (m *LogReadRequest) GetNumShards() int32 {
-	if m != nil && m.NumShards != nil {
-		return *m.NumShards
-	}
-	return 0
-}
-
-type LogReadResponse struct {
-	Log              []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"`
-	Offset           *LogOffset    `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"`
-	LastEndTime      *int64        `protobuf:"varint,3,opt,name=last_end_time" json:"last_end_time,omitempty"`
-	XXX_unrecognized []byte        `json:"-"`
-}
-
-func (m *LogReadResponse) Reset()         { *m = LogReadResponse{} }
-func (m *LogReadResponse) String() string { return proto.CompactTextString(m) }
-func (*LogReadResponse) ProtoMessage()    {}
-
-func (m *LogReadResponse) GetLog() []*RequestLog {
-	if m != nil {
-		return m.Log
-	}
-	return nil
-}
-
-func (m *LogReadResponse) GetOffset() *LogOffset {
-	if m != nil {
-		return m.Offset
-	}
-	return nil
-}
-
-func (m *LogReadResponse) GetLastEndTime() int64 {
-	if m != nil && m.LastEndTime != nil {
-		return *m.LastEndTime
-	}
-	return 0
-}
-
-type LogUsageRecord struct {
-	VersionId        *string `protobuf:"bytes,1,opt,name=version_id" json:"version_id,omitempty"`
-	StartTime        *int32  `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"`
-	EndTime          *int32  `protobuf:"varint,3,opt,name=end_time" json:"end_time,omitempty"`
-	Count            *int64  `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
-	TotalSize        *int64  `protobuf:"varint,5,opt,name=total_size" json:"total_size,omitempty"`
-	Records          *int32  `protobuf:"varint,6,opt,name=records" json:"records,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *LogUsageRecord) Reset()         { *m = LogUsageRecord{} }
-func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) }
-func (*LogUsageRecord) ProtoMessage()    {}
-
-func (m *LogUsageRecord) GetVersionId() string {
-	if m != nil && m.VersionId != nil {
-		return *m.VersionId
-	}
-	return ""
-}
-
-func (m *LogUsageRecord) GetStartTime() int32 {
-	if m != nil && m.StartTime != nil {
-		return *m.StartTime
-	}
-	return 0
-}
-
-func (m *LogUsageRecord) GetEndTime() int32 {
-	if m != nil && m.EndTime != nil {
-		return *m.EndTime
-	}
-	return 0
-}
-
-func (m *LogUsageRecord) GetCount() int64 {
-	if m != nil && m.Count != nil {
-		return *m.Count
-	}
-	return 0
-}
-
-func (m *LogUsageRecord) GetTotalSize() int64 {
-	if m != nil && m.TotalSize != nil {
-		return *m.TotalSize
-	}
-	return 0
-}
-
-func (m *LogUsageRecord) GetRecords() int32 {
-	if m != nil && m.Records != nil {
-		return *m.Records
-	}
-	return 0
-}
-
-type LogUsageRequest struct {
-	AppId            *string  `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
-	VersionId        []string `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"`
-	StartTime        *int32   `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"`
-	EndTime          *int32   `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"`
-	ResolutionHours  *uint32  `protobuf:"varint,5,opt,name=resolution_hours,def=1" json:"resolution_hours,omitempty"`
-	CombineVersions  *bool    `protobuf:"varint,6,opt,name=combine_versions" json:"combine_versions,omitempty"`
-	UsageVersion     *int32   `protobuf:"varint,7,opt,name=usage_version" json:"usage_version,omitempty"`
-	VersionsOnly     *bool    `protobuf:"varint,8,opt,name=versions_only" json:"versions_only,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *LogUsageRequest) Reset()         { *m = LogUsageRequest{} }
-func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) }
-func (*LogUsageRequest) ProtoMessage()    {}
-
-const Default_LogUsageRequest_ResolutionHours uint32 = 1
-
-func (m *LogUsageRequest) GetAppId() string {
-	if m != nil && m.AppId != nil {
-		return *m.AppId
-	}
-	return ""
-}
-
-func (m *LogUsageRequest) GetVersionId() []string {
-	if m != nil {
-		return m.VersionId
-	}
-	return nil
-}
-
-func (m *LogUsageRequest) GetStartTime() int32 {
-	if m != nil && m.StartTime != nil {
-		return *m.StartTime
-	}
-	return 0
-}
-
-func (m *LogUsageRequest) GetEndTime() int32 {
-	if m != nil && m.EndTime != nil {
-		return *m.EndTime
-	}
-	return 0
-}
-
-func (m *LogUsageRequest) GetResolutionHours() uint32 {
-	if m != nil && m.ResolutionHours != nil {
-		return *m.ResolutionHours
-	}
-	return Default_LogUsageRequest_ResolutionHours
-}
-
-func (m *LogUsageRequest) GetCombineVersions() bool {
-	if m != nil && m.CombineVersions != nil {
-		return *m.CombineVersions
-	}
-	return false
-}
-
-func (m *LogUsageRequest) GetUsageVersion() int32 {
-	if m != nil && m.UsageVersion != nil {
-		return *m.UsageVersion
-	}
-	return 0
-}
-
-func (m *LogUsageRequest) GetVersionsOnly() bool {
-	if m != nil && m.VersionsOnly != nil {
-		return *m.VersionsOnly
-	}
-	return false
-}
-
-type LogUsageResponse struct {
-	Usage            []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"`
-	Summary          *LogUsageRecord   `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *LogUsageResponse) Reset()         { *m = LogUsageResponse{} }
-func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) }
-func (*LogUsageResponse) ProtoMessage()    {}
-
-func (m *LogUsageResponse) GetUsage() []*LogUsageRecord {
-	if m != nil {
-		return m.Usage
-	}
-	return nil
-}
-
-func (m *LogUsageResponse) GetSummary() *LogUsageRecord {
-	if m != nil {
-		return m.Summary
-	}
-	return nil
-}
-
-func init() {
-}
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.proto b/vendor/google.golang.org/appengine/internal/log/log_service.proto
deleted file mode 100644
index 8981dc47577cedcbd5ac1fe11d698c3db24b5d45..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/log/log_service.proto
+++ /dev/null
@@ -1,150 +0,0 @@
-syntax = "proto2";
-option go_package = "log";
-
-package appengine;
-
-message LogServiceError {
-  enum ErrorCode {
-    OK  = 0;
-    INVALID_REQUEST = 1;
-    STORAGE_ERROR = 2;
-  }
-}
-
-message UserAppLogLine {
-  required int64 timestamp_usec = 1;
-  required int64 level = 2;
-  required string message = 3;
-}
-
-message UserAppLogGroup {
-  repeated UserAppLogLine log_line = 2;
-}
-
-message FlushRequest {
-  optional bytes logs = 1;
-}
-
-message SetStatusRequest {
-  required string status = 1;
-}
-
-
-message LogOffset {
-  optional bytes request_id = 1;
-}
-
-message LogLine {
-  required int64 time = 1;
-  required int32 level = 2;
-  required string log_message = 3;
-}
-
-message RequestLog {
-  required string app_id = 1;
-  optional string module_id = 37 [default="default"];
-  required string version_id = 2;
-  required bytes request_id = 3;
-  optional LogOffset offset = 35;
-  required string ip = 4;
-  optional string nickname = 5;
-  required int64 start_time = 6;
-  required int64 end_time = 7;
-  required int64 latency = 8;
-  required int64 mcycles = 9;
-  required string method = 10;
-  required string resource = 11;
-  required string http_version = 12;
-  required int32 status = 13;
-  required int64 response_size = 14;
-  optional string referrer = 15;
-  optional string user_agent = 16;
-  required string url_map_entry = 17;
-  required string combined = 18;
-  optional int64 api_mcycles = 19;
-  optional string host = 20;
-  optional double cost = 21;
-
-  optional string task_queue_name = 22;
-  optional string task_name = 23;
-
-  optional bool was_loading_request = 24;
-  optional int64 pending_time = 25;
-  optional int32 replica_index = 26 [default = -1];
-  optional bool finished = 27 [default = true];
-  optional bytes clone_key = 28;
-
-  repeated LogLine line = 29;
-
-  optional bool lines_incomplete = 36;
-  optional bytes app_engine_release = 38;
-
-  optional int32 exit_reason = 30;
-  optional bool was_throttled_for_time = 31;
-  optional bool was_throttled_for_requests = 32;
-  optional int64 throttled_time = 33;
-
-  optional bytes server_name = 34;
-}
-
-message LogModuleVersion {
-  optional string module_id = 1 [default="default"];
-  optional string version_id = 2;
-}
-
-message LogReadRequest {
-  required string app_id = 1;
-  repeated string version_id = 2;
-  repeated LogModuleVersion module_version = 19;
-
-  optional int64 start_time = 3;
-  optional int64 end_time = 4;
-  optional LogOffset offset = 5;
-  repeated bytes request_id = 6;
-
-  optional int32 minimum_log_level = 7;
-  optional bool include_incomplete = 8;
-  optional int64 count = 9;
-
-  optional string combined_log_regex = 14;
-  optional string host_regex = 15;
-  optional int32 replica_index = 16;
-
-  optional bool include_app_logs = 10;
-  optional int32 app_logs_per_request = 17;
-  optional bool include_host = 11;
-  optional bool include_all = 12;
-  optional bool cache_iterator = 13;
-  optional int32 num_shards = 18;
-}
-
-message LogReadResponse {
-  repeated RequestLog log = 1;
-  optional LogOffset offset = 2;
-  optional int64 last_end_time = 3;
-}
-
-message LogUsageRecord {
-  optional string version_id = 1;
-  optional int32 start_time = 2;
-  optional int32 end_time = 3;
-  optional int64 count = 4;
-  optional int64 total_size = 5;
-  optional int32 records = 6;
-}
-
-message LogUsageRequest {
-  required string app_id = 1;
-  repeated string version_id = 2;
-  optional int32 start_time = 3;
-  optional int32 end_time = 4;
-  optional uint32 resolution_hours = 5 [default = 1];
-  optional bool combine_versions = 6;
-  optional int32 usage_version = 7;
-  optional bool versions_only = 8;
-}
-
-message LogUsageResponse {
-  repeated LogUsageRecord usage = 1;
-  optional LogUsageRecord summary = 2;
-}
diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go
deleted file mode 100644
index 822e784a458d9a19ccf50943cb0b20664e265556..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/main_vm.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2011 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// +build !appengine
-
-package internal
-
-import (
-	"io"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-)
-
-func Main() {
-	installHealthChecker(http.DefaultServeMux)
-
-	port := "8080"
-	if s := os.Getenv("PORT"); s != "" {
-		port = s
-	}
-
-	host := ""
-	if IsDevAppServer() {
-		host = "127.0.0.1"
-	}
-	if err := http.ListenAndServe(host+":"+port, http.HandlerFunc(handleHTTP)); err != nil {
-		log.Fatalf("http.ListenAndServe: %v", err)
-	}
-}
-
-func installHealthChecker(mux *http.ServeMux) {
-	// If no health check handler has been installed by this point, add a trivial one.
-	const healthPath = "/_ah/health"
-	hreq := &http.Request{
-		Method: "GET",
-		URL: &url.URL{
-			Path: healthPath,
-		},
-	}
-	if _, pat := mux.Handler(hreq); pat != healthPath {
-		mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) {
-			io.WriteString(w, "ok")
-		})
-	}
-}
diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go
deleted file mode 100644
index 9cc1f71d104d471e04b4986f0c893054edcc5980..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/metadata.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file has code for accessing metadata.
-//
-// References:
-//	https://cloud.google.com/compute/docs/metadata
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-)
-
-const (
-	metadataHost = "metadata"
-	metadataPath = "/computeMetadata/v1/"
-)
-
-var (
-	metadataRequestHeaders = http.Header{
-		"Metadata-Flavor": []string{"Google"},
-	}
-)
-
-// TODO(dsymonds): Do we need to support default values, like Python?
-func mustGetMetadata(key string) []byte {
-	b, err := getMetadata(key)
-	if err != nil {
-		log.Fatalf("Metadata fetch failed: %v", err)
-	}
-	return b
-}
-
-func getMetadata(key string) ([]byte, error) {
-	// TODO(dsymonds): May need to use url.Parse to support keys with query args.
-	req := &http.Request{
-		Method: "GET",
-		URL: &url.URL{
-			Scheme: "http",
-			Host:   metadataHost,
-			Path:   metadataPath + key,
-		},
-		Header: metadataRequestHeaders,
-		Host:   metadataHost,
-	}
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode)
-	}
-	return ioutil.ReadAll(resp.Body)
-}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
deleted file mode 100644
index a0145ed317c1c6749c85f7c03a91f58a4de1c900..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
+++ /dev/null
@@ -1,375 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/modules/modules_service.proto
-// DO NOT EDIT!
-
-/*
-Package modules is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/modules/modules_service.proto
-
-It has these top-level messages:
-	ModulesServiceError
-	GetModulesRequest
-	GetModulesResponse
-	GetVersionsRequest
-	GetVersionsResponse
-	GetDefaultVersionRequest
-	GetDefaultVersionResponse
-	GetNumInstancesRequest
-	GetNumInstancesResponse
-	SetNumInstancesRequest
-	SetNumInstancesResponse
-	StartModuleRequest
-	StartModuleResponse
-	StopModuleRequest
-	StopModuleResponse
-	GetHostnameRequest
-	GetHostnameResponse
-*/
-package modules
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type ModulesServiceError_ErrorCode int32
-
-const (
-	ModulesServiceError_OK                ModulesServiceError_ErrorCode = 0
-	ModulesServiceError_INVALID_MODULE    ModulesServiceError_ErrorCode = 1
-	ModulesServiceError_INVALID_VERSION   ModulesServiceError_ErrorCode = 2
-	ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3
-	ModulesServiceError_TRANSIENT_ERROR   ModulesServiceError_ErrorCode = 4
-	ModulesServiceError_UNEXPECTED_STATE  ModulesServiceError_ErrorCode = 5
-)
-
-var ModulesServiceError_ErrorCode_name = map[int32]string{
-	0: "OK",
-	1: "INVALID_MODULE",
-	2: "INVALID_VERSION",
-	3: "INVALID_INSTANCES",
-	4: "TRANSIENT_ERROR",
-	5: "UNEXPECTED_STATE",
-}
-var ModulesServiceError_ErrorCode_value = map[string]int32{
-	"OK":                0,
-	"INVALID_MODULE":    1,
-	"INVALID_VERSION":   2,
-	"INVALID_INSTANCES": 3,
-	"TRANSIENT_ERROR":   4,
-	"UNEXPECTED_STATE":  5,
-}
-
-func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode {
-	p := new(ModulesServiceError_ErrorCode)
-	*p = x
-	return p
-}
-func (x ModulesServiceError_ErrorCode) String() string {
-	return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x))
-}
-func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode")
-	if err != nil {
-		return err
-	}
-	*x = ModulesServiceError_ErrorCode(value)
-	return nil
-}
-
-type ModulesServiceError struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *ModulesServiceError) Reset()         { *m = ModulesServiceError{} }
-func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) }
-func (*ModulesServiceError) ProtoMessage()    {}
-
-type GetModulesRequest struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetModulesRequest) Reset()         { *m = GetModulesRequest{} }
-func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) }
-func (*GetModulesRequest) ProtoMessage()    {}
-
-type GetModulesResponse struct {
-	Module           []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *GetModulesResponse) Reset()         { *m = GetModulesResponse{} }
-func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) }
-func (*GetModulesResponse) ProtoMessage()    {}
-
-func (m *GetModulesResponse) GetModule() []string {
-	if m != nil {
-		return m.Module
-	}
-	return nil
-}
-
-type GetVersionsRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetVersionsRequest) Reset()         { *m = GetVersionsRequest{} }
-func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) }
-func (*GetVersionsRequest) ProtoMessage()    {}
-
-func (m *GetVersionsRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-type GetVersionsResponse struct {
-	Version          []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte   `json:"-"`
-}
-
-func (m *GetVersionsResponse) Reset()         { *m = GetVersionsResponse{} }
-func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) }
-func (*GetVersionsResponse) ProtoMessage()    {}
-
-func (m *GetVersionsResponse) GetVersion() []string {
-	if m != nil {
-		return m.Version
-	}
-	return nil
-}
-
-type GetDefaultVersionRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetDefaultVersionRequest) Reset()         { *m = GetDefaultVersionRequest{} }
-func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }
-func (*GetDefaultVersionRequest) ProtoMessage()    {}
-
-func (m *GetDefaultVersionRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-type GetDefaultVersionResponse struct {
-	Version          *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetDefaultVersionResponse) Reset()         { *m = GetDefaultVersionResponse{} }
-func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) }
-func (*GetDefaultVersionResponse) ProtoMessage()    {}
-
-func (m *GetDefaultVersionResponse) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-type GetNumInstancesRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	Version          *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetNumInstancesRequest) Reset()         { *m = GetNumInstancesRequest{} }
-func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
-func (*GetNumInstancesRequest) ProtoMessage()    {}
-
-func (m *GetNumInstancesRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-func (m *GetNumInstancesRequest) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-type GetNumInstancesResponse struct {
-	Instances        *int64 `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"`
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *GetNumInstancesResponse) Reset()         { *m = GetNumInstancesResponse{} }
-func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
-func (*GetNumInstancesResponse) ProtoMessage()    {}
-
-func (m *GetNumInstancesResponse) GetInstances() int64 {
-	if m != nil && m.Instances != nil {
-		return *m.Instances
-	}
-	return 0
-}
-
-type SetNumInstancesRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	Version          *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
-	Instances        *int64  `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *SetNumInstancesRequest) Reset()         { *m = SetNumInstancesRequest{} }
-func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
-func (*SetNumInstancesRequest) ProtoMessage()    {}
-
-func (m *SetNumInstancesRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-func (m *SetNumInstancesRequest) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-func (m *SetNumInstancesRequest) GetInstances() int64 {
-	if m != nil && m.Instances != nil {
-		return *m.Instances
-	}
-	return 0
-}
-
-type SetNumInstancesResponse struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *SetNumInstancesResponse) Reset()         { *m = SetNumInstancesResponse{} }
-func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
-func (*SetNumInstancesResponse) ProtoMessage()    {}
-
-type StartModuleRequest struct {
-	Module           *string `protobuf:"bytes,1,req,name=module" json:"module,omitempty"`
-	Version          *string `protobuf:"bytes,2,req,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *StartModuleRequest) Reset()         { *m = StartModuleRequest{} }
-func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) }
-func (*StartModuleRequest) ProtoMessage()    {}
-
-func (m *StartModuleRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-func (m *StartModuleRequest) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-type StartModuleResponse struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *StartModuleResponse) Reset()         { *m = StartModuleResponse{} }
-func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) }
-func (*StartModuleResponse) ProtoMessage()    {}
-
-type StopModuleRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	Version          *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *StopModuleRequest) Reset()         { *m = StopModuleRequest{} }
-func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) }
-func (*StopModuleRequest) ProtoMessage()    {}
-
-func (m *StopModuleRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-func (m *StopModuleRequest) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-type StopModuleResponse struct {
-	XXX_unrecognized []byte `json:"-"`
-}
-
-func (m *StopModuleResponse) Reset()         { *m = StopModuleResponse{} }
-func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) }
-func (*StopModuleResponse) ProtoMessage()    {}
-
-type GetHostnameRequest struct {
-	Module           *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
-	Version          *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
-	Instance         *string `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetHostnameRequest) Reset()         { *m = GetHostnameRequest{} }
-func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) }
-func (*GetHostnameRequest) ProtoMessage()    {}
-
-func (m *GetHostnameRequest) GetModule() string {
-	if m != nil && m.Module != nil {
-		return *m.Module
-	}
-	return ""
-}
-
-func (m *GetHostnameRequest) GetVersion() string {
-	if m != nil && m.Version != nil {
-		return *m.Version
-	}
-	return ""
-}
-
-func (m *GetHostnameRequest) GetInstance() string {
-	if m != nil && m.Instance != nil {
-		return *m.Instance
-	}
-	return ""
-}
-
-type GetHostnameResponse struct {
-	Hostname         *string `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *GetHostnameResponse) Reset()         { *m = GetHostnameResponse{} }
-func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) }
-func (*GetHostnameResponse) ProtoMessage()    {}
-
-func (m *GetHostnameResponse) GetHostname() string {
-	if m != nil && m.Hostname != nil {
-		return *m.Hostname
-	}
-	return ""
-}
-
-func init() {
-}
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
deleted file mode 100644
index d29f0065a2f807b59ec5e3a6a381137ec54acc3d..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto
+++ /dev/null
@@ -1,80 +0,0 @@
-syntax = "proto2";
-option go_package = "modules";
-
-package appengine;
-
-message ModulesServiceError {
-  enum ErrorCode {
-    OK  = 0;
-    INVALID_MODULE = 1;
-    INVALID_VERSION = 2;
-    INVALID_INSTANCES = 3;
-    TRANSIENT_ERROR = 4;
-    UNEXPECTED_STATE = 5;
-  }
-}
-
-message GetModulesRequest {
-}
-
-message GetModulesResponse {
-  repeated string module = 1;
-}
-
-message GetVersionsRequest {
-  optional string module = 1;
-}
-
-message GetVersionsResponse {
-  repeated string version = 1;
-}
-
-message GetDefaultVersionRequest {
-  optional string module = 1;
-}
-
-message GetDefaultVersionResponse {
-  required string version = 1;
-}
-
-message GetNumInstancesRequest {
-  optional string module = 1;
-  optional string version = 2;
-}
-
-message GetNumInstancesResponse {
-  required int64 instances = 1;
-}
-
-message SetNumInstancesRequest {
-  optional string module = 1;
-  optional string version = 2;
-  required int64 instances = 3;
-}
-
-message SetNumInstancesResponse {}
-
-message StartModuleRequest {
-  required string module = 1;
-  required string version = 2;
-}
-
-message StartModuleResponse {}
-
-message StopModuleRequest {
-  optional string module = 1;
-  optional string version = 2;
-}
-
-message StopModuleResponse {}
-
-message GetHostnameRequest {
-  optional string module = 1;
-  optional string version = 2;
-  optional string instance = 3;
-}
-
-message GetHostnameResponse {
-  required string hostname = 1;
-}
-
diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go
deleted file mode 100644
index 3b94cf0c6a8b1bb56666dfffff19620aa7cd2bf7..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/net.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file implements a network dialer that limits the number of concurrent connections.
-// It is only used for API calls.
-
-import (
-	"log"
-	"net"
-	"runtime"
-	"sync"
-	"time"
-)
-
-var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable.
-
-func limitRelease() {
-	// non-blocking
-	select {
-	case <-limitSem:
-	default:
-		// This should not normally happen.
-		log.Print("appengine: unbalanced limitSem release!")
-	}
-}
-
-func limitDial(network, addr string) (net.Conn, error) {
-	limitSem <- 1
-
-	// Dial with a timeout in case the API host is MIA.
-	// The connection should normally be very fast.
-	conn, err := net.DialTimeout(network, addr, 500*time.Millisecond)
-	if err != nil {
-		limitRelease()
-		return nil, err
-	}
-	lc := &limitConn{Conn: conn}
-	runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required
-	return lc, nil
-}
-
-type limitConn struct {
-	close sync.Once
-	net.Conn
-}
-
-func (lc *limitConn) Close() error {
-	defer lc.close.Do(func() {
-		limitRelease()
-		runtime.SetFinalizer(lc, nil)
-	})
-	return lc.Conn.Close()
-}
diff --git a/vendor/google.golang.org/appengine/internal/regen.sh b/vendor/google.golang.org/appengine/internal/regen.sh
deleted file mode 100755
index 2fdb546a63335a08a0c82688066c80291a02a112..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/regen.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/bash -e
-#
-# This script rebuilds the generated code for the protocol buffers.
-# To run this you will need protoc and goprotobuf installed;
-# see https://github.com/golang/protobuf for instructions.
-
-PKG=google.golang.org/appengine
-
-function die() {
-	echo 1>&2 $*
-	exit 1
-}
-
-# Sanity check that the right tools are accessible.
-for tool in go protoc protoc-gen-go; do
-	q=$(which $tool) || die "didn't find $tool"
-	echo 1>&2 "$tool: $q"
-done
-
-echo -n 1>&2 "finding package dir... "
-pkgdir=$(go list -f '{{.Dir}}' $PKG)
-echo 1>&2 $pkgdir
-base=$(echo $pkgdir | sed "s,/$PKG\$,,")
-echo 1>&2 "base: $base"
-cd $base
-
-# Run protoc once per package.
-for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
-	echo 1>&2 "* $dir"
-	protoc --go_out=. $dir/*.proto
-done
-
-for f in $(find $PKG/internal -name '*.pb.go'); do
-  # Remove proto.RegisterEnum calls.
-  # These cause duplicate registration panics when these packages
-  # are used on classic App Engine. proto.RegisterEnum only affects
-  # parsing the text format; we don't care about that.
-  # https://code.google.com/p/googleappengine/issues/detail?id=11670#c17
-  sed -i '/proto.RegisterEnum/d' $f
-done
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
deleted file mode 100644
index 526bd39e6d1a23bd69e999e1349d89e5bbbd69ab..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
+++ /dev/null
@@ -1,231 +0,0 @@
-// Code generated by protoc-gen-go.
-// source: google.golang.org/appengine/internal/remote_api/remote_api.proto
-// DO NOT EDIT!
-
-/*
-Package remote_api is a generated protocol buffer package.
-
-It is generated from these files:
-	google.golang.org/appengine/internal/remote_api/remote_api.proto
-
-It has these top-level messages:
-	Request
-	ApplicationError
-	RpcError
-	Response
-*/
-package remote_api
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-type RpcError_ErrorCode int32
-
-const (
-	RpcError_UNKNOWN             RpcError_ErrorCode = 0
-	RpcError_CALL_NOT_FOUND      RpcError_ErrorCode = 1
-	RpcError_PARSE_ERROR         RpcError_ErrorCode = 2
-	RpcError_SECURITY_VIOLATION  RpcError_ErrorCode = 3
-	RpcError_OVER_QUOTA          RpcError_ErrorCode = 4
-	RpcError_REQUEST_TOO_LARGE   RpcError_ErrorCode = 5
-	RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6
-	RpcError_FEATURE_DISABLED    RpcError_ErrorCode = 7
-	RpcError_BAD_REQUEST         RpcError_ErrorCode = 8
-	RpcError_RESPONSE_TOO_LARGE  RpcError_ErrorCode = 9
-	RpcError_CANCELLED           RpcError_ErrorCode = 10
-	RpcError_REPLAY_ERROR        RpcError_ErrorCode = 11
-	RpcError_DEADLINE_EXCEEDED   RpcError_ErrorCode = 12
-)
-
-var RpcError_ErrorCode_name = map[int32]string{
-	0:  "UNKNOWN",
-	1:  "CALL_NOT_FOUND",
-	2:  "PARSE_ERROR",
-	3:  "SECURITY_VIOLATION",
-	4:  "OVER_QUOTA",
-	5:  "REQUEST_TOO_LARGE",
-	6:  "CAPABILITY_DISABLED",
-	7:  "FEATURE_DISABLED",
-	8:  "BAD_REQUEST",
-	9:  "RESPONSE_TOO_LARGE",
-	10: "CANCELLED",
-	11: "REPLAY_ERROR",
-	12: "DEADLINE_EXCEEDED",
-}
-var RpcError_ErrorCode_value = map[string]int32{
-	"UNKNOWN":             0,
-	"CALL_NOT_FOUND":      1,
-	"PARSE_ERROR":         2,
-	"SECURITY_VIOLATION":  3,
-	"OVER_QUOTA":          4,
-	"REQUEST_TOO_LARGE":   5,
-	"CAPABILITY_DISABLED": 6,
-	"FEATURE_DISABLED":    7,
-	"BAD_REQUEST":         8,
-	"RESPONSE_TOO_LARGE":  9,
-	"CANCELLED":           10,
-	"REPLAY_ERROR":        11,
-	"DEADLINE_EXCEEDED":   12,
-}
-
-func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode {
-	p := new(RpcError_ErrorCode)
-	*p = x
-	return p
-}
-func (x RpcError_ErrorCode) String() string {
-	return proto.EnumName(RpcError_ErrorCode_name, int32(x))
-}
-func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode")
-	if err != nil {
-		return err
-	}
-	*x = RpcError_ErrorCode(value)
-	return nil
-}
-
-type Request struct {
-	ServiceName      *string `protobuf:"bytes,2,req,name=service_name" json:"service_name,omitempty"`
-	Method           *string `protobuf:"bytes,3,req,name=method" json:"method,omitempty"`
-	Request          []byte  `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
-	RequestId        *string `protobuf:"bytes,5,opt,name=request_id" json:"request_id,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *Request) Reset()         { *m = Request{} }
-func (m *Request) String() string { return proto.CompactTextString(m) }
-func (*Request) ProtoMessage()    {}
-
-func (m *Request) GetServiceName() string {
-	if m != nil && m.ServiceName != nil {
-		return *m.ServiceName
-	}
-	return ""
-}
-
-func (m *Request) GetMethod() string {
-	if m != nil && m.Method != nil {
-		return *m.Method
-	}
-	return ""
-}
-
-func (m *Request) GetRequest() []byte {
-	if m != nil {
-		return m.Request
-	}
-	return nil
-}
-
-func (m *Request) GetRequestId() string {
-	if m != nil && m.RequestId != nil {
-		return *m.RequestId
-	}
-	return ""
-}
-
-type ApplicationError struct {
-	Code             *int32  `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
-	Detail           *string `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *ApplicationError) Reset()         { *m = ApplicationError{} }
-func (m *ApplicationError) String() string { return proto.CompactTextString(m) }
-func (*ApplicationError) ProtoMessage()    {}
-
-func (m *ApplicationError) GetCode() int32 {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return 0
-}
-
-func (m *ApplicationError) GetDetail() string {
-	if m != nil && m.Detail != nil {
-		return *m.Detail
-	}
-	return ""
-}
-
-type RpcError struct {
-	Code             *int32  `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
-	Detail           *string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
-	XXX_unrecognized []byte  `json:"-"`
-}
-
-func (m *RpcError) Reset()         { *m = RpcError{} }
-func (m *RpcError) String() string { return proto.CompactTextString(m) }
-func (*RpcError) ProtoMessage()    {}
-
-func (m *RpcError) GetCode() int32 {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return 0
-}
-
-func (m *RpcError) GetDetail() string {
-	if m != nil && m.Detail != nil {
-		return *m.Detail
-	}
-	return ""
-}
-
-type Response struct {
-	Response         []byte            `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
-	Exception        []byte            `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
-	ApplicationError *ApplicationError `protobuf:"bytes,3,opt,name=application_error" json:"application_error,omitempty"`
-	JavaException    []byte            `protobuf:"bytes,4,opt,name=java_exception" json:"java_exception,omitempty"`
-	RpcError         *RpcError         `protobuf:"bytes,5,opt,name=rpc_error" json:"rpc_error,omitempty"`
-	XXX_unrecognized []byte            `json:"-"`
-}
-
-func (m *Response) Reset()         { *m = Response{} }
-func (m *Response) String() string { return proto.CompactTextString(m) }
-func (*Response) ProtoMessage()    {}
-
-func (m *Response) GetResponse() []byte {
-	if m != nil {
-		return m.Response
-	}
-	return nil
-}
-
-func (m *Response) GetException() []byte {
-	if m != nil {
-		return m.Exception
-	}
-	return nil
-}
-
-func (m *Response) GetApplicationError() *ApplicationError {
-	if m != nil {
-		return m.ApplicationError
-	}
-	return nil
-}
-
-func (m *Response) GetJavaException() []byte {
-	if m != nil {
-		return m.JavaException
-	}
-	return nil
-}
-
-func (m *Response) GetRpcError() *RpcError {
-	if m != nil {
-		return m.RpcError
-	}
-	return nil
-}
-
-func init() {
-}
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
deleted file mode 100644
index f21763a4e239ad1ef2daf053725b521d7989e71a..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
+++ /dev/null
@@ -1,44 +0,0 @@
-syntax = "proto2";
-option go_package = "remote_api";
-
-package remote_api;
-
-message Request {
-  required string service_name = 2;
-  required string method = 3;
-  required bytes request = 4;
-  optional string request_id = 5;
-}
-
-message ApplicationError {
-  required int32 code = 1;
-  required string detail = 2;
-}
-
-message RpcError {
-  enum ErrorCode {
-    UNKNOWN = 0;
-    CALL_NOT_FOUND = 1;
-    PARSE_ERROR = 2;
-    SECURITY_VIOLATION = 3;
-    OVER_QUOTA = 4;
-    REQUEST_TOO_LARGE = 5;
-    CAPABILITY_DISABLED = 6;
-    FEATURE_DISABLED = 7;
-    BAD_REQUEST = 8;
-    RESPONSE_TOO_LARGE = 9;
-    CANCELLED = 10;
-    REPLAY_ERROR = 11;
-    DEADLINE_EXCEEDED = 12;
-  }
-  required int32 code = 1;
-  optional string detail = 2;
-}
-
-message Response {
-  optional bytes response = 1;
-  optional bytes exception = 2;
-  optional ApplicationError application_error = 3;
-  optional bytes java_exception = 4;
-  optional RpcError rpc_error = 5;
-}
diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go
deleted file mode 100644
index 28a6d181206149a9e856ac43ce470645268c4dcb..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/internal/transaction.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2014 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package internal
-
-// This file implements hooks for applying datastore transactions.
-
-import (
-	"errors"
-	"reflect"
-
-	"github.com/golang/protobuf/proto"
-	netcontext "golang.org/x/net/context"
-
-	basepb "google.golang.org/appengine/internal/base"
-	pb "google.golang.org/appengine/internal/datastore"
-)
-
-var transactionSetters = make(map[reflect.Type]reflect.Value)
-
-// RegisterTransactionSetter registers a function that sets transaction information
-// in a protocol buffer message. f should be a function with two arguments,
-// the first being a protocol buffer type, and the second being *datastore.Transaction.
-func RegisterTransactionSetter(f interface{}) {
-	v := reflect.ValueOf(f)
-	transactionSetters[v.Type().In(0)] = v
-}
-
-// applyTransaction applies the transaction t to message pb
-// by using the relevant setter passed to RegisterTransactionSetter.
-func applyTransaction(pb proto.Message, t *pb.Transaction) {
-	v := reflect.ValueOf(pb)
-	if f, ok := transactionSetters[v.Type()]; ok {
-		f.Call([]reflect.Value{v, reflect.ValueOf(t)})
-	}
-}
-
-var transactionKey = "used for *Transaction"
-
-func transactionFromContext(ctx netcontext.Context) *transaction {
-	t, _ := ctx.Value(&transactionKey).(*transaction)
-	return t
-}
-
-func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context {
-	return netcontext.WithValue(ctx, &transactionKey, t)
-}
-
-type transaction struct {
-	transaction pb.Transaction
-	finished    bool
-}
-
-var ErrConcurrentTransaction = errors.New("internal: concurrent transaction")
-
-func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool) error {
-	if transactionFromContext(c) != nil {
-		return errors.New("nested transactions are not supported")
-	}
-
-	// Begin the transaction.
-	t := &transaction{}
-	req := &pb.BeginTransactionRequest{
-		App: proto.String(FullyQualifiedAppID(c)),
-	}
-	if xg {
-		req.AllowMultipleEg = proto.Bool(true)
-	}
-	if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil {
-		return err
-	}
-
-	// Call f, rolling back the transaction if f returns a non-nil error, or panics.
-	// The panic is not recovered.
-	defer func() {
-		if t.finished {
-			return
-		}
-		t.finished = true
-		// Ignore the error return value, since we are already returning a non-nil
-		// error (or we're panicking).
-		Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{})
-	}()
-	if err := f(withTransaction(c, t)); err != nil {
-		return err
-	}
-	t.finished = true
-
-	// Commit the transaction.
-	res := &pb.CommitResponse{}
-	err := Call(c, "datastore_v3", "Commit", &t.transaction, res)
-	if ae, ok := err.(*APIError); ok {
-		/* TODO: restore this conditional
-		if appengine.IsDevAppServer() {
-		*/
-		// The Python Dev AppServer raises an ApplicationError with error code 2 (which is
-		// Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.".
-		if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." {
-			return ErrConcurrentTransaction
-		}
-		if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) {
-			return ErrConcurrentTransaction
-		}
-	}
-	return err
-}
diff --git a/vendor/google.golang.org/appengine/namespace.go b/vendor/google.golang.org/appengine/namespace.go
deleted file mode 100644
index 21860ca08227cde4901f65c0cd82520537d18f68..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/namespace.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2012 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package appengine
-
-import (
-	"fmt"
-	"regexp"
-
-	"golang.org/x/net/context"
-
-	"google.golang.org/appengine/internal"
-)
-
-// Namespace returns a replacement context that operates within the given namespace.
-func Namespace(c context.Context, namespace string) (context.Context, error) {
-	if !validNamespace.MatchString(namespace) {
-		return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace)
-	}
-	return internal.NamespacedContext(c, namespace), nil
-}
-
-// validNamespace matches valid namespace names.
-var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`)
diff --git a/vendor/google.golang.org/appengine/timeout.go b/vendor/google.golang.org/appengine/timeout.go
deleted file mode 100644
index 05642a992a39eeed3662519c08dd4937f09d6a6c..0000000000000000000000000000000000000000
--- a/vendor/google.golang.org/appengine/timeout.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2013 Google Inc. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package appengine
-
-import "golang.org/x/net/context"
-
-// IsTimeoutError reports whether err is a timeout error.
-func IsTimeoutError(err error) bool {
-	if err == context.DeadlineExceeded {
-		return true
-	}
-	if t, ok := err.(interface {
-		IsTimeout() bool
-	}); ok {
-		return t.IsTimeout()
-	}
-	return false
-}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 652917e085fc77aae5541f6e387299af1f176276..192b038101f0788c497ed6c8ba586de8dc158b70 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -20,6 +20,30 @@
 			"revision": "bbf7a2afc14f93e1e0a5c06df524fbd75e5031e5",
 			"revisionTime": "2017-03-24T14:02:28Z"
 		},
+		{
+			"checksumSHA1": "BlfYVRUk8gVLCXtbqy4JBVFMPTg=",
+			"path": "github.com/clipperhouse/set",
+			"revision": "c425a638bbb3034eaa3dfe8c2f0f4bc29129b7fc",
+			"revisionTime": "2015-03-04T20:45:47Z"
+		},
+		{
+			"checksumSHA1": "C+JncsAI7+mxsVAvx/7lo1p9Pvs=",
+			"path": "github.com/clipperhouse/slice",
+			"revision": "3ae82e00044e045370183e264317ec785b8f0da3",
+			"revisionTime": "2015-03-01T17:33:39Z"
+		},
+		{
+			"checksumSHA1": "NM+gxNbuon8DgHMmdVwHUhwmMyI=",
+			"path": "github.com/clipperhouse/stringer",
+			"revision": "a8382ce6af9a129cab27e7595ef44a4c2b817360",
+			"revisionTime": "2016-04-10T22:32:32Z"
+		},
+		{
+			"checksumSHA1": "APx+deQijXJSBgYle3eao7O+yLE=",
+			"path": "github.com/clipperhouse/typewriter",
+			"revision": "c1a48da378ebb7db1db9f35981b5cc24bf2e5b85",
+			"revisionTime": "2016-12-20T22:28:20Z"
+		},
 		{
 			"checksumSHA1": "vM0AXBjMyPUVF7sLxjXX0to78l0=",
 			"path": "github.com/coreos/go-oidc/http",
@@ -106,6 +130,12 @@
 			"version": "v1.2",
 			"versionExact": "v1.2"
 		},
+		{
+			"checksumSHA1": "p5z5hdUt68Z3tK7Is+yLGrCNzoA=",
+			"path": "github.com/fatih/color",
+			"revision": "5df930a27be2502f99b292b7cc09ebad4d0891f4",
+			"revisionTime": "2017-09-26T11:14:11Z"
+		},
 		{
 			"checksumSHA1": "ImX1uv6O09ggFeBPUJJ2nu7MPSA=",
 			"path": "github.com/ghodss/yaml",
@@ -155,22 +185,22 @@
 			"revisionTime": "2016-01-25T20:49:56Z"
 		},
 		{
-			"checksumSHA1": "yqF125xVSkmfLpIVGrLlfE05IUk=",
-			"path": "github.com/golang/protobuf/proto",
-			"revision": "ab9f9a6dab164b7d1246e0e688b0ab7b94d8553e",
-			"revisionTime": "2017-08-16T00:15:14Z"
+			"checksumSHA1": "cDO97b41LeLcrTxo4kSBTu2EXLo=",
+			"path": "github.com/google/go-jsonnet",
+			"revision": "e8f6d25f61d163deee16a78b545f4aaa0f295c01",
+			"revisionTime": "2017-10-25T22:39:20Z"
 		},
 		{
-			"checksumSHA1": "pks4vOMGe/SWJkCPDraWp6B4kZQ=",
+			"checksumSHA1": "TWB9bLGW9VSQZYw5eZUKg4RZlr4=",
 			"path": "github.com/google/go-jsonnet/ast",
-			"revision": "5cd467fd1885ca5527a3ab19c45baf9ddc786249",
-			"revisionTime": "2017-08-24T19:11:05Z"
+			"revision": "968ae23435fca7e3c2f4e8396dc49497ee96e0e2",
+			"revisionTime": "2017-10-25T03:00:40Z"
 		},
 		{
-			"checksumSHA1": "FdqrqmPqoaxcw2O22+/l2HXv9Zg=",
+			"checksumSHA1": "uG3PovrccCfWMZBI0guARaKzbYU=",
 			"path": "github.com/google/go-jsonnet/parser",
-			"revision": "5cd467fd1885ca5527a3ab19c45baf9ddc786249",
-			"revisionTime": "2017-08-24T19:11:05Z"
+			"revision": "968ae23435fca7e3c2f4e8396dc49497ee96e0e2",
+			"revisionTime": "2017-10-25T03:00:40Z"
 		},
 		{
 			"checksumSHA1": "fgPBEKvm7D7y4IMxGaxHsPmtYtU=",
@@ -250,6 +280,12 @@
 			"revision": "3f09c2282fc5ad74b3d04a485311f3173c2431d3",
 			"revisionTime": "2017-04-26T07:38:02Z"
 		},
+		{
+			"checksumSHA1": "i+X88NaP9sqkBeCn8s9dPb+ET2Y=",
+			"path": "github.com/mattn/go-colorable",
+			"revision": "ad5389df28cdac544c99bd7b9161a0b5b6ca9d1b",
+			"revisionTime": "2017-08-16T03:18:13Z"
+		},
 		{
 			"checksumSHA1": "U6lX43KDDlNOn+Z0Yyww+ZzHfFo=",
 			"path": "github.com/mattn/go-isatty",
@@ -496,12 +532,6 @@
 			"revision": "f6abca593680b2315d2075e0f5e2a9751e3f431a",
 			"revisionTime": "2017-06-01T20:57:54Z"
 		},
-		{
-			"checksumSHA1": "zHXKW3VTfu4Dswo3GTsCGVCZuw4=",
-			"path": "github.com/strickyak/jsonnet_cgo",
-			"revision": "04f8990f6dd09242167d7320e3267a4326ffdcfb",
-			"revisionTime": "2017-06-22T22:16:47Z"
-		},
 		{
 			"checksumSHA1": "MxLnUmfrP+r5HfCZM29+WPKebn8=",
 			"path": "github.com/ugorji/go/codec",
@@ -737,52 +767,22 @@
 			"revisionTime": "2017-04-21T08:09:44Z"
 		},
 		{
-			"checksumSHA1": "WPEbk80NB3Esdh4Yk0PXr2K7xVU=",
-			"path": "google.golang.org/appengine",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
-		},
-		{
-			"checksumSHA1": "/XD6hF+tqSNrfPrFmukDeHKFVVA=",
-			"path": "google.golang.org/appengine/internal",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
-		},
-		{
-			"checksumSHA1": "x6Thdfyasqd68dWZWqzWWeIfAfI=",
-			"path": "google.golang.org/appengine/internal/app_identity",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
-		},
-		{
-			"checksumSHA1": "TsNO8P0xUlLNyh3Ic/tzSp/fDWM=",
-			"path": "google.golang.org/appengine/internal/base",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
-		},
-		{
-			"checksumSHA1": "5QsV5oLGSfKZqTCVXP6NRz5T4Tw=",
-			"path": "google.golang.org/appengine/internal/datastore",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
-		},
-		{
-			"checksumSHA1": "Gep2T9zmVYV8qZfK2gu3zrmG6QE=",
-			"path": "google.golang.org/appengine/internal/log",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
+			"checksumSHA1": "8bP6iLolDGDRKAnx89Qb/OatWDE=",
+			"path": "golang.org/x/tools/go/ast/astutil",
+			"revision": "9b61fcc4c548d69663d915801fc4b42a43b6cd9c",
+			"revisionTime": "2017-10-24T20:47:09Z"
 		},
 		{
-			"checksumSHA1": "eLZVX1EHLclFtQnjDIszsdyWRHo=",
-			"path": "google.golang.org/appengine/internal/modules",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
+			"checksumSHA1": "o6uoZozSLnj3Ph+hj399ZPqJYhE=",
+			"path": "golang.org/x/tools/go/gcimporter15",
+			"revision": "9b61fcc4c548d69663d915801fc4b42a43b6cd9c",
+			"revisionTime": "2017-10-24T20:47:09Z"
 		},
 		{
-			"checksumSHA1": "a1XY7rz3BieOVqVI2Et6rKiwQCk=",
-			"path": "google.golang.org/appengine/internal/remote_api",
-			"revision": "d9a072cfa7b9736e44311ef77b3e09d804bfa599",
-			"revisionTime": "2017-08-14T19:09:42Z"
+			"checksumSHA1": "nTSuDBk95d0rNSqK8YF72I9orHA=",
+			"path": "golang.org/x/tools/imports",
+			"revision": "9b61fcc4c548d69663d915801fc4b42a43b6cd9c",
+			"revisionTime": "2017-10-24T20:47:09Z"
 		},
 		{
 			"checksumSHA1": "6f8MEU31llHM1sLM/GGH4/Qxu0A=",