diff --git a/src/margo.sh/Gopkg.lock b/src/margo.sh/Gopkg.lock
index de10f658..8c58e411 100644
--- a/src/margo.sh/Gopkg.lock
+++ b/src/margo.sh/Gopkg.lock
@@ -17,17 +17,39 @@
   branch = "master"
   name = "golang.org/x/crypto"
   packages = ["blake2b"]
-  revision = "2c241ca3045ddc354463c376a9515d9f1f1390a4"
+  revision = "4ec37c66abab2c7e02ae775328b2ff001c3f025a"
 
 [[projects]]
   branch = "master"
   name = "golang.org/x/sys"
   packages = ["cpu"]
-  revision = "78d5f264b493f125018180c204871ecf58a2dce1"
+  revision = "7db1c3b1a98089d0071c84f646ff5c96aad43682"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/tools"
+  packages = [
+    "cmd/guru",
+    "cmd/guru/serial",
+    "container/intsets",
+    "go/ast/astutil",
+    "go/buildutil",
+    "go/callgraph",
+    "go/callgraph/static",
+    "go/loader",
+    "go/pointer",
+    "go/ssa",
+    "go/ssa/ssautil",
+    "go/types/typeutil",
+    "imports",
+    "internal/fastwalk",
+    "refactor/importgraph"
+  ]
+  revision = "87723262609ca8fd55d449c027454c29cadefd68"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "a7d8a00d2d704fb62eed79ee67536c295268edae7c67b316af3af70397acad95"
+  inputs-digest = "d929fab6918d1833fd0bf96d285bc438bfa936590205bbba2e182511b2bf6ac5"
   solver-name = "gps-cdcl"
   solver-version = 1
diff --git a/src/margo.sh/Gopkg.toml b/src/margo.sh/Gopkg.toml
index 48f5c2eb..9d2cfa57 100644
--- a/src/margo.sh/Gopkg.toml
+++ b/src/margo.sh/Gopkg.toml
@@ -1,3 +1,11 @@
+required = [
+	"golang.org/x/tools/cmd/guru"
+]
+
+[prune]
+  go-tests = true
+  unused-packages = true
+
 [[constraint]]
   name = "github.com/ugorji/go"
   branch = "master"
@@ -10,6 +18,6 @@
   branch = "master"
   name = "golang.org/x/crypto"
 
-[prune]
-  go-tests = true
-  unused-packages = true
+[[constraint]]
+  branch = "master"
+  name = "golang.org/x/tools"
diff --git a/src/margo.sh/cmdpkg/margosublime/main.go b/src/margo.sh/cmdpkg/margosublime/main.go
index 90644935..9041a7c2 100644
--- a/src/margo.sh/cmdpkg/margosublime/main.go
+++ b/src/margo.sh/cmdpkg/margosublime/main.go
@@ -33,7 +33,7 @@ func Main() {
 			return mgcli.Error("agent creation failed:", err)
 		}
 
-		ag.Store.EditorConfig(sublime.DefaultConfig)
+		ag.Store.SetBaseConfig(sublime.DefaultConfig)
 		if margoExt != nil {
 			margoExt(ag.Args())
 		}
diff --git a/src/margo.sh/extension-example/extension-example.go b/src/margo.sh/extension-example/extension-example.go
index 860aaba4..9d89e3b0 100644
--- a/src/margo.sh/extension-example/extension-example.go
+++ b/src/margo.sh/extension-example/extension-example.go
@@ -12,12 +12,12 @@ func Margo(ma mg.Args) {
 	// they are run in the specified order
 	// and should ideally not block for more than a couple milliseconds
 	ma.Store.Use(
-		// by default, events (e.g. ViewSaved) are triggered in all files
-		// uncomment the reducer below to restict event to Go(-lang) files
-		// please note, however, that this mode is not tested
+		// By default, events (e.g. ViewSaved) are triggered in all files.
+		// Uncomment the reducer below to restict events to Go(-lang) files.
+		// Please note, however, that this mode is not tested
 		// and saving a non-go file will not trigger linters, etc. for that go pkg
 		//
-		// mg.Reduce(func(mx *mg.Ctx) *mg.State {
+		// mg.NewReducer(func(mx *mg.Ctx) *mg.State {
 		// 	return mx.SetConfig(mx.Config.EnabledForLangs("go"))
 		// }),
 
diff --git a/src/margo.sh/format/format.go b/src/margo.sh/format/format.go
index b2bd1226..2520cec2 100644
--- a/src/margo.sh/format/format.go
+++ b/src/margo.sh/format/format.go
@@ -19,22 +19,20 @@ type FmtFunc struct {
 	Fmt func(mx *mg.Ctx, src []byte) ([]byte, error)
 
 	// Langs is the list of languages in which the reducer should run
-	Langs []string
+	Langs []mg.Lang
 
-	// Actions is a list of additional actions on which the reducer is allowed to run.
+	// Actions is a list of actions on which the reducer is allowed to run.
 	// The reducer always runs on the ViewFmt action, even if this list is empty.
 	Actions []mg.Action
 }
 
+// ReducerCond returns true if Langs and Actions matches the Ctx
+func (ff FmtFunc) ReducerCond(mx *mg.Ctx) bool {
+	return mx.ActionIs(ff.Actions...) && mx.LangIs(ff.Langs...)
+}
+
 // Reduce implements the FmtFunc reducer.
 func (ff FmtFunc) Reduce(mx *mg.Ctx) *mg.State {
-	if !mx.LangIs(ff.Langs...) {
-		return mx.State
-	}
-	if !mx.ActionIs(mg.ViewFmt{}) && !mx.ActionIs(ff.Actions...) {
-		return mx.State
-	}
-
 	fn := mx.View.Filename()
 	src, err := mx.View.ReadAll()
 	if err != nil {
@@ -48,7 +46,7 @@ func (ff FmtFunc) Reduce(mx *mg.Ctx) *mg.State {
 	if err != nil {
 		return mx.AddErrorf("failed to fmt %s: %s\n", fn, err)
 	}
-	return mx.SetSrc(src)
+	return mx.SetViewSrc(src)
 }
 
 // FmtCmd is wrapper around FmtFunc for generic fmt commands.
@@ -66,9 +64,9 @@ type FmtCmd struct {
 	Env mg.EnvMap
 
 	// Langs is the list of languages in which the reducer should run
-	Langs []string
+	Langs []mg.Lang
 
-	// Actions is a list of additional actions on which the reducer is allowed to run.
+	// Actions is a list of actions on which the reducer is allowed to run.
 	// The reducer always runs on the ViewFmt action, even if this list is empty.
 	Actions []mg.Action
 }
diff --git a/src/margo.sh/golang/common.go b/src/margo.sh/golang/common.go
index bff089b6..e2925a9c 100644
--- a/src/margo.sh/golang/common.go
+++ b/src/margo.sh/golang/common.go
@@ -1,10 +1,10 @@
 package golang
 
 import (
-	"margo.sh/mg"
 	"go/ast"
 	"go/build"
 	"go/token"
+	"margo.sh/mg"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -14,12 +14,12 @@ import (
 	"unicode/utf8"
 )
 
-var (
-	CommonPatterns = append([]*regexp.Regexp{
+func init() {
+	mg.AddCommonPatterns(mg.Go,
 		regexp.MustCompile(`^\s*(?P<path>.+?\.\w+):(?P<line>\d+:)(?P<column>\d+:?)?(?:(?P<tag>warning|error)[:])?(?P<message>.+?)(?: [(](?P<label>[-\w]+)[)])?$`),
 		regexp.MustCompile(`(?P<message>can't load package: package .+: found packages .+ \((?P<path>.+?\.go)\).+)`),
-	}, mg.CommonPatterns...)
-)
+	)
+}
 
 func BuildContext(mx *mg.Ctx) *build.Context {
 	c := build.Default
diff --git a/src/margo.sh/golang/gocmd.go b/src/margo.sh/golang/gocmd.go
index 307e6486..7e100e2a 100644
--- a/src/margo.sh/golang/gocmd.go
+++ b/src/margo.sh/golang/gocmd.go
@@ -115,7 +115,7 @@ func (gc *GoCmd) playTempDir(bx *mg.BultinCmdCtx) (newBx *mg.BultinCmdCtx, tDir
 		return bx, "", "", fmt.Errorf("cannot MkTempDir: %s", err)
 	}
 
-	if !bx.LangIs("go") {
+	if !bx.LangIs(mg.Go) {
 		return bx, tDir, "", nil
 	}
 
@@ -202,7 +202,7 @@ func newGoCmdCtx(bx *mg.BultinCmdCtx, label, cancelID string, tDir, tFn string)
 
 	gx.iw = &mg.IssueWriter{
 		Base:     mg.Issue{Label: label},
-		Patterns: CommonPatterns,
+		Patterns: bx.CommonPatterns(),
 		Dir:      gx.pkgDir,
 	}
 
@@ -240,6 +240,6 @@ func (gx *goCmdCtx) run(origView *mg.View) error {
 		ik.Dir = origView.Dir()
 	}
 
-	gx.Store.Dispatch(mg.StoreIssues{Key: ik, Issues: issues})
+	gx.Store.Dispatch(mg.StoreIssues{IssueKey: ik, Issues: issues})
 	return err
 }
diff --git a/src/margo.sh/golang/gocode.go b/src/margo.sh/golang/gocode.go
index 5faa4896..a3977486 100644
--- a/src/margo.sh/golang/gocode.go
+++ b/src/margo.sh/golang/gocode.go
@@ -11,7 +11,7 @@ import (
 	"io"
 	"margo.sh/golang/internal/gocode"
 	"margo.sh/mg"
-	"margo.sh/misc/pf"
+	"margo.sh/mgpf"
 	"margo.sh/sublime"
 	"strings"
 	"time"
@@ -71,7 +71,13 @@ func (g *Gocode) ReducerConfig(mx *mg.Ctx) mg.EditorConfig {
 		return nil
 	}
 
+	// ST might query the GoSublime plugin first, so we must always disable it
 	cfg = cfg.DisableGsComplete()
+	// but we don't want to affect editor completions in non-go files
+	if !g.ReducerCond(mx) {
+		return cfg
+	}
+
 	if !g.AllowExplicitCompletions {
 		cfg = cfg.InhibitExplicitCompletions()
 	}
@@ -82,7 +88,7 @@ func (g *Gocode) ReducerConfig(mx *mg.Ctx) mg.EditorConfig {
 }
 
 func (g *Gocode) ReducerCond(mx *mg.Ctx) bool {
-	return mx.LangIs("go") && mx.ActionIs(mg.QueryCompletions{})
+	return mx.ActionIs(mg.QueryCompletions{}) && mx.LangIs(mg.Go)
 }
 
 func (g *Gocode) ReducerMount(mx *mg.Ctx) {
@@ -116,7 +122,7 @@ func (g *Gocode) Reduce(mx *mg.Ctx) *mg.State {
 	select {
 	case g.reqs <- gr:
 	case <-time.After(qTimeout):
-		mx.Log.Println("gocode didn't accept the request after", pf.D(time.Since(start)))
+		mx.Log.Println("gocode didn't accept the request after", mgpf.D(time.Since(start)))
 		return st
 	}
 
@@ -131,10 +137,10 @@ func (g *Gocode) Reduce(mx *mg.Ctx) *mg.State {
 	case <-time.After(pTimeout):
 		go func() {
 			<-gr.res
-			mx.Log.Println("gocode eventually responded after", pf.Since(start))
+			mx.Log.Println("gocode eventually responded after", mgpf.Since(start))
 		}()
 
-		mx.Log.Println("gocode didn't respond after", pf.D(pTimeout), "taking", pf.Since(start))
+		mx.Log.Println("gocode didn't respond after", mgpf.D(pTimeout), "taking", mgpf.Since(start))
 		return st
 	}
 }
diff --git a/src/margo.sh/golang/gocode_calltips.go b/src/margo.sh/golang/gocode_calltips.go
index dad7d082..34d7b85d 100644
--- a/src/margo.sh/golang/gocode_calltips.go
+++ b/src/margo.sh/golang/gocode_calltips.go
@@ -27,7 +27,7 @@ type GocodeCalltips struct {
 }
 
 func (gc *GocodeCalltips) ReducerCond(mx *mg.Ctx) bool {
-	return mx.LangIs("go")
+	return mx.LangIs(mg.Go)
 }
 
 func (gc *GocodeCalltips) ReducerMount(mx *mg.Ctx) {
diff --git a/src/margo.sh/golang/gofmt.go b/src/margo.sh/golang/gofmt.go
index 402c996f..6558f981 100644
--- a/src/margo.sh/golang/gofmt.go
+++ b/src/margo.sh/golang/gofmt.go
@@ -10,6 +10,12 @@ import (
 var (
 	GoFmt     mg.Reducer = mg.NewReducer(goFmt)
 	GoImports mg.Reducer = mg.NewReducer(goImports)
+
+	commonFmtLangs   = []mg.Lang{mg.Go}
+	commonFmtActions = []mg.Action{
+		mg.ViewFmt{},
+		mg.ViewPreSave{},
+	}
 )
 
 func disableGsFmt(st *mg.State) *mg.State {
@@ -24,8 +30,8 @@ type FmtFunc func(mx *mg.Ctx, src []byte) ([]byte, error)
 func (ff FmtFunc) Reduce(mx *mg.Ctx) *mg.State {
 	return disableGsFmt(mgformat.FmtFunc{
 		Fmt:     ff,
-		Langs:   []string{"go"},
-		Actions: []mg.Action{mg.ViewPreSave{}},
+		Langs:   commonFmtLangs,
+		Actions: commonFmtActions,
 	}.Reduce(mx))
 }
 
@@ -39,7 +45,7 @@ func goImports(mx *mg.Ctx) *mg.State {
 	return disableGsFmt(mgformat.FmtCmd{
 		Name:    "goimports",
 		Args:    []string{"-srcdir", mx.View.Filename()},
-		Langs:   []string{"go"},
-		Actions: []mg.Action{mg.ViewPreSave{}},
+		Langs:   commonFmtLangs,
+		Actions: commonFmtActions,
 	}.Reduce(mx))
 }
diff --git a/src/margo.sh/golang/guru.go b/src/margo.sh/golang/guru.go
new file mode 100644
index 00000000..8e017a2e
--- /dev/null
+++ b/src/margo.sh/golang/guru.go
@@ -0,0 +1,133 @@
+package golang
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"margo.sh/cmdpkg/margo/cmdrunner"
+	"margo.sh/mg"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+)
+
+var (
+	fnPosPat = regexp.MustCompile(`^(.+):(\d+):(\d+)$`)
+)
+
+type Guru struct {
+	mg.ReducerType
+}
+
+func (g *Guru) ReducerCond(mx *mg.Ctx) bool {
+	return mx.LangIs(mg.Go)
+}
+
+func (g *Guru) ReducerMount(mx *mg.Ctx) {
+	go cmdrunner.Cmd{
+		Name:     "go",
+		Args:     []string{"install", "margo.sh/vendor/golang.org/x/tools/cmd/guru"},
+		OutToErr: true,
+	}.Run()
+}
+
+func (g *Guru) Reduce(mx *mg.Ctx) *mg.State {
+	switch mx.Action.(type) {
+	case mg.QueryUserCmds:
+		return mx.AddUserCmds(
+			mg.UserCmd{
+				Title: "Guru Definition",
+				Name:  "guru.definition",
+				Desc:  "show declaration of selected identifier",
+			},
+		)
+	case mg.RunCmd:
+		runDef := func(bx *mg.BultinCmdCtx) *mg.State {
+			go g.definition(bx)
+			return bx.State
+		}
+		return mx.AddBuiltinCmds(
+			mg.BultinCmd{Name: "goto.definition", Run: runDef},
+			mg.BultinCmd{Name: "guru.definition", Run: runDef},
+		)
+	default:
+		return mx.State
+	}
+}
+
+func (g *Guru) definition(bx *mg.BultinCmdCtx) {
+	defer bx.Output.Close()
+	defer bx.Begin(mg.Task{Title: "guru definition", ShowNow: true}).Done()
+
+	v := bx.View
+	dir := v.Dir()
+	fn := v.Filename()
+
+	if v.Path == "" {
+		tmpDir, err := ioutil.TempDir("", "guru")
+		if err == nil {
+			defer os.RemoveAll(tmpDir)
+			fn = filepath.Join(tmpDir, v.Name)
+			src, _ := v.ReadAll()
+			ioutil.WriteFile(fn, src, 0600)
+		}
+	}
+
+	cmd := exec.Command(
+		"/user/gp/bin/guru",
+		"-json",
+		"-modified",
+		"definition",
+		fmt.Sprintf("%s:#%d", fn, v.Pos),
+	)
+	cmd.Dir = dir
+	buf := &bytes.Buffer{}
+	cmd.Stdout = buf
+	cmd.Stderr = bx.Output
+	if v.Dirty {
+		src, _ := v.ReadAll()
+		hdr := &bytes.Buffer{}
+		fmt.Fprintf(hdr, "%s\n%d\n", fn, len(src))
+		cmd.Stdin = io.MultiReader(hdr, bytes.NewReader(src))
+	}
+
+	if err := cmd.Run(); err != nil {
+		fmt.Fprintln(bx.Output, "Error:", err)
+		return
+	}
+
+	res := struct {
+		ObjPos string `json:"objpos"`
+	}{}
+	if err := json.Unmarshal(buf.Bytes(), &res); err != nil {
+		fmt.Fprintln(bx.Output, "cannot decode guru output:", err)
+	}
+
+	m := fnPosPat.FindStringSubmatch(res.ObjPos)
+	if len(m) != 4 {
+		fmt.Fprintln(bx.Output, "cannot parse guru objpos:", res.ObjPos)
+		return
+	}
+
+	n := func(s string) int {
+		n, _ := strconv.Atoi(s)
+		if n > 0 {
+			return n - 1
+		}
+		return 0
+	}
+
+	fn = m[1]
+	if v.Path == "" && filepath.Base(fn) == v.Name {
+		fn = v.Name
+	}
+	bx.Store.Dispatch(mg.Activate{
+		Path: fn,
+		Row:  n(m[2]),
+		Col:  n(m[3]),
+	})
+}
diff --git a/src/margo.sh/golang/internal/gocode/bridge._margo_.go b/src/margo.sh/golang/internal/gocode/bridge._margo_.go
index eb3c08ad..b34cbc9d 100644
--- a/src/margo.sh/golang/internal/gocode/bridge._margo_.go
+++ b/src/margo.sh/golang/internal/gocode/bridge._margo_.go
@@ -3,9 +3,7 @@
 package gocode
 
 import (
-	"fmt"
 	"go/build"
-	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -132,11 +130,9 @@ func (m *margoState) updateConfig(c MargoConfig, filename string) {
 	}
 	if m.prevPkg != m.env.CurrentPackagePath {
 		m.prevPkg = m.env.CurrentPackagePath
-		fmt.Fprintf(os.Stderr, "Gocode pkg: %#v\n", m.env.CurrentPackagePath)
 	}
 	if m.prevEnv != nv {
 		m.prevEnv = nv
-		fmt.Fprintf(os.Stderr, "Gocode env: %#v\n", nv)
 	}
 
 	g_daemon.autocomplete = m.ctx
diff --git a/src/margo.sh/golang/lint.go b/src/margo.sh/golang/lint.go
index 26663f19..91ede660 100644
--- a/src/margo.sh/golang/lint.go
+++ b/src/margo.sh/golang/lint.go
@@ -1,151 +1,44 @@
 package golang
 
 import (
-	"bytes"
 	"margo.sh/mg"
-	"os"
-	"os/exec"
-	"regexp"
-	"sync"
 )
 
-type LintArgs struct {
-	Writer *mg.IssueWriter
-	Env    mg.EnvMap
-	Dir    string
-}
-
-type LintFunc func(LintArgs) error
-
-type LinterOpts struct {
-	Log      *mg.Logger
-	Actions  []mg.Action
-	Patterns []*regexp.Regexp
-	Lint     LintFunc
-	Label    string
-}
-
-type linterSupport struct {
-	nCh    chan struct{}
-	mu     sync.RWMutex
-	dir    string
-	issues mg.IssueSet
-}
-
-func (ls *linterSupport) Reduce(lo LinterOpts, mx *mg.Ctx) *mg.State {
-	ls.mu.RLock()
-	defer ls.mu.RUnlock()
-
-	if mx.ActionIs(mg.Started{}) {
-		ls.start(lo, mx.Store)
-	}
-	dir := mx.View.Dir()
-	if mx.ActionIs(lo.Actions...) && IsPkgDir(dir) {
-		ls.notify()
-	}
-
-	if ls.dir == dir {
-		return mx.State.AddIssues(ls.issues...)
-	}
-	return mx.State
-}
-
-func (ls *linterSupport) Command(la LintArgs, name string, args ...string) *exec.Cmd {
-	cmd := exec.Command(name, args...)
-	cmd.Env = la.Env.Environ()
-	cmd.Stdout = la.Writer
-	cmd.Stderr = la.Writer
-	cmd.Dir = la.Dir
-	return cmd
-}
-
-func (ls *linterSupport) notify() {
-	select {
-	case ls.nCh <- struct{}{}:
-	default:
-	}
-}
-
-func (ls *linterSupport) start(lo LinterOpts, sto *mg.Store) {
-	ls.nCh = make(chan struct{}, 1)
-	go ls.loop(lo, sto)
-}
-
-func (ls *linterSupport) loop(lo LinterOpts, sto *mg.Store) {
-	for range ls.nCh {
-		st := sto.State()
-		dir := st.View.Dir()
-		if IsPkgDir(dir) {
-			ls.lint(lo, sto.Dispatch, st, dir)
-		}
-	}
-}
-
-func (ls *linterSupport) lint(lo LinterOpts, dispatch mg.Dispatcher, st *mg.State, dir string) {
-	defer dispatch(mg.Render)
-
-	buf := bytes.NewBuffer(nil)
-	w := &mg.IssueWriter{
-		Writer:   buf,
-		Patterns: lo.Patterns,
-		Base:     mg.Issue{Tag: mg.IssueError, Label: lo.Label},
-		Dir:      dir,
-	}
-	if len(w.Patterns) == 0 {
-		w.Patterns = CommonPatterns
-	}
-	err := lo.Lint(LintArgs{
-		Writer: w,
-		Env:    st.Env,
-		Dir:    dir,
-	})
-	w.Flush()
-	issues := w.Issues()
-	if len(issues) == 0 && err != nil {
-		out := bytes.TrimSpace(buf.Bytes())
-		lo.Log.Printf("golang.linterSupport: '%s' in '%s' failed: %s\n%s\n", lo.Label, dir, err, out)
-	}
+// Linter wraps mg.Linter to restrict its Langs to Go
+//
+// all top-level fields are passed along to the underlying Linter
+type Linter struct {
+	mg.Linter
 
-	ls.mu.Lock()
-	ls.dir = dir
-	ls.issues = issues
-	ls.mu.Unlock()
-}
+	Actions []mg.Action
 
-type Linter struct {
-	mg.ReducerType
-	linterSupport
+	Name string
+	Args []string
 
-	Name    string
-	Args    []string
+	Tag     mg.IssueTag
 	Label   string
 	TempDir []string
 }
 
-func (lt *Linter) Reduce(mx *mg.Ctx) *mg.State {
-	return lt.linterSupport.Reduce(LinterOpts{
-		Log:      mx.Log,
-		Actions:  []mg.Action{mg.ViewSaved{}},
-		Patterns: CommonPatterns,
-		Lint:     lt.lint,
-		Label:    lt.Label,
-	}, mx)
+// ReducerInit syncs top-level fields with the underlying Linter
+func (lt *Linter) ReducerInit(mx *mg.Ctx) {
+	l := &lt.Linter
+	l.Actions = lt.Actions
+	l.Name = lt.Name
+	l.Args = lt.Args
+	l.Tag = lt.Tag
+	l.Label = lt.Label
+	l.TempDir = lt.TempDir
+
+	lt.Linter.ReducerInit(mx)
 }
 
-func (lt *Linter) lint(la LintArgs) error {
-	if len(lt.TempDir) != 0 {
-		tmpDir, err := mg.MkTempDir(lt.Label)
-		if err != nil {
-			return err
-		}
-		defer os.RemoveAll(tmpDir)
-		for _, k := range lt.TempDir {
-			la.Env = la.Env.Add(k, tmpDir)
-		}
-	}
-	return lt.Command(la, lt.Name, lt.Args...).Run()
+// ReducerCond restricts reduction to Go
+func (lt *Linter) ReducerCond(mx *mg.Ctx) bool {
+	return mx.LangIs(mg.Go) && lt.Linter.ReducerCond(mx)
 }
 
+// GoInstall returns a Linter that runs `go install args...`
 func GoInstall(args ...string) *Linter {
 	return &Linter{
 		Name:  "go",
@@ -154,12 +47,19 @@ func GoInstall(args ...string) *Linter {
 	}
 }
 
+// GoInstallDiscardBinaries returns a Linter that runs `go install args...`
+// it's like GoInstall, but additionally sets GOBIN to a temp directory
+// resulting in all binaries being discarded
 func GoInstallDiscardBinaries(args ...string) *Linter {
-	lt := GoInstall(args...)
-	lt.TempDir = append(lt.TempDir, "GOBIN")
-	return lt
+	return &Linter{
+		Name:    "go",
+		Args:    append([]string{"install"}, args...),
+		Label:   "Go/Install",
+		TempDir: []string{"GOBIN"},
+	}
 }
 
+// GoVet returns a Linter that runs `go vet args...`
 func GoVet(args ...string) *Linter {
 	return &Linter{
 		Name:  "go",
@@ -168,6 +68,7 @@ func GoVet(args ...string) *Linter {
 	}
 }
 
+// GoTest returns a Linter that runs `go test args...`
 func GoTest(args ...string) *Linter {
 	return &Linter{
 		Name:  "go",
diff --git a/src/margo.sh/golang/snippets.go b/src/margo.sh/golang/snippets.go
index 29c396e7..176b027a 100644
--- a/src/margo.sh/golang/snippets.go
+++ b/src/margo.sh/golang/snippets.go
@@ -34,11 +34,11 @@ func SnippetFuncs(l ...SnippetFunc) *SnippetFuncsList {
 	return &SnippetFuncsList{Funcs: l}
 }
 
-func (sf *SnippetFuncsList) Reduce(mx *mg.Ctx) *mg.State {
-	if !mx.LangIs("go") || !mx.ActionIs(mg.QueryCompletions{}) {
-		return mx.State
-	}
+func (sf *SnippetFuncsList) ReducerCond(mx *mg.Ctx) bool {
+	return mx.ActionIs(mg.QueryCompletions{}) && mx.LangIs(mg.Go)
+}
 
+func (sf *SnippetFuncsList) Reduce(mx *mg.Ctx) *mg.State {
 	src, _ := mx.View.ReadAll()
 	pos := mx.View.Pos
 	if pos < 0 || pos > len(src) {
diff --git a/src/margo.sh/golang/syntaxcheck.go b/src/margo.sh/golang/syntaxcheck.go
index 68a014fa..901c2149 100644
--- a/src/margo.sh/golang/syntaxcheck.go
+++ b/src/margo.sh/golang/syntaxcheck.go
@@ -3,27 +3,49 @@ package golang
 import (
 	"go/scanner"
 	"margo.sh/mg"
+	"margo.sh/mgutil"
 )
 
-type SyntaxCheck struct{ mg.ReducerType }
+type SyntaxCheck struct {
+	mg.ReducerType
+
+	q *mgutil.ChanQ
+}
+
+func (sc *SyntaxCheck) ReducerCond(mx *mg.Ctx) bool {
+	return mx.LangIs(mg.Go)
+}
+
+func (sc *SyntaxCheck) ReducerMount(mx *mg.Ctx) {
+	sc.q = mgutil.NewChanQ(1)
+	go sc.checker()
+}
+
+func (sc *SyntaxCheck) ReducerUnmount(mx *mg.Ctx) {
+	sc.q.Close()
+}
 
 func (sc *SyntaxCheck) Reduce(mx *mg.Ctx) *mg.State {
-	if mx.LangIs("go") && mx.ActionIs(mg.ViewActivated{}, mg.ViewModified{}, mg.ViewSaved{}) {
-		go sc.check(mx)
+	switch mx.Action.(type) {
+	case mg.ViewActivated, mg.ViewModified, mg.ViewSaved:
+		sc.q.Put(mx)
 	}
 	return mx.State
 }
 
+func (sc *SyntaxCheck) checker() {
+	for v := range sc.q.C() {
+		sc.check(v.(*mg.Ctx))
+	}
+}
+
 func (sc *SyntaxCheck) check(mx *mg.Ctx) {
 	src, _ := mx.View.ReadAll()
 	pf := ParseFile(mx.Store, mx.View.Filename(), src)
-	type Key struct{}
+	type iKey struct{}
 	mx.Store.Dispatch(mg.StoreIssues{
-		Key: mg.IssueKey{
-			Key:  Key{},
-			Name: mx.View.Name,
-		},
-		Issues: sc.errsToIssues(mx.View, pf.ErrorList),
+		IssueKey: mg.IssueKey{Key: iKey{}},
+		Issues:   sc.errsToIssues(mx.View, pf.ErrorList),
 	})
 }
 
@@ -36,7 +58,7 @@ func (sc *SyntaxCheck) errsToIssues(v *mg.View, el scanner.ErrorList) mg.IssueSe
 			Row:     e.Pos.Line - 1,
 			Col:     e.Pos.Column - 1,
 			Message: e.Msg,
-			Tag:     mg.IssueError,
+			Tag:     mg.Error,
 			Label:   "Go/SyntaxCheck",
 		}
 	}
diff --git a/src/margo.sh/js/jsonfmt.go b/src/margo.sh/js/jsonfmt.go
index 680bdde8..fbd46023 100644
--- a/src/margo.sh/js/jsonfmt.go
+++ b/src/margo.sh/js/jsonfmt.go
@@ -12,14 +12,11 @@ type JsonFmt struct {
 	Indent string
 }
 
-func (j JsonFmt) Reduce(mx *mg.Ctx) *mg.State {
-	if !mx.View.LangIs("json") {
-		return mx.State
-	}
-	if _, ok := mx.Action.(mg.ViewFmt); !ok {
-		return mx.State
-	}
+func (j JsonFmt) ReducerCond(mx *mg.Ctx) bool {
+	return mx.ActionIs(mg.ViewFmt{}) && mx.LangIs(mg.JSON)
+}
 
+func (j JsonFmt) Reduce(mx *mg.Ctx) *mg.State {
 	fn := mx.View.Filename()
 	r, err := mx.View.Open()
 	if err != nil {
@@ -36,5 +33,5 @@ func (j JsonFmt) Reduce(mx *mg.Ctx) *mg.State {
 	if err != nil {
 		return mx.AddErrorf("failed to marshal json %s: %s\n", fn, err)
 	}
-	return mx.SetSrc(src)
+	return mx.SetViewSrc(src)
 }
diff --git a/src/margo.sh/mg/action.go b/src/margo.sh/mg/action.go
index ada21e39..3444a753 100644
--- a/src/margo.sh/mg/action.go
+++ b/src/margo.sh/mg/action.go
@@ -52,9 +52,9 @@ var (
 	}
 )
 
-// Started is dispatched to indicate the start of IPC communication.
+// initAction is dispatched to indicate the start of IPC communication.
 // It's the first action that is dispatched.
-type Started struct{ ActionType }
+type initAction struct{ ActionType }
 
 type actionCreator func(codec.Handle, agentReqAction) (Action, error)
 
@@ -62,9 +62,9 @@ type actionType struct{ ActionType }
 
 type ActionType struct{}
 
-func (act ActionType) actionType() actionType { return actionType{} }
+func (ActionType) actionType() actionType { return actionType{} }
 
-func (act ActionType) ActionLabel() string { return "" }
+func (ActionType) ActionLabel() string { return "" }
 
 type Action interface {
 	actionType() actionType
@@ -72,6 +72,19 @@ type Action interface {
 	ActionLabel() string
 }
 
+type Activate struct {
+	ActionType
+
+	Path string
+	Name string
+	Row  int
+	Col  int
+}
+
+func (a Activate) clientAction() clientActionType {
+	return clientActionType{Name: "Activate", Data: a}
+}
+
 var Render Action = nil
 
 type QueryCompletions struct{ ActionType }
@@ -81,9 +94,17 @@ type QueryIssues struct{ ActionType }
 // Restart is the action dispatched to initiate a graceful restart of the agent
 type Restart struct{ ActionType }
 
+func (r Restart) clientAction() clientActionType {
+	return clientActionType{Name: "Restart"}
+}
+
 // Shutdown is the action dispatched to initiate a graceful shutdown of the agent
 type Shutdown struct{ ActionType }
 
+func (s Shutdown) clientAction() clientActionType {
+	return clientActionType{Name: "Shutdown"}
+}
+
 type ViewActivated struct{ ActionType }
 
 type ViewModified struct{ ActionType }
diff --git a/src/margo.sh/mg/agent.go b/src/margo.sh/mg/agent.go
index 27f07301..218e7c26 100644
--- a/src/margo.sh/mg/agent.go
+++ b/src/margo.sh/mg/agent.go
@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"github.com/ugorji/go/codec"
 	"io"
+	"margo.sh/mgpf"
 	"margo.sh/mgutil"
-	"margo.sh/misc/pf"
 	"os"
 	"sort"
 	"strings"
@@ -85,13 +85,13 @@ type agentReq struct {
 	Actions []agentReqAction
 	Props   clientProps
 	Sent    string
-	Profile *pf.Profile
+	Profile *mgpf.Profile
 }
 
 func newAgentReq(kvs KVStore) *agentReq {
 	return &agentReq{
 		Props:   makeClientProps(kvs),
-		Profile: pf.NewProfile(""),
+		Profile: mgpf.NewProfile(""),
 	}
 }
 
diff --git a/src/margo.sh/mg/builtins.go b/src/margo.sh/mg/builtins.go
index f7870d86..05144463 100644
--- a/src/margo.sh/mg/builtins.go
+++ b/src/margo.sh/mg/builtins.go
@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	Builtins = builtins{}
+	Builtins = &builtins{}
 )
 
 type BultinCmdList []BultinCmd
diff --git a/src/margo.sh/mg/client-actions.go b/src/margo.sh/mg/client-actions.go
index 591a54ff..62262c9b 100644
--- a/src/margo.sh/mg/client-actions.go
+++ b/src/margo.sh/mg/client-actions.go
@@ -1,8 +1,10 @@
 package mg
 
 var (
-	clientRestart  = clientActionType{Name: "restart"}
-	clientShutdown = clientActionType{Name: "shutdown"}
+	_ clientAction = CmdOutput{}
+	_ clientAction = Activate{}
+	_ clientAction = Restart{}
+	_ clientAction = Shutdown{}
 )
 
 type clientAction interface {
@@ -14,6 +16,17 @@ type clientActionType struct {
 	Data interface{}
 }
 
-func (t clientActionType) clientAction() clientActionType {
-	return t
+type clientActionSupport struct{ ReducerType }
+
+func (cas *clientActionSupport) Reduce(mx *Ctx) *State {
+	if act, ok := mx.Action.(clientAction); ok {
+		switch act := act.(type) {
+		case Activate:
+			mx.Log.Printf("client action Activate(%s:%d:%d) dispatched\n", act.Path, act.Row, act.Col)
+		case Restart, Shutdown:
+			mx.Log.Printf("client action %s dispatched\n", act.clientAction().Name)
+		}
+		return mx.addClientActions(act)
+	}
+	return mx.State
 }
diff --git a/src/margo.sh/mg/cmd.go b/src/margo.sh/mg/cmd.go
index 74ed8bc6..ef35f183 100644
--- a/src/margo.sh/mg/cmd.go
+++ b/src/margo.sh/mg/cmd.go
@@ -87,7 +87,7 @@ func (w *CmdOutputWriter) Close(output ...[]byte) error {
 }
 
 func (w *CmdOutputWriter) dispatch() {
-	if w.Dispatch == nil {
+	if w.Dispatch == nil || w.Fd == "" {
 		return
 	}
 
@@ -116,14 +116,16 @@ type CmdOutput struct {
 	Close  bool
 }
 
+func (out CmdOutput) clientAction() clientActionType {
+	return clientActionType{Name: "CmdOutput", Data: out}
+}
+
 type cmdSupport struct{ ReducerType }
 
 func (cs *cmdSupport) Reduce(mx *Ctx) *State {
 	switch act := mx.Action.(type) {
 	case RunCmd:
 		return cs.runCmd(NewBultinCmdCtx(mx, act))
-	case CmdOutput:
-		return cs.cmdOutput(mx, act)
 	}
 	return mx.State
 }
@@ -135,13 +137,6 @@ func (cs *cmdSupport) runCmd(bx *BultinCmdCtx) *State {
 	return Builtins.ExecCmd(bx)
 }
 
-func (cs *cmdSupport) cmdOutput(mx *Ctx, out CmdOutput) *State {
-	return mx.State.addClientActions(clientActionType{
-		Name: "output",
-		Data: out,
-	})
-}
-
 type RunCmd struct {
 	ActionType
 
diff --git a/src/margo.sh/mg/cmd_internal_test.go b/src/margo.sh/mg/cmd_internal_test.go
index 0f9ae259..25d00a31 100644
--- a/src/margo.sh/mg/cmd_internal_test.go
+++ b/src/margo.sh/mg/cmd_internal_test.go
@@ -48,7 +48,7 @@ func TestCmdSupport_Reduce_withRunCmd(t *testing.T) {
 func TestCmdSupport_Reduce_withCmdOutput(t *testing.T) {
 	var called bool
 	fd := "CIlZ7zBWHIAL"
-	cs := &cmdSupport{}
+	cs := &clientActionSupport{}
 	ctx := NewTestingCtx(nil)
 	defer ctx.Cancel()
 
diff --git a/src/margo.sh/mg/common.go b/src/margo.sh/mg/common.go
index 1e16b8d5..a2eb1dd1 100644
--- a/src/margo.sh/mg/common.go
+++ b/src/margo.sh/mg/common.go
@@ -1,6 +1,7 @@
 package mg
 
 import (
+	"os"
 	"path/filepath"
 	"strings"
 )
@@ -55,7 +56,14 @@ func (e EnvMap) Merge(p map[string]string) EnvMap {
 }
 
 func (e EnvMap) Environ() []string {
-	l := make([]string, 0, len(e))
+	el := os.Environ()
+	l := make([]string, 0, len(e)+len(el))
+	for _, s := range el {
+		k := strings.SplitN(s, "=", 2)[0]
+		if _, exists := e[k]; !exists {
+			l = append(l, s)
+		}
+	}
 	for k, v := range e {
 		l = append(l, k+"="+v)
 	}
diff --git a/src/margo.sh/mg/ctx.go b/src/margo.sh/mg/ctx.go
new file mode 100644
index 00000000..60a1c644
--- /dev/null
+++ b/src/margo.sh/mg/ctx.go
@@ -0,0 +1,165 @@
+package mg
+
+import (
+	"context"
+	"github.com/ugorji/go/codec"
+	"margo.sh/mgpf"
+	"reflect"
+	"regexp"
+	"sync"
+	"time"
+)
+
+var (
+	_ context.Context = (*Ctx)(nil)
+)
+
+// Ctx holds data about the current request/reduction.
+//
+// To create a new instance, use Store.NewCtx()
+//
+// NOTE: Ctx should be treated as readonly and users should not assign to any
+// of its fields or the fields of any of its members.
+// If a field must be updated, you should use one of the methods like Copy
+//
+// Unless a field is tagged with `mg.Nillable:"true"`, it will never be nil
+// and if updated, no field should be set to nil
+type Ctx struct {
+	// State is the current state of the world
+	*State
+
+	// Action is the action that was dispatched.
+	// It's a hint telling reducers about some action that happened,
+	// e.g. that the view is about to be saved or that it was changed.
+	Action Action `mg.Nillable:"true"`
+
+	// Store is the global store
+	Store *Store
+
+	// Log is the global logger
+	Log *Logger
+
+	Cookie string
+
+	Profile *mgpf.Profile
+
+	doneC      chan struct{}
+	cancelOnce *sync.Once
+	handle     codec.Handle
+}
+
+// newCtx creates a new Ctx
+// if st is nil, the state will be set to the equivalent of Store.state.new()
+// if p is nil a new Profile will be created with cookie as its name
+func newCtx(sto *Store, st *State, act Action, cookie string, p *mgpf.Profile) *Ctx {
+	if st == nil {
+		st = sto.state.new()
+	}
+	if p == nil {
+		p = mgpf.NewProfile(cookie)
+	}
+	return &Ctx{
+		State:      st,
+		Action:     act,
+		Store:      sto,
+		Log:        sto.ag.Log,
+		Cookie:     cookie,
+		Profile:    p,
+		doneC:      make(chan struct{}),
+		cancelOnce: &sync.Once{},
+		handle:     sto.ag.handle,
+	}
+}
+
+// Deadline implements context.Context.Deadline
+func (*Ctx) Deadline() (time.Time, bool) {
+	return time.Time{}, false
+}
+
+// Cancel cancels the ctx by arranging for the Ctx.Done() channel to be closed.
+// Canceling this Ctx cancels all other Ctxs Copy()ed from it.
+func (mx *Ctx) Cancel() {
+	mx.cancelOnce.Do(func() {
+		close(mx.doneC)
+	})
+}
+
+// Done implements context.Context.Done()
+func (mx *Ctx) Done() <-chan struct{} {
+	return mx.doneC
+}
+
+// Err implements context.Context.Err()
+func (mx *Ctx) Err() error {
+	select {
+	case <-mx.Done():
+		return context.Canceled
+	default:
+		return nil
+	}
+}
+
+// Value implements context.Context.Value() but always returns nil
+func (mx *Ctx) Value(k interface{}) interface{} {
+	return nil
+}
+
+// AgentName returns the name of the agent if set
+// if set, it's usually the agent name as used in the command `margo.sh [run...] $agent`
+func (mx *Ctx) AgentName() string {
+	return mx.Store.ag.Name
+}
+
+// ActionIs returns true if Ctx.Action is the same type as any of those in actions
+// for convenience, it returns true if actionsis empty
+func (mx *Ctx) ActionIs(actions ...Action) bool {
+	if len(actions) == 0 {
+		return true
+	}
+	typ := reflect.TypeOf(mx.Action)
+	for _, act := range actions {
+		if reflect.TypeOf(act) == typ {
+			return true
+		}
+	}
+	return false
+}
+
+// LangIs is equivalent to View.LangIs(langs...)
+func (mx *Ctx) LangIs(langs ...Lang) bool {
+	return mx.View.LangIs(langs...)
+}
+
+// CommonPatterns is equivalent to View.CommonPatterns()
+func (mx *Ctx) CommonPatterns() []*regexp.Regexp {
+	return mx.View.CommonPatterns()
+}
+
+// Copy create a shallow copy of the Ctx.
+//
+// It applies the functions in updaters to the new object.
+// Updating the new Ctx via these functions is preferred to assigning to the new object
+func (mx *Ctx) Copy(updaters ...func(*Ctx)) *Ctx {
+	x := *mx
+	mx = &x
+
+	for _, f := range updaters {
+		f(mx)
+	}
+	return mx
+}
+
+func (mx *Ctx) SetState(st *State) *Ctx {
+	mx = mx.Copy()
+	mx.State = st
+	return mx
+}
+
+func (mx *Ctx) SetView(v *View) *Ctx {
+	return mx.SetState(mx.State.SetView(v))
+}
+
+// Begin is a short-hand for Ctx.Store.Begin
+func (mx *Ctx) Begin(t Task) *TaskTicket {
+	return mx.Store.Begin(t)
+}
diff --git a/src/margo.sh/mg/issue.go b/src/margo.sh/mg/issue.go
index 19ba39b1..e02990cd 100644
--- a/src/margo.sh/mg/issue.go
+++ b/src/margo.sh/mg/issue.go
@@ -12,17 +12,53 @@ import (
 )
 
 var (
-	CommonPatterns = []*regexp.Regexp{
-		regexp.MustCompile(`^\s*(?P<path>.+?\.\w+):(?P<line>\d+:)(?P<column>\d+:?)?(?P<message>.+)$`),
-		regexp.MustCompile(`^\s*(?P<path>.+?\.\w+)\((?P<line>\d+)(?:,(?P<column>\d+))?\):(?P<message>.+)$`),
+	commonPatterns = struct {
+		sync.RWMutex
+		m map[Lang][]*regexp.Regexp
+	}{
+		m: map[Lang][]*regexp.Regexp{
+			"": {
+				regexp.MustCompile(`^\s*(?P<path>.+?\.\w+):(?P<line>\d+:)(?P<column>\d+:?)?(?P<message>.+)$`),
+				regexp.MustCompile(`^\s*(?P<path>.+?\.\w+)\((?P<line>\d+)(?:,(?P<column>\d+))?\):(?P<message>.+)$`),
+			},
+		},
 	}
 )
 
+type commonPattern struct {
+	Lang     Lang
+	Patterns []*regexp.Regexp
+}
+
+func AddCommonPatterns(lang Lang, l ...*regexp.Regexp) {
+	p := &commonPatterns
+	p.Lock()
+	defer p.Unlock()
+
+	for _, k := range []Lang{"", lang} {
+		p.m[k] = append(p.m[k], l...)
+	}
+}
+
+func CommonPatterns(langs ...Lang) []*regexp.Regexp {
+	p := &commonPatterns
+	p.RLock()
+	defer p.RUnlock()
+
+	l := p.m[""]
+	l = l[:len(l):len(l)]
+	for _, lang := range langs {
+		l = append(l, p.m[lang]...)
+	}
+	return l
+}
+
 type IssueTag string
 
 const (
-	IssueError   = IssueTag("error")
-	IssueWarning = IssueTag("warning")
+	Error   = IssueTag("error")
+	Warning = IssueTag("warning")
+	Notice  = IssueTag("notice")
 )
 
 type Issue struct {
@@ -36,6 +72,13 @@ type Issue struct {
 	Message string
 }
 
+func (isu Issue) finalize() Issue {
+	if isu.Tag == "" {
+		isu.Tag = Error
+	}
+	return isu
+}
+
 func (isu Issue) Equal(p Issue) bool {
 	return isu.SameFile(p) && isu.Row == p.Row && isu.Message == p.Message
 }
@@ -79,6 +122,7 @@ func (s IssueSet) Add(l ...Issue) IssueSet {
 	res := make(IssueSet, 0, len(s)+len(l))
 	for _, lst := range []IssueSet{s, IssueSet(l)} {
 		for _, p := range lst {
+			p = p.finalize()
 			if !res.Has(p) {
 				res = append(res, p)
 			}
@@ -120,7 +164,7 @@ func (is IssueSet) AllInView(v *View) IssueSet {
 type StoreIssues struct {
 	ActionType
 
-	Key    IssueKey
+	IssueKey
 	Issues IssueSet
 }
 
@@ -144,9 +188,9 @@ func (iks *issueKeySupport) Reduce(mx *Ctx) *State {
 	switch act := mx.Action.(type) {
 	case StoreIssues:
 		if len(act.Issues) == 0 {
-			delete(iks.issues, act.Key)
+			delete(iks.issues, act.IssueKey)
 		} else {
-			iks.issues[act.Key] = act.Issues
+			iks.issues[act.IssueKey] = act.Issues
 		}
 	}
 
@@ -156,6 +200,12 @@ func (iks *issueKeySupport) Reduce(mx *Ctx) *State {
 	path := norm(mx.View.Path)
 	dir := norm(mx.View.Dir())
 	match := func(k IssueKey) bool {
+		// no restrictions were set
+		k.Key = nil
+		if k == (IssueKey{}) {
+			return true
+		}
+
 		if path != "" && path == k.Path {
 			return true
 		}
@@ -184,23 +234,51 @@ func (_ issueStatusSupport) Reduce(mx *Ctx) *State {
 		return mx.State
 	}
 
-	status := make([]string, 0, 3)
-	status = append(status, "placeholder")
-	inview := 0
+	type Cfg struct {
+		title  string
+		inView int
+		total  int
+	}
+	cfgs := map[IssueTag]*Cfg{
+		Error:   {title: "Errors"},
+		Warning: {title: "Warning"},
+		Notice:  {title: "Notices"},
+	}
+
+	msg := ""
 	for _, isu := range mx.Issues {
+		cfg, ok := cfgs[isu.Tag]
+		if !ok {
+			continue
+		}
+
+		cfg.total++
 		if !isu.InView(mx.View) {
 			continue
 		}
-		inview++
-		if len(status) > 1 || isu.Message == "" || isu.Row != mx.View.Row {
+		cfg.inView++
+
+		if len(msg) > 1 || isu.Message == "" || isu.Row != mx.View.Row {
 			continue
 		}
-		if isu.Label != "" {
-			status = append(status, isu.Label)
+		if isu.Label == "" {
+			msg = isu.Message
+		} else {
+			msg = isu.Label + ": " + isu.Message
 		}
-		status = append(status, isu.Message)
 	}
-	status[0] = fmt.Sprintf("Issues (%d/%d)", inview, len(mx.Issues))
+
+	status := make([]string, 0, len(cfgs)+1)
+	for _, k := range []IssueTag{Error, Warning, Notice} {
+		cfg := cfgs[k]
+		if cfg.total == 0 {
+			continue
+		}
+		status = append(status, fmt.Sprintf("%d/%d %s", cfg.inView, cfg.total, cfg.title))
+	}
+	if msg != "" {
+		status = append(status, msg)
+	}
 	return mx.AddStatus(status...)
 }
 
@@ -356,14 +434,14 @@ func (w *IssueWriter) matchOne(p *regexp.Regexp, s []byte) *Issue {
 			if lbl != "" {
 				isu.Label = lbl
 			}
-		case "error", "warning":
+		case "error", "warning", "notice":
 			isu.Tag = IssueTag(k)
 			isu.Message = str(v)
 		case "message":
 			isu.Message = str(v)
 		case "tag":
 			tag := IssueTag(str(v))
-			if tag == IssueWarning || tag == IssueError {
+			if tag == Warning || tag == Error || tag == Notice {
 				isu.Tag = tag
 			}
 		}
diff --git a/src/margo.sh/mg/issue_test.go b/src/margo.sh/mg/issue_test.go
index 5e703fb8..56d74e2e 100644
--- a/src/margo.sh/mg/issue_test.go
+++ b/src/margo.sh/mg/issue_test.go
@@ -6,11 +6,11 @@ import (
 )
 
 func TestIssueWriter(t *testing.T) {
-	base := Issue{Label: "lbl", Tag: IssueWarning}
+	base := Issue{Label: "lbl", Tag: Warning}
 	w := &IssueWriter{
 		Dir:      "/abc",
 		Base:     base,
-		Patterns: CommonPatterns,
+		Patterns: CommonPatterns(),
 	}
 	fmt.Fprintln(w, "abc.go:555:666: hello world")
 	fmt.Fprintln(w, "no match")
diff --git a/src/margo.sh/mg/langs.go b/src/margo.sh/mg/langs.go
new file mode 100644
index 00000000..e789ce0a
--- /dev/null
+++ b/src/margo.sh/mg/langs.go
@@ -0,0 +1,50 @@
+package mg
+
+var (
+	ActionScript Lang = "actionscript"
+	AppleScript  Lang = "applescript"
+	ASP          Lang = "asp"
+	C            Lang = "c"
+	Clojure      Lang = "clojure"
+	CPP          Lang = "c++"
+	CSharp       Lang = "cs"
+	CSS          Lang = "css"
+	D            Lang = "d"
+	Diff         Lang = "diff"
+	DosBatch     Lang = "dosbatch"
+	Dot          Lang = "dot"
+	Empty        Lang = "empty"
+	Erl          Lang = "erl"
+	Erlang       Lang = "erlang"
+	Go           Lang = "go"
+	Groovy       Lang = "groovy"
+	Haskell      Lang = "haskell"
+	Java         Lang = "java"
+	JS           Lang = "js"
+	JSON         Lang = "json"
+	LaTeX        Lang = "latex"
+	LISP         Lang = "lisp"
+	Lua          Lang = "lua"
+	Makefile     Lang = "makefile"
+	Matlab       Lang = "matlab"
+	ObjC         Lang = "objc"
+	Ocaml        Lang = "ocaml"
+	Octave       Lang = "octave"
+	Pascal       Lang = "pascal"
+	Perl         Lang = "perl"
+	PHP          Lang = "php"
+	Plist        Lang = "plist"
+	Python       Lang = "python"
+	R            Lang = "r"
+	Ruby         Lang = "ruby"
+	Rust         Lang = "rust"
+	Scala        Lang = "scala"
+	ShellScript  Lang = "shell"
+	SQL          Lang = "sql"
+	Tcl          Lang = "tcl"
+	Yaml         Lang = "yaml"
+)
+
+// Lang is the lower-case name of a language i.e. "go", not "Go"
+// where possible, the predefined instances in should be used
+type Lang string
diff --git a/src/margo.sh/mg/lint.go b/src/margo.sh/mg/lint.go
new file mode 100644
index 00000000..e3d4d5b4
--- /dev/null
+++ b/src/margo.sh/mg/lint.go
@@ -0,0 +1,129 @@
+package mg
+
+import (
+	"margo.sh/mgutil"
+	"os"
+	"os/exec"
+)
+
+type Linter struct {
+	ReducerType
+
+	Langs   []Lang
+	Actions []Action
+
+	Name string
+	Args []string
+
+	IssueKey func(*Ctx) IssueKey
+	Tag      IssueTag
+	Label    string
+	TempDir  []string
+
+	q *mgutil.ChanQ
+}
+
+func (lt *Linter) ReducerCond(mx *Ctx) bool {
+	return mx.LangIs(lt.Langs...) &&
+		(mx.ActionIs(lt.userActs()...) || mx.ActionIs(lt.auxActs()...))
+}
+
+func (lt *Linter) userActs() []Action {
+	if acts := lt.Actions; len(acts) != 0 {
+		return acts
+	}
+	return []Action{ViewSaved{}}
+}
+
+func (lt *Linter) auxActs() []Action {
+	return []Action{QueryUserCmds{}}
+}
+
+func (lt *Linter) Reduce(mx *Ctx) *State {
+	// keep non-default actions in sync with auxActs()
+	switch mx.Action.(type) {
+	case QueryUserCmds:
+		return lt.userCmds(mx)
+	default:
+		lt.q.Put(mx)
+		return mx.State
+	}
+}
+
+func (lt *Linter) ReducerMount(mx *Ctx) {
+	lt.q = mgutil.NewChanQ(1)
+	go lt.loop()
+}
+
+func (lt *Linter) ReducerUnmount(mx *Ctx) {
+	lt.q.Close()
+}
+
+func (lt *Linter) userCmds(mx *Ctx) *State {
+	lbl := lt.Label
+	if lbl == "" {
+		lbl = lt.Name
+	}
+	return mx.AddUserCmds(UserCmd{
+		Name:  lt.Name,
+		Args:  lt.Args,
+		Title: "Linter: " + lbl,
+	})
+}
+
+func (lt *Linter) loop() {
+	for v := range lt.q.C() {
+		lt.lint(v.(*Ctx))
+	}
+}
+
+func (lt *Linter) key(mx *Ctx) IssueKey {
+	if ik := lt.IssueKey; ik != nil {
+		return ik(mx)
+	}
+	return IssueKey{Key: lt}
+}
+
+func (lt *Linter) lint(mx *Ctx) {
+	res := StoreIssues{}
+	res.Key = lt.key(mx)
+	// make sure to clear any old issues, even if we return early
+	defer func() { mx.Store.Dispatch(res) }()
+
+	cmdStr := mgutil.QuoteCmd(lt.Name, lt.Args...)
+	if len(lt.TempDir) != 0 {
+		tmpDir, err := MkTempDir(lt.Label)
+		if err != nil {
+			mx.Log.Println("cannot create tempDir for linter `%s`:", cmdStr, err)
+			return
+		}
+		defer os.RemoveAll(tmpDir)
+
+		m := mx.Env
+		for _, k := range lt.TempDir {
+			m = m.Add(k, tmpDir)
+		}
+		mx = mx.SetState(mx.State.SetEnv(m))
+	}
+
+	dir := mx.View.Dir()
+	iw := &IssueWriter{
+		Dir:      dir,
+		Patterns: mx.CommonPatterns(),
+		Base:     Issue{Label: lt.Label, Tag: lt.Tag},
+	}
+
+	cmd := exec.Command(lt.Name, lt.Args...)
+	cmd.Stdout = iw
+	cmd.Stderr = iw
+	cmd.Env = mx.Env.Environ()
+	cmd.Dir = dir
+
+	if err := cmd.Start(); err != nil {
+		mx.Log.Printf("cannot start linter `%s`: %s", cmdStr, err)
+		return
+	}
+	cmd.Wait()
+	iw.Close()
+	res.Issues = iw.Issues()
+}
diff --git a/src/margo.sh/mg/reducers.go b/src/margo.sh/mg/reducers.go
index 85f02c85..a72cda85 100644
--- a/src/margo.sh/mg/reducers.go
+++ b/src/margo.sh/mg/reducers.go
@@ -1,16 +1,12 @@
 package mg
 
 import (
-	"go/build"
-	"os/exec"
-	"path/filepath"
 	"reflect"
 	"runtime"
-	"strings"
 )
 
 var (
-	_ Reducer = reducerType{}
+	_ Reducer = &reducerType{}
 
 	defaultReducers = struct {
 		before, use, after []Reducer
@@ -20,17 +16,46 @@ var (
 			Builtins,
 		},
 		after: []Reducer{
-			issueStatusSupport{},
+			&issueStatusSupport{},
 			&cmdSupport{},
 			&restartSupport{},
+			&clientActionSupport{},
 		},
 	}
 )
 
 // A Reducer is the main method of state transitions in margo.
 //
-// ReducerType can be embedded into struct types to implement all optional methods,
-// i.e. the only required method is Reduce()
+// The methods are called in the order listed below:
+//
+// * ReducerInit
+//   this is called during the first action (initAction{} FKA Started{})
+//
+// * ReducerConfig
+//   this is called on each reduction
+//
+// * ReducerCond
+//   this is called on each reduction
+//   if it returns false, no other method is called
+//
+// * ReducerMount
+//   this is called once, after the first time ReducerCond returns true
+//
+// * Reduce
+//   this is called on each reduction until the agent begins shutting down
+//
+// * ReducerUnmount
+//   this is called once when the agent is shutting down,
+//   iif ReducerMount was called
+//
+// For simplicity and the ability to extend the interface in the future,
+// users should embed `ReducerType` in their types to complete the interface.
+//
+// For convenience, it also implements all optional (non-Reduce()) methods.
+//
+// The prefixes `Reduce` and `Reducer` are reserved, and should not be used.
+// To work-around a frequent typo, the `ReducerXXX` methods will have an alias
+// `ReduceXXX` designed to fail the build if the name is used.
 //
 // NewReducer() can be used to convert a function to a reducer.
 //
@@ -64,16 +89,22 @@ type Reducer interface {
 	// in pf.Profile and other display scenarios
 	ReducerLabel() string
 
+	// ReducerInit is called for the first reduction
+	// * it's only called once and can be used to initialise reducer state
+	//   e.g. for initialising an embedded type
+	// * it's called before ReducerConfig()
+	ReducerInit(*Ctx)
+
 	// ReducerConfig is called on each reduction, before ReducerCond
 	// if it returns a new EditorConfig, it's equivalent to State.SetConfig()
 	// but is always run before ReducerCond() so is usefull for making sure
 	// configuration changes are always applied, even if Reduce() isn't called
 	ReducerConfig(*Ctx) EditorConfig
 
-	// ReducerCond is called before Reduce is called
-	// if it returns false, Reduce is not called
+	// ReducerCond is called before Reduce and ReducerMount is called
+	// if it returns false, no other methods are called
 	//
-	// It can be used a pre-condition in combination with Reducer(Un)Mount
+	// It can be used as a pre-condition in combination with Reducer(Un)Mount
 	ReducerCond(*Ctx) bool
 
 	// ReducerMount is called once, after the first time that ReducerCond returns true
@@ -87,37 +118,57 @@ type Reducer interface {
 	// After this method is called, Reduce will never be called again
 	ReducerUnmount(*Ctx)
 
-	reducerType() reducerType
+	reducerType() *ReducerType
+
+	reducerPrefixTypo
 }
 
+// reducerPrefixTypo aims to fail the build when you define a method like
+// ReduceCond()... which is a typo about 100% of the time.
+// it should be kept in sync with Reducer
+type reducerPrefixTypo interface {
+	ReduceLabel(useReducerForThePrefixNotReduce)
+	ReduceInit(useReducerForThePrefixNotReduce)
+	ReduceConfig(useReducerForThePrefixNotReduce)
+	ReduceCond(useReducerForThePrefixNotReduce)
+	ReduceMount(useReducerForThePrefixNotReduce)
+	ReduceUnmount(useReducerForThePrefixNotReduce)
+}
+
+type useReducerForThePrefixNotReduce struct{}
+
 type reducerType struct{ ReducerType }
 
-func (rt reducerType) Reduce(mx *Ctx) *State { return mx.State }
+func (rt *reducerType) Reduce(mx *Ctx) *State { return mx.State }
 
 // ReducerType implements all optional methods of a reducer
-type ReducerType struct{}
+type ReducerType struct {
+	reducerPrefixTypo
+}
 
-func (rt ReducerType) reducerType() reducerType { return reducerType{} }
+func (rt *ReducerType) reducerType() *ReducerType { return rt }
 
 // ReducerLabel implements Reducer.ReducerLabel
-func (rt ReducerType) ReducerLabel() string { return "" }
+func (rt *ReducerType) ReducerLabel() string { return "" }
+
+// ReducerInit implements Reducer.ReducerInit
+func (rt *ReducerType) ReducerInit(*Ctx) {}
 
 // ReducerCond implements Reducer.ReducerCond
-func (rt ReducerType) ReducerCond(*Ctx) bool { return true }
+func (rt *ReducerType) ReducerCond(*Ctx) bool { return true }
 
 // ReducerConfig implements Reducer.ReducerConfig
-func (rt ReducerType) ReducerConfig(*Ctx) EditorConfig { return nil }
+func (rt *ReducerType) ReducerConfig(*Ctx) EditorConfig { return nil }
 
 // ReducerMount implements Reducer.ReducerMount
-func (rt ReducerType) ReducerMount(*Ctx) {}
+func (rt *ReducerType) ReducerMount(*Ctx) {}
 
 // ReducerUnmount implements Reducer.ReducerUnmount
-func (rt ReducerType) ReducerUnmount(*Ctx) {}
+func (rt *ReducerType) ReducerUnmount(*Ctx) {}
 
 // reducerList is a slice of reducers
 type reducerList []Reducer
 
-// callReducers calls the reducers in the slice in order.
 func (rl reducerList) callReducers(mx *Ctx) *Ctx {
 	for _, r := range rl {
 		mx = rl.callReducer(mx, r)
@@ -127,19 +178,35 @@ func (rl reducerList) callReducers(mx *Ctx) *Ctx {
 
 func (rl reducerList) callReducer(mx *Ctx, r Reducer) *Ctx {
 	defer mx.Profile.Push(ReducerLabel(r)).Pop()
+
+	rl.crInit(mx, r)
+
 	if c := rl.crConfig(mx, r); c != nil {
 		mx = mx.SetState(mx.State.SetConfig(c))
 	}
+
 	if !rl.crCond(mx, r) {
 		return mx
 	}
+
 	rl.crMount(mx, r)
+
 	if rl.crUnmount(mx, r) {
 		return mx
 	}
+
 	return rl.crReduce(mx, r)
 }
 
+func (rl reducerList) crInit(mx *Ctx, r Reducer) {
+	if _, ok := mx.Action.(initAction); !ok {
+		return
+	}
+
+	defer mx.Profile.Push("ReducerInit").Pop()
+	r.ReducerInit(mx)
+}
+
 func (rl reducerList) crConfig(mx *Ctx, r Reducer) EditorConfig {
 	defer mx.Profile.Push("ReducerConfig").Pop()
 	return r.ReducerConfig(mx)
@@ -151,21 +218,23 @@ func (rl reducerList) crCond(mx *Ctx, r Reducer) bool {
 }
 
 func (rl reducerList) crMount(mx *Ctx, r Reducer) {
-	if mx.Store.mounted[r] {
+	k := r.reducerType()
+	if mx.Store.mounted[k] {
 		return
 	}
 
 	defer mx.Profile.Push("Mount").Pop()
-	mx.Store.mounted[r] = true
+	mx.Store.mounted[k] = true
 	r.ReducerMount(mx)
 }
 
 func (rl reducerList) crUnmount(mx *Ctx, r Reducer) bool {
-	if !mx.ActionIs(unmount{}) || !mx.Store.mounted[r] {
+	k := r.reducerType()
+	if !mx.ActionIs(unmount{}) || !mx.Store.mounted[k] {
 		return false
 	}
 	defer mx.Profile.Push("Unmount").Pop()
-	delete(mx.Store.mounted, r)
+	delete(mx.Store.mounted, k)
 	r.ReducerUnmount(mx)
 	return true
 }
@@ -226,87 +295,3 @@ func ReducerLabel(r Reducer) string {
 	}
 	return "mg.Reducer"
 }
-
-type rsBuildRes struct {
-	ActionType
-	issues IssueSet
-}
-
-type restartSupport struct {
-	ReducerType
-	issues IssueSet
-}
-
-func (r *restartSupport) Reduce(mx *Ctx) *State {
-	st := mx.State
-	switch act := mx.Action.(type) {
-	case ViewSaved:
-		r.tryPrepRestart(mx)
-	case Restart:
-		mx.Log.Printf("%T action dispatched\n", mx.Action)
-		st = mx.addClientActions(clientRestart)
-	case Shutdown:
-		mx.Log.Printf("%T action dispatched\n", mx.Action)
-		st = mx.addClientActions(clientShutdown)
-	case rsBuildRes:
-		r.issues = act.issues
-	}
-	return st.AddIssues(r.issues...)
-}
-
-func (r *restartSupport) tryPrepRestart(mx *Ctx) {
-	v := mx.View
-	hasSfx := strings.HasSuffix
-	if !hasSfx(v.Path, ".go") || hasSfx(v.Path, "_test.go") {
-		return
-	}
-
-	dir := filepath.ToSlash(mx.View.Dir())
-	if !filepath.IsAbs(dir) {
-		return
-	}
-
-	// if we use build..ImportPath, it will be wrong if we work on the code outside the GS GOPATH
-	imp := ""
-	if i := strings.LastIndex(dir, "/src/"); i >= 0 {
-		imp = dir[i+5:]
-	}
-	if imp != "margo" && !strings.HasPrefix(imp+"/", "margo.sh/") {
-		return
-	}
-
-	go r.prepRestart(mx, dir)
-}
-
-func (r *restartSupport) prepRestart(mx *Ctx, dir string) {
-
-	pkg, _ := build.Default.ImportDir(dir, 0)
-	if pkg == nil || pkg.Name == "" {
-		return
-	}
-
-	defer mx.Begin(Task{Title: "prepping margo restart"}).Done()
-
-	cmd := exec.Command("margo.sh", "build", mx.AgentName())
-	cmd.Dir = mx.View.Dir()
-	cmd.Env = mx.Env.Environ()
-	out, err := cmd.CombinedOutput()
-
-	iw := &IssueWriter{
-		Dir:      mx.View.Dir(),
-		Patterns: CommonPatterns,
-		Base:     Issue{Label: "Mg/RestartSupport"},
-	}
-	iw.Write(out)
-	iw.Flush()
-	res := rsBuildRes{issues: iw.Issues()}
-
-	msg := "telling margo to restart after " + mx.View.Filename() + " was saved"
-	if err == nil && len(res.issues) == 0 {
-		mx.Log.Println(msg)
-		mx.Store.Dispatch(Restart{})
-	} else {
-		mx.Log.Printf("not %s: `margo.sh build %s` failed: error: %v\n%s\n", msg, mx.AgentName(), err, out)
-		mx.Store.Dispatch(res)
-	}
-}
diff --git a/src/margo.sh/mg/restart.go b/src/margo.sh/mg/restart.go
new file mode 100644
index 00000000..4383ada0
--- /dev/null
+++ b/src/margo.sh/mg/restart.go
@@ -0,0 +1,133 @@
+package mg
+
+import (
+	"go/build"
+	"margo.sh/mgutil"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+var (
+	// we need to use the env that we started with, not the user's env
+	buildCtx = build.Default
+)
+
+type rsIssues struct {
+	ActionType
+	issues IssueSet
+}
+
+type restartSupport struct {
+	ReducerType
+	q      *mgutil.ChanQ
+	issues IssueSet
+}
+
+func (rs *restartSupport) ReducerLabel() string {
+	return "Mg/Restart"
+}
+
+func (rs *restartSupport) ReducerInit(mx *Ctx) {
+	go rs.onInit(mx)
+}
+
+func (rs *restartSupport) ReducerCond(mx *Ctx) bool {
+	if len(rs.issues) != 0 || mx.ActionIs(rsIssues{}) {
+		return true
+	}
+	if mx.LangIs(Go) && mx.ActionIs(ViewSaved{}) {
+		return true
+	}
+	return false
+}
+
+func (rs *restartSupport) ReducerMount(mx *Ctx) {
+	rs.q = mgutil.NewChanQ(1)
+	go rs.loop()
+}
+
+func (rs *restartSupport) ReducerUnmount(mx *Ctx) {
+	rs.q.Close()
+}
+
+func (rs *restartSupport) Reduce(mx *Ctx) *State {
+	switch act := mx.Action.(type) {
+	case rsIssues:
+		rs.issues = act.issues
+	case ViewSaved:
+		rs.q.Put(mx)
+	}
+	return mx.State.AddIssues(rs.issues...)
+}
+
+func (rs *restartSupport) loop() {
+	for v := range rs.q.C() {
+		rs.onSave(v.(*Ctx))
+	}
+}
+
+func (rs *restartSupport) mgPkg(mx *Ctx) *build.Package {
+	v := mx.View
+	if !strings.HasSuffix(v.Path, ".go") {
+		return nil
+	}
+
+	pkg, _ := buildCtx.ImportDir(mx.View.Dir(), 0)
+	if pkg == nil || pkg.ImportPath == "" {
+		return nil
+	}
+	imp := pkg.ImportPath + "/"
+	if !strings.HasPrefix(imp, "margo/") && !strings.HasPrefix(imp, "margo.sh/") {
+		return nil
+	}
+	return pkg
+}
+
+func (rs *restartSupport) onInit(mx *Ctx) {
+	if os.Getenv("MARGO_BUILD_ERROR") == "" {
+		return
+	}
+
+	res := rsIssues{issues: rs.slowLint(mx)}
+	if len(res.issues) != 0 {
+		mx.Store.Dispatch(res)
+	}
+}
+
+func (rs *restartSupport) onSave(mx *Ctx) {
+	pkg := rs.mgPkg(mx)
+	if pkg == nil {
+		return
+	}
+
+	res := rsIssues{issues: rs.slowLint(mx)}
+	mx.Store.Dispatch(res)
+	if len(res.issues) == 0 {
+		mx.Log.Println(pkg.ImportPath, "saved with no issues, restarting")
+		mx.Store.Dispatch(Restart{})
+	}
+}
+
+func (rs *restartSupport) slowLint(mx *Ctx) IssueSet {
+	defer mx.Begin(Task{Title: "prepping margo restart"}).Done()
+
+	cmd := exec.Command("margo.sh", "build", mx.AgentName())
+	cmd.Dir = mx.View.Dir()
+	cmd.Env = mx.Env.Environ()
+	out, err := cmd.CombinedOutput()
+
+	iw := &IssueWriter{
+		Dir:      mx.View.Dir(),
+		Patterns: mx.CommonPatterns(),
+		Base:     Issue{Label: rs.ReducerLabel()},
+	}
+	iw.Write(out)
+	iw.Close()
+	issues := iw.Issues()
+
+	if err != nil {
+		mx.Log.Printf(rs.ReducerLabel()+": %s\n%s\n", err, out)
+	}
+	return issues
+}
diff --git a/src/margo.sh/mg/state.go b/src/margo.sh/mg/state.go
index 185d5ad3..1e249f38 100644
--- a/src/margo.sh/mg/state.go
+++ b/src/margo.sh/mg/state.go
@@ -1,164 +1,17 @@
 package mg
 
 import (
-	"context"
 	"fmt"
 	"github.com/ugorji/go/codec"
-	"margo.sh/misc/pf"
 	"reflect"
-	"sync"
-	"time"
 )
 
 var (
 	// ErrNoSettings is the error returned from EditorProps.Settings()
 	// when there was no settings sent from the editor
 	ErrNoSettings = fmt.Errorf("no editor settings")
-
-	_ context.Context = (*Ctx)(nil)
 )
 
-// Ctx holds data about the current request/reduction.
-//
-// To create a new instance, use Store.NewCtx()
-//
-// NOTE: Ctx should be treated as readonly and users should not assign to any
-// of its fields or the fields of any of its members.
-// If a field must be updated, you should use one of the methods like Copy
-//
-// Unless a field is tagged with `mg.Nillable:"true"`, it will never be nil
-// and if updated, no field should be set to nil
-type Ctx struct {
-	// State is the current state of the world
-	*State
-
-	// Action is the action that was dispatched.
-	// It's a hint telling reducers about some action that happened,
-	// e.g. that the view is about to be saved or that it was changed.
-	Action Action `mg.Nillable:"true"`
-
-	// Store is the global store
-	Store *Store
-
-	// Log is the global logger
-	Log *Logger
-
-	Cookie string
-
-	Profile *pf.Profile
-
-	doneC      chan struct{}
-	cancelOnce *sync.Once
-	handle     codec.Handle
-}
-
-// newCtx creates a new Ctx
-// if st is nil, the state will be set to the equivalent of Store.state.new()
-// if p is nil a new Profile will be created with cookie as its name
-func newCtx(sto *Store, st *State, act Action, cookie string, p *pf.Profile) *Ctx {
-	if st == nil {
-		st = sto.state.new()
-	}
-	if p == nil {
-		p = pf.NewProfile(cookie)
-	}
-	return &Ctx{
-		State:      st,
-		Action:     act,
-		Store:      sto,
-		Log:        sto.ag.Log,
-		Cookie:     cookie,
-		Profile:    p,
-		doneC:      make(chan struct{}),
-		cancelOnce: &sync.Once{},
-		handle:     sto.ag.handle,
-	}
-}
-
-// Deadline implements context.Context.Deadline
-func (*Ctx) Deadline() (time.Time, bool) {
-	return time.Time{}, false
-}
-
-// Cancel cancels the ctx by arranging for the Ctx.Done() channel to be closed.
-// Canceling this Ctx cancels all other Ctxs Copy()ed from it.
-func (mx *Ctx) Cancel() {
-	mx.cancelOnce.Do(func() {
-		close(mx.doneC)
-	})
-}
-
-// Done implements context.Context.Done()
-func (mx *Ctx) Done() <-chan struct{} {
-	return mx.doneC
-}
-
-// Err implements context.Context.Err()
-func (mx *Ctx) Err() error {
-	select {
-	case <-mx.Done():
-		return context.Canceled
-	default:
-		return nil
-	}
-}
-
-// Value implements context.Context.Value() but always returns nil
-func (mx *Ctx) Value(k interface{}) interface{} {
-	return nil
-}
-
-// AgentName returns the name of the agent if set
-// if set, it's usually the agent name as used in the command `margo.sh [run...] $agent`
-func (mx *Ctx) AgentName() string {
-	return mx.Store.ag.Name
-}
-
-// ActionIs returns true if the type Ctx.Action is the same type as any of those in actions
-func (mx *Ctx) ActionIs(actions ...Action) bool {
-	typ := reflect.TypeOf(mx.Action)
-	for _, act := range actions {
-		if reflect.TypeOf(act) == typ {
-			return true
-		}
-	}
-	return false
-}
-
-// LangIs is a wrapper around Ctx.View.Lang()
-func (mx *Ctx) LangIs(names ...string) bool {
-	return mx.View.LangIs(names...)
-}
-
-// Copy create a shallow copy of the Ctx.
-//
-// It applies the functions in updaters to the new object.
-// Updating the new Ctx via these functions is preferred to assigning to the new object
-func (mx *Ctx) Copy(updaters ...func(*Ctx)) *Ctx {
-	x := *mx
-	mx = &x
-
-	for _, f := range updaters {
-		f(mx)
-	}
-	return mx
-}
-
-func (mx *Ctx) SetState(st *State) *Ctx {
-	mx = mx.Copy()
-	mx.State = st
-	return mx
-}
-
-func (mx *Ctx) SetView(v *View) *Ctx {
-	return mx.SetState(mx.State.SetView(v))
-}
-
-// Begin stars a new task and returns its ticket
-func (mx *Ctx) Begin(t Task) *TaskTicket {
-	return mx.Store.Begin(t)
-}
-
 // EditorProps holds data about the text editor
 type EditorProps struct {
 	// Name is the name of the editor
@@ -192,7 +45,7 @@ type EditorConfig interface {
 	// for which actions should be dispatched.
 	//
 	// To request actions for all languages, use `"*"` (the default)
-	EnabledForLangs(langs ...string) EditorConfig
+	EnabledForLangs(langs ...Lang) EditorConfig
 }
 
 // StickyState is state that's persisted from one reduction to the next.
@@ -343,15 +196,20 @@ func (st *State) SetConfig(c EditorConfig) *State {
 	})
 }
 
+// SetEnv updates State.Env.
+func (st *State) SetEnv(m EnvMap) *State {
+	return st.Copy(func(st *State) {
+		st.Env = m
+	})
+}
+
 // SetSrc is a wrapper around View.SetSrc().
 // If `len(src) == 0` it does nothing because this is almost always a bug.
-func (st *State) SetSrc(src []byte) *State {
+func (st *State) SetViewSrc(src []byte) *State {
 	if len(src) == 0 {
 		return st
 	}
-	return st.Copy(func(st *State) {
-		st.View = st.View.SetSrc(src)
-	})
+	return st.SetView(st.View.SetSrc(src))
 }
 
 func (st *State) SetView(v *View) *State {
diff --git a/src/margo.sh/mg/store.go b/src/margo.sh/mg/store.go
index f29fdf69..fd1f80f5 100644
--- a/src/margo.sh/mg/store.go
+++ b/src/margo.sh/mg/store.go
@@ -1,7 +1,7 @@
 package mg
 
 import (
-	"margo.sh/misc/pf"
+	"margo.sh/mgpf"
 	"os"
 	"path/filepath"
 	"strings"
@@ -10,8 +10,10 @@ import (
 
 var _ Dispatcher = (&Store{}).Dispatch
 
+// Dispatcher is the signature of the Store.Dispatch method
 type Dispatcher func(Action)
 
+// Subscriber is the signature of the function accepted by Store.Subscribe
 type Subscriber func(*Ctx)
 
 type dispatchHandler func()
@@ -42,7 +44,10 @@ func (sr storeReducers) Copy(updaters ...func(*storeReducers)) storeReducers {
 	return sr
 }
 
+// Store holds global, shared state
 type Store struct {
+	// KVMap is an in-memory cache of data with automatic eviction
+	// eviction might happen if the active view changes
 	KVMap
 
 	mu       sync.Mutex
@@ -69,7 +74,7 @@ type Store struct {
 		unmounted bool
 	}
 
-	mounted map[Reducer]bool
+	mounted map[*ReducerType]bool
 }
 
 func (sto *Store) mount() {
@@ -94,8 +99,18 @@ func (sto *Store) unmount() {
 	<-done
 }
 
+// Dispatch schedules a new reduction with Action act
+//
+// * actions coming from the editor has a higher priority
+// * as a result, if Shutdown is dispatched, the action might be dropped
 func (sto *Store) Dispatch(act Action) {
-	sto.dsp.lo <- func() { sto.handleAct(act, nil) }
+	c := sto.dsp.lo
+	f := func() { sto.handleAct(act, nil) }
+	select {
+	case c <- f:
+	default:
+		go func() { c <- f }()
+	}
 }
 
 func (sto *Store) nextDispatcher() dispatchHandler {
@@ -119,8 +134,8 @@ func (sto *Store) nextDispatcher() dispatchHandler {
 }
 
 func (sto *Store) dispatcher() {
-	sto.handleAct(Started{}, nil)
 	sto.ag.Log.Println("started")
+	sto.handleAct(initAction{}, nil)
 
 	for {
 		if f := sto.nextDispatcher(); f != nil {
@@ -137,7 +152,7 @@ func (sto *Store) handleReduce(mx *Ctx) *Ctx {
 	return sto.reducers.Reduce(mx)
 }
 
-func (sto *Store) handle(h func() *Ctx, p *pf.Profile) {
+func (sto *Store) handle(h func() *Ctx, p *mgpf.Profile) {
 	p.Push("handleRequest")
 	sto.mu.Lock()
 
@@ -153,9 +168,9 @@ func (sto *Store) handle(h func() *Ctx, p *pf.Profile) {
 	}
 }
 
-func (sto *Store) handleAct(act Action, p *pf.Profile) {
+func (sto *Store) handleAct(act Action, p *mgpf.Profile) {
 	if p == nil {
-		p = pf.NewProfile("")
+		p = mgpf.NewProfile("")
 	}
 	sto.handle(func() *Ctx {
 		mx := newCtx(sto, nil, act, "", p)
@@ -202,7 +217,7 @@ func (sto *Store) handleReqInit(rq *agentReq, mx *Ctx) (*Ctx, []Action) {
 	if v := props.View; v != nil && v.Name != "" {
 		mx.View = v
 		sto.initCache(v)
-		v.initSrcPos()
+		v.finalize()
 	}
 	if len(props.Env) != 0 {
 		mx.Env = props.Env
@@ -253,11 +268,13 @@ func newStore(ag *Agent, sub Subscriber) *Store {
 	sto.dsp.lo = make(chan dispatchHandler, 640)
 	sto.dsp.hi = make(chan dispatchHandler, 640)
 
-	sto.mounted = map[Reducer]bool{}
+	sto.mounted = map[*ReducerType]bool{}
 
 	return sto
 }
 
+// Subscribe arranges for sub to be called after each reduction takes place
+// the function returned can be used to unsubscribe from further notifications
 func (sto *Store) Subscribe(sub Subscriber) (unsubscribe func()) {
 	sto.mu.Lock()
 	defer sto.mu.Unlock()
@@ -287,25 +304,36 @@ func (sto *Store) updateReducers(updaters ...func(*storeReducers)) *Store {
 	return sto
 }
 
+// Before adds reducers to the list of reducers
+// they're are called before normal (Store.Use) reducers
 func (sto *Store) Before(reducers ...Reducer) *Store {
 	return sto.updateReducers(func(sr *storeReducers) {
 		sr.before = sr.before.Add(reducers...)
 	})
 }
 
+// Use adds reducers to the list of reducers
+// they're called after reducers added with Store.Before
+// and before reducers added with Store.After
 func (sto *Store) Use(reducers ...Reducer) *Store {
 	return sto.updateReducers(func(sr *storeReducers) {
 		sr.use = sr.use.Add(reducers...)
 	})
 }
 
+// After adds reducers to the list of reducers
+// they're are called after normal (Store.Use) reducers
 func (sto *Store) After(reducers ...Reducer) *Store {
 	return sto.updateReducers(func(sr *storeReducers) {
 		sr.after = sr.after.Add(reducers...)
 	})
 }
 
-func (sto *Store) EditorConfig(cfg EditorConfig) *Store {
+// SetBaseConfig sets the EditorConfig on which State.Config is based
+//
+// this method is made available for use by editor/client integration
+// normal users should use State.SetConfig instead
+func (sto *Store) SetBaseConfig(cfg EditorConfig) *Store {
 	sto.mu.Lock()
 	defer sto.mu.Unlock()
 
@@ -313,6 +341,7 @@ func (sto *Store) EditorConfig(cfg EditorConfig) *Store {
 	return sto
 }
 
+// Begin starts a new task and returns its ticket
 func (sto *Store) Begin(t Task) *TaskTicket {
 	return sto.tasks.Begin(t)
 }
diff --git a/src/margo.sh/mg/tasks.go b/src/margo.sh/mg/tasks.go
index 89abf838..0ef407ca 100644
--- a/src/margo.sh/mg/tasks.go
+++ b/src/margo.sh/mg/tasks.go
@@ -13,6 +13,7 @@ type Task struct {
 	Title    string
 	Cancel   func()
 	CancelID string
+	ShowNow  bool
 }
 
 type TaskTicket struct {
@@ -22,6 +23,7 @@ type TaskTicket struct {
 	CancelID string
 
 	tracker *taskTracker
+	showNow bool
 	cancel  func()
 }
 
@@ -51,6 +53,9 @@ type taskTracker struct {
 }
 
 func (tr *taskTracker) ReducerMount(mx *Ctx) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+
 	tr.timer = time.NewTimer(1 * time.Second)
 	dispatch := mx.Store.Dispatch
 	go func() {
@@ -61,6 +66,9 @@ func (tr *taskTracker) ReducerMount(mx *Ctx) {
 }
 
 func (tr *taskTracker) ReducerUnmount(*Ctx) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+
 	for _, t := range tr.tickets {
 		t.Cancel()
 	}
@@ -118,12 +126,6 @@ func (tr *taskTracker) runCmd(st *State) *State {
 	)
 }
 
-func (tr *taskTracker) shutdown(mx *Ctx) {
-	for _, t := range tr.tickets {
-		t.Cancel()
-	}
-}
-
 // Cancel cancels the task tid.
 // true is returned if the task exists and was canceled
 func (tr *taskTracker) Cancel(tid string) bool {
@@ -204,11 +206,11 @@ func (tr *taskTracker) status() string {
 		default:
 			tr.buf.WriteString(" ●")
 		}
-		if title == "" && t.Title != "" && age >= 1 && age <= 3 {
+		if title == "" && t.Title != "" && (age >= 1 || t.showNow) && age <= 3 {
 			title = t.Title
 		}
 	}
-	if tr.buf.Len() == initLen {
+	if tr.buf.Len() == initLen && title == "" {
 		return ""
 	}
 	if title != "" {
@@ -280,6 +282,7 @@ func (tr *taskTracker) Begin(o Task) *TaskTicket {
 		Start:    time.Now(),
 		cancel:   o.Cancel,
 		tracker:  tr,
+		showNow:  o.ShowNow,
 	}
 	tr.tickets = append(tr.tickets, t)
 	return t
diff --git a/src/margo.sh/mg/view.go b/src/margo.sh/mg/view.go
index fd2dc79d..e4005475 100644
--- a/src/margo.sh/mg/view.go
+++ b/src/margo.sh/mg/view.go
@@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"regexp"
 	"unicode/utf8"
 )
 
@@ -22,7 +23,7 @@ type View struct {
 	Col   int
 	Dirty bool
 	Ext   string
-	Lang  string
+	Lang  Lang
 
 	changed int
 	kvs     KVStore
@@ -40,12 +41,12 @@ func (v *View) Copy(updaters ...func(*View)) *View {
 	return &x
 }
 
-func (v *View) LangIs(names ...string) bool {
-	for _, s := range names {
-		if s == v.Lang {
-			return true
-		}
-		if v.Ext != "" && v.Ext[1:] == s {
+func (v *View) LangIs(langs ...Lang) bool {
+	if len(langs) == 0 {
+		return true
+	}
+	for _, l := range langs {
+		if l == v.Lang {
 			return true
 		}
 	}
@@ -123,7 +124,7 @@ func (v *View) Open() (r io.ReadCloser, err error) {
 	return os.Open(v.Path)
 }
 
-func (v *View) initSrcPos() {
+func (v *View) finalize() {
 	src, err := v.ReadAll()
 	if err != nil {
 		return
@@ -131,7 +132,11 @@ func (v *View) initSrcPos() {
 
 	v.Src = src
 	v.Pos = BytePos(src, v.Pos)
+	lines := bytes.Split(src[:v.Pos], []byte{'\n'})
+	v.Row = len(lines) - 1
+	v.Col = len(lines[len(lines)-1])
 	v.Hash = SrcHash(src)
+	v.Ext = filepath.Ext(v.Filename())
 	v.kvs.Put(v.key(), src)
 }
 
@@ -152,6 +157,11 @@ func SrcHash(s []byte) string {
 	return "hash:blake2b/Sum512;base64url," + base64.URLEncoding.EncodeToString(hash[:])
 }
 
+// CommonPatterns is equivalent to CommonPatterns(View.Lang)
+func (v *View) CommonPatterns() []*regexp.Regexp {
+	return CommonPatterns(v.Lang)
+}
+
 func BytePos(src []byte, charPos int) int {
 	for i, c := range src {
 		if !utf8.RuneStart(c) {
diff --git a/src/margo.sh/misc/pf/pf.go b/src/margo.sh/mgpf/mgpf.go
similarity index 99%
rename from src/margo.sh/misc/pf/pf.go
rename to src/margo.sh/mgpf/mgpf.go
index 0555f4db..f1dcd924 100644
--- a/src/margo.sh/misc/pf/pf.go
+++ b/src/margo.sh/mgpf/mgpf.go
@@ -1,4 +1,4 @@
-package pf
+package mgpf
 
 import (
 	"fmt"
diff --git a/src/margo.sh/misc/pprof/pprofdo/pprofdo-fallback.go b/src/margo.sh/mgpf/pprof/pprofdo/pprofdo-fallback.go
similarity index 100%
rename from src/margo.sh/misc/pprof/pprofdo/pprofdo-fallback.go
rename to src/margo.sh/mgpf/pprof/pprofdo/pprofdo-fallback.go
diff --git a/src/margo.sh/misc/pprof/pprofdo/pprofdo.go b/src/margo.sh/mgpf/pprof/pprofdo/pprofdo.go
similarity index 100%
rename from src/margo.sh/misc/pprof/pprofdo/pprofdo.go
rename to src/margo.sh/mgpf/pprof/pprofdo/pprofdo.go
diff --git a/src/margo.sh/misc/pprof/pprofhttp/pprofhttp.go b/src/margo.sh/mgpf/pprof/pprofhttp/pprofhttp.go
similarity index 100%
rename from src/margo.sh/misc/pprof/pprofhttp/pprofhttp.go
rename to src/margo.sh/mgpf/pprof/pprofhttp/pprofhttp.go
diff --git a/src/margo.sh/sublime/config.go b/src/margo.sh/sublime/config.go
index 6d805ec6..01065df5 100644
--- a/src/margo.sh/sublime/config.go
+++ b/src/margo.sh/sublime/config.go
@@ -12,7 +12,7 @@ var (
 
 type Config struct {
 	Values struct {
-		EnabledForLangs            []string
+		EnabledForLangs            []mg.Lang
 		InhibitExplicitCompletions bool
 		InhibitWordCompletions     bool
 		OverrideSettings           map[string]interface{}
@@ -27,7 +27,7 @@ func (c Config) Config() mg.EditorConfig {
 	return c
 }
 
-func (c Config) EnabledForLangs(langs ...string) mg.EditorConfig {
+func (c Config) EnabledForLangs(langs ...mg.Lang) mg.EditorConfig {
 	c.Values.EnabledForLangs = langs
 	return c
 }
diff --git a/src/margo.sh/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s b/src/margo.sh/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s
index 784bce6a..5593b1b3 100644
--- a/src/margo.sh/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s
+++ b/src/margo.sh/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.s
@@ -748,15 +748,3 @@ noinc:
 
 	MOVQ BP, SP
 	RET
-
-// func supportsAVX2() bool
-TEXT ·supportsAVX2(SB), 4, $0-1
-	MOVQ runtime·support_avx2(SB), AX
-	MOVB AX, ret+0(FP)
-	RET
-
-// func supportsAVX() bool
-TEXT ·supportsAVX(SB), 4, $0-1
-	MOVQ runtime·support_avx(SB), AX
-	MOVB AX, ret+0(FP)
-	RET
diff --git a/src/margo.sh/vendor/golang.org/x/tools/AUTHORS b/src/margo.sh/vendor/golang.org/x/tools/AUTHORS
new file mode 100644
index 00000000..15167cd7
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/src/margo.sh/vendor/golang.org/x/tools/CONTRIBUTORS b/src/margo.sh/vendor/golang.org/x/tools/CONTRIBUTORS
new file mode 100644
index 00000000..1c4577e9
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/src/margo.sh/vendor/golang.org/x/tools/LICENSE b/src/margo.sh/vendor/golang.org/x/tools/LICENSE
new file mode 100644
index 00000000..6a66aea5
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/LICENSE
@@ -0,0 +1,27 @@
+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
+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.
diff --git a/src/margo.sh/vendor/golang.org/x/tools/PATENTS b/src/margo.sh/vendor/golang.org/x/tools/PATENTS
new file mode 100644
index 00000000..73309904
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/cmd/getgo/LICENSE b/src/margo.sh/vendor/golang.org/x/tools/cmd/getgo/LICENSE
new file mode 100644
index 00000000..32017f8f
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/getgo/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2017 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.
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callees.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callees.go
new file mode 100644
index 00000000..7ab1dba5
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callees.go
@@ -0,0 +1,257 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/pointer"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// Callees reports the possible callees of the function call site
+// identified by the specified source location.
+func callees(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
+	if err != nil {
+		return err
+	}
+
+	// Determine the enclosing call for the specified position.
+	var e *ast.CallExpr
+	for _, n := range qpos.path {
+		if e, _ = n.(*ast.CallExpr); e != nil {
+			break
+		}
+	}
+	if e == nil {
+		return fmt.Errorf("there is no function call here")
+	}
+	// TODO(adonovan): issue an error if the call is "too far
+	// away" from the current selection, as this most likely is
+	// not what the user intended.
+
+	// Reject type conversions.
+	if qpos.info.Types[e.Fun].IsType() {
+		return fmt.Errorf("this is a type conversion, not a function call")
+	}
+
+	// Deal with obviously static calls before constructing SSA form.
+	// Some static calls may yet require SSA construction,
+	// e.g.  f := func(){}; f().
+	switch funexpr := unparen(e.Fun).(type) {
+	case *ast.Ident:
+		switch obj := qpos.info.Uses[funexpr].(type) {
+		case *types.Builtin:
+			// Reject calls to built-ins.
+			return fmt.Errorf("this is a call to the built-in '%s' operator", obj.Name())
+		case *types.Func:
+			// This is a static function call
+			q.Output(lprog.Fset, &calleesTypesResult{
+				site:   e,
+				callee: obj,
+			})
+			return nil
+		}
+	case *ast.SelectorExpr:
+		sel := qpos.info.Selections[funexpr]
+		if sel == nil {
+			// qualified identifier.
+			// May refer to top level function variable
+			// or to top level function.
+			callee := qpos.info.Uses[funexpr.Sel]
+			if obj, ok := callee.(*types.Func); ok {
+				q.Output(lprog.Fset, &calleesTypesResult{
+					site:   e,
+					callee: obj,
+				})
+				return nil
+			}
+		} else if sel.Kind() == types.MethodVal {
+			// Inspect the receiver type of the selected method.
+			// If it is concrete, the call is statically dispatched.
+			// (Due to implicit field selections, it is not enough to look
+			// at sel.Recv(), the type of the actual receiver expression.)
+			method := sel.Obj().(*types.Func)
+			recvtype := method.Type().(*types.Signature).Recv().Type()
+			if !types.IsInterface(recvtype) {
+				// static method call
+				q.Output(lprog.Fset, &calleesTypesResult{
+					site:   e,
+					callee: method,
+				})
+				return nil
+			}
+		}
+	}
+
+	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	pkg := prog.Package(qpos.info.Pkg)
+	if pkg == nil {
+		return fmt.Errorf("no SSA package")
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	// Ascertain calling function and call site.
+	callerFn := ssa.EnclosingFunction(pkg, qpos.path)
+	if callerFn == nil {
+		return fmt.Errorf("no SSA function built for this location (dead code?)")
+	}
+
+	// Find the call site.
+	site, err := findCallSite(callerFn, e)
+	if err != nil {
+		return err
+	}
+
+	funcs, err := findCallees(ptaConfig, site)
+	if err != nil {
+		return err
+	}
+
+	q.Output(lprog.Fset, &calleesSSAResult{
+		site:  site,
+		funcs: funcs,
+	})
+	return nil
+}
+
+func findCallSite(fn *ssa.Function, call *ast.CallExpr) (ssa.CallInstruction, error) {
+	instr, _ := fn.ValueForExpr(call)
+	callInstr, _ := instr.(ssa.CallInstruction)
+	if instr == nil {
+		return nil, fmt.Errorf("this call site is unreachable in this analysis")
+	}
+	return callInstr, nil
+}
+
+func findCallees(conf *pointer.Config, site ssa.CallInstruction) ([]*ssa.Function, error) {
+	// Avoid running the pointer analysis for static calls.
+	if callee := site.Common().StaticCallee(); callee != nil {
+		switch callee.String() {
+		case "runtime.SetFinalizer", "(reflect.Value).Call":
+			// The PTA treats calls to these intrinsics as dynamic.
+			// TODO(adonovan): avoid reliance on PTA internals.
+
+		default:
+			return []*ssa.Function{callee}, nil // singleton
+		}
+	}
+
+	// Dynamic call: use pointer analysis.
+	conf.BuildCallGraph = true
+	cg := ptrAnalysis(conf).CallGraph
+	cg.DeleteSyntheticNodes()
+
+	// Find all call edges from the site.
+	n := cg.Nodes[site.Parent()]
+	if n == nil {
+		return nil, fmt.Errorf("this call site is unreachable in this analysis")
+	}
+	calleesMap := make(map[*ssa.Function]bool)
+	for _, edge := range n.Out {
+		if edge.Site == site {
+			calleesMap[edge.Callee.Func] = true
+		}
+	}
+
+	// De-duplicate and sort.
+	funcs := make([]*ssa.Function, 0, len(calleesMap))
+	for f := range calleesMap {
+		funcs = append(funcs, f)
+	}
+	sort.Sort(byFuncPos(funcs))
+	return funcs, nil
+}
+
+type calleesSSAResult struct {
+	site  ssa.CallInstruction
+	funcs []*ssa.Function
+}
+
+type calleesTypesResult struct {
+	site   *ast.CallExpr
+	callee *types.Func
+}
+
+func (r *calleesSSAResult) PrintPlain(printf printfFunc) {
+	if len(r.funcs) == 0 {
+		// dynamic call on a provably nil func/interface
+		printf(r.site, "%s on nil value", r.site.Common().Description())
+	} else {
+		printf(r.site, "this %s dispatches to:", r.site.Common().Description())
+		for _, callee := range r.funcs {
+			printf(callee, "\t%s", callee)
+		}
+	}
+}
+
+func (r *calleesSSAResult) JSON(fset *token.FileSet) []byte {
+	j := &serial.Callees{
+		Pos:  fset.Position(r.site.Pos()).String(),
+		Desc: r.site.Common().Description(),
+	}
+	for _, callee := range r.funcs {
+		j.Callees = append(j.Callees, &serial.Callee{
+			Name: callee.String(),
+			Pos:  fset.Position(callee.Pos()).String(),
+		})
+	}
+	return toJSON(j)
+}
+
+func (r *calleesTypesResult) PrintPlain(printf printfFunc) {
+	printf(r.site, "this static function call dispatches to:")
+	printf(r.callee, "\t%s", r.callee.FullName())
+}
+
+func (r *calleesTypesResult) JSON(fset *token.FileSet) []byte {
+	j := &serial.Callees{
+		Pos:  fset.Position(r.site.Pos()).String(),
+		Desc: "static function call",
+	}
+	j.Callees = []*serial.Callee{
+		{
+			Name: r.callee.FullName(),
+			Pos:  fset.Position(r.callee.Pos()).String(),
+		},
+	}
+	return toJSON(j)
+}
+
+// NB: byFuncPos is not deterministic across packages since it depends on load order.
+// Use lessPos if the tests need it.
+type byFuncPos []*ssa.Function
+
+func (a byFuncPos) Len() int           { return len(a) }
+func (a byFuncPos) Less(i, j int) bool { return a[i].Pos() < a[j].Pos() }
+func (a byFuncPos) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callers.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callers.go
new file mode 100644
index 00000000..e51b6e50
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callers.go
@@ -0,0 +1,195 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// Callers reports the possible callers of the function
+// immediately enclosing the specified source location.
+//
+func callers(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	prog := ssautil.CreateProgram(lprog, 0)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	pkg := prog.Package(qpos.info.Pkg)
+	if pkg == nil {
+		return fmt.Errorf("no SSA package")
+	}
+	if !ssa.HasEnclosingFunction(pkg, qpos.path) {
+		return fmt.Errorf("this position is not inside a function")
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	target := ssa.EnclosingFunction(pkg, qpos.path)
+	if target == nil {
+		return fmt.Errorf("no SSA function built for this location (dead code?)")
+	}
+
+	// If the function is never address-taken, all calls are direct
+	// and can be found quickly by inspecting the whole SSA program.
+	cg := directCallsTo(target, entryPoints(ptaConfig.Mains))
+	if cg == nil {
+		// Run the pointer analysis, recording each
+		// call found to originate from target.
+		// (Pointer analysis may return fewer results than
+		// directCallsTo because it ignores dead code.)
+		ptaConfig.BuildCallGraph = true
+		cg = ptrAnalysis(ptaConfig).CallGraph
+	}
+	cg.DeleteSyntheticNodes()
+	edges := cg.CreateNode(target).In
+
+	// TODO(adonovan): sort + dedup calls to ensure test determinism.
+
+	q.Output(lprog.Fset, &callersResult{
+		target:    target,
+		callgraph: cg,
+		edges:     edges,
+	})
+	return nil
+}
+
+// directCallsTo inspects the whole program and returns a callgraph
+// containing edges for all direct calls to the target function.
+// directCallsTo returns nil if the function is ever address-taken.
+func directCallsTo(target *ssa.Function, entrypoints []*ssa.Function) *callgraph.Graph {
+	cg := callgraph.New(nil) // use nil as root *Function
+	targetNode := cg.CreateNode(target)
+
+	// Is the function a program entry point?
+	// If so, add edge from callgraph root.
+	for _, f := range entrypoints {
+		if f == target {
+			callgraph.AddEdge(cg.Root, nil, targetNode)
+		}
+	}
+
+	// Find receiver type (for methods).
+	var recvType types.Type
+	if recv := target.Signature.Recv(); recv != nil {
+		recvType = recv.Type()
+	}
+
+	// Find all direct calls to function,
+	// or a place where its address is taken.
+	var space [32]*ssa.Value // preallocate
+	for fn := range ssautil.AllFunctions(target.Prog) {
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				// Is this a method (T).f of a concrete type T
+				// whose runtime type descriptor is address-taken?
+				// (To be fully sound, we would have to check that
+				// the type doesn't make it to reflection as a
+				// subelement of some other address-taken type.)
+				if recvType != nil {
+					if mi, ok := instr.(*ssa.MakeInterface); ok {
+						if types.Identical(mi.X.Type(), recvType) {
+							return nil // T is address-taken
+						}
+						if ptr, ok := mi.X.Type().(*types.Pointer); ok &&
+							types.Identical(ptr.Elem(), recvType) {
+							return nil // *T is address-taken
+						}
+					}
+				}
+
+				// Direct call to target?
+				rands := instr.Operands(space[:0])
+				if site, ok := instr.(ssa.CallInstruction); ok &&
+					site.Common().Value == target {
+					callgraph.AddEdge(cg.CreateNode(fn), site, targetNode)
+					rands = rands[1:] // skip .Value (rands[0])
+				}
+
+				// Address-taken?
+				for _, rand := range rands {
+					if rand != nil && *rand == target {
+						return nil
+					}
+				}
+			}
+		}
+	}
+
+	return cg
+}
+
+func entryPoints(mains []*ssa.Package) []*ssa.Function {
+	var entrypoints []*ssa.Function
+	for _, pkg := range mains {
+		entrypoints = append(entrypoints, pkg.Func("init"))
+		if main := pkg.Func("main"); main != nil && pkg.Pkg.Name() == "main" {
+			entrypoints = append(entrypoints, main)
+		}
+	}
+	return entrypoints
+}
+
+type callersResult struct {
+	target    *ssa.Function
+	callgraph *callgraph.Graph
+	edges     []*callgraph.Edge
+}
+
+func (r *callersResult) PrintPlain(printf printfFunc) {
+	root := r.callgraph.Root
+	if r.edges == nil {
+		printf(r.target, "%s is not reachable in this program.", r.target)
+	} else {
+		printf(r.target, "%s is called from these %d sites:", r.target, len(r.edges))
+		for _, edge := range r.edges {
+			if edge.Caller == root {
+				printf(r.target, "the root of the call graph")
+			} else {
+				printf(edge, "\t%s from %s", edge.Description(), edge.Caller.Func)
+			}
+		}
+	}
+}
+
+func (r *callersResult) JSON(fset *token.FileSet) []byte {
+	var callers []serial.Caller
+	for _, edge := range r.edges {
+		callers = append(callers, serial.Caller{
+			Caller: edge.Caller.Func.String(),
+			Pos:    fset.Position(edge.Pos()).String(),
+			Desc:   edge.Description(),
+		})
+	}
+	return toJSON(callers)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callstack.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callstack.go
new file mode 100644
index 00000000..f1ca6a6c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/callstack.go
@@ -0,0 +1,141 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/token"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/static"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// Callstack displays an arbitrary path from a root of the callgraph
+// to the function at the current position.
+//
+// The information may be misleading in a context-insensitive
+// analysis. e.g. the call path X->Y->Z might be infeasible if Y never
+// calls Z when it is called from X.  TODO(adonovan): think about UI.
+//
+// TODO(adonovan): permit user to specify a starting point other than
+// the analysis root.
+//
+func callstack(q *Query) error {
+	fset := token.NewFileSet()
+	lconf := loader.Config{Fset: fset, Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	prog := ssautil.CreateProgram(lprog, 0)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	pkg := prog.Package(qpos.info.Pkg)
+	if pkg == nil {
+		return fmt.Errorf("no SSA package")
+	}
+
+	if !ssa.HasEnclosingFunction(pkg, qpos.path) {
+		return fmt.Errorf("this position is not inside a function")
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	target := ssa.EnclosingFunction(pkg, qpos.path)
+	if target == nil {
+		return fmt.Errorf("no SSA function built for this location (dead code?)")
+	}
+
+	var callpath []*callgraph.Edge
+	isEnd := func(n *callgraph.Node) bool { return n.Func == target }
+
+	// First, build a callgraph containing only static call edges,
+	// and search for an arbitrary path from a root to the target function.
+	// This is quick, and the user wants a static path if one exists.
+	cg := static.CallGraph(prog)
+	cg.DeleteSyntheticNodes()
+	for _, ep := range entryPoints(ptaConfig.Mains) {
+		callpath = callgraph.PathSearch(cg.CreateNode(ep), isEnd)
+		if callpath != nil {
+			break
+		}
+	}
+
+	// No fully static path found.
+	// Run the pointer analysis and build a complete call graph.
+	if callpath == nil {
+		ptaConfig.BuildCallGraph = true
+		cg := ptrAnalysis(ptaConfig).CallGraph
+		cg.DeleteSyntheticNodes()
+		callpath = callgraph.PathSearch(cg.Root, isEnd)
+		if callpath != nil {
+			callpath = callpath[1:] // remove synthetic edge from <root>
+		}
+	}
+
+	q.Output(fset, &callstackResult{
+		qpos:     qpos,
+		target:   target,
+		callpath: callpath,
+	})
+	return nil
+}
+
+type callstackResult struct {
+	qpos     *queryPos
+	target   *ssa.Function
+	callpath []*callgraph.Edge
+}
+
+func (r *callstackResult) PrintPlain(printf printfFunc) {
+	if r.callpath != nil {
+		printf(r.qpos, "Found a call path from root to %s", r.target)
+		printf(r.target, "%s", r.target)
+		for i := len(r.callpath) - 1; i >= 0; i-- {
+			edge := r.callpath[i]
+			printf(edge, "%s from %s", edge.Description(), edge.Caller.Func)
+		}
+	} else {
+		printf(r.target, "%s is unreachable in this analysis scope", r.target)
+	}
+}
+
+func (r *callstackResult) JSON(fset *token.FileSet) []byte {
+	var callers []serial.Caller
+	for i := len(r.callpath) - 1; i >= 0; i-- { // (innermost first)
+		edge := r.callpath[i]
+		callers = append(callers, serial.Caller{
+			Pos:    fset.Position(edge.Pos()).String(),
+			Caller: edge.Caller.Func.String(),
+			Desc:   edge.Description(),
+		})
+	}
+	return toJSON(&serial.CallStack{
+		Pos:     fset.Position(r.target.Pos()).String(),
+		Target:  r.target.String(),
+		Callers: callers,
+	})
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/definition.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/definition.go
new file mode 100644
index 00000000..46d48060
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/definition.go
@@ -0,0 +1,205 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	pathpkg "path"
+	"path/filepath"
+	"strconv"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+)
+
+// definition reports the location of the definition of an identifier.
+func definition(q *Query) error {
+	// First try the simple resolution done by parser.
+	// It only works for intra-file references but it is very fast.
+	// (Extending this approach to all the files of the package,
+	// resolved using ast.NewPackage, was not worth the effort.)
+	{
+		qpos, err := fastQueryPos(q.Build, q.Pos)
+		if err != nil {
+			return err
+		}
+
+		id, _ := qpos.path[0].(*ast.Ident)
+		if id == nil {
+			return fmt.Errorf("no identifier here")
+		}
+
+		// Did the parser resolve it to a local object?
+		if obj := id.Obj; obj != nil && obj.Pos().IsValid() {
+			q.Output(qpos.fset, &definitionResult{
+				pos:   obj.Pos(),
+				descr: fmt.Sprintf("%s %s", obj.Kind, obj.Name),
+			})
+			return nil // success
+		}
+
+		// Qualified identifier?
+		if pkg := packageForQualIdent(qpos.path, id); pkg != "" {
+			srcdir := filepath.Dir(qpos.fset.File(qpos.start).Name())
+			tok, pos, err := findPackageMember(q.Build, qpos.fset, srcdir, pkg, id.Name)
+			if err != nil {
+				return err
+			}
+			q.Output(qpos.fset, &definitionResult{
+				pos:   pos,
+				descr: fmt.Sprintf("%s %s.%s", tok, pkg, id.Name),
+			})
+			return nil // success
+		}
+
+		// Fall back on the type checker.
+	}
+
+	// Run the type checker.
+	lconf := loader.Config{Build: q.Build}
+	allowErrors(&lconf)
+
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := lconf.Load()
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	id, _ := qpos.path[0].(*ast.Ident)
+	if id == nil {
+		return fmt.Errorf("no identifier here")
+	}
+
+	// Look up the declaration of this identifier.
+	// If id is an anonymous field declaration,
+	// it is both a use of a type and a def of a field;
+	// prefer the use in that case.
+	obj := qpos.info.Uses[id]
+	if obj == nil {
+		obj = qpos.info.Defs[id]
+		if obj == nil {
+			// Happens for y in "switch y := x.(type)",
+			// and the package declaration,
+			// but I think that's all.
+			return fmt.Errorf("no object for identifier")
+		}
+	}
+
+	if !obj.Pos().IsValid() {
+		return fmt.Errorf("%s is built in", obj.Name())
+	}
+
+	q.Output(lprog.Fset, &definitionResult{
+		pos:   obj.Pos(),
+		descr: qpos.objectString(obj),
+	})
+	return nil
+}
+
+// packageForQualIdent returns the package p if id is X in a qualified
+// identifier p.X; it returns "" otherwise.
+//
+// Precondition: id is path[0], and the parser did not resolve id to a
+// local object.  For speed, packageForQualIdent assumes that p is a
+// package iff it is the basename of an import path (and not, say, a
+// package-level decl in another file or a predeclared identifier).
+func packageForQualIdent(path []ast.Node, id *ast.Ident) string {
+	if sel, ok := path[1].(*ast.SelectorExpr); ok && sel.Sel == id && ast.IsExported(id.Name) {
+		if pkgid, ok := sel.X.(*ast.Ident); ok && pkgid.Obj == nil {
+			f := path[len(path)-1].(*ast.File)
+			for _, imp := range f.Imports {
+				path, _ := strconv.Unquote(imp.Path.Value)
+				if imp.Name != nil {
+					if imp.Name.Name == pkgid.Name {
+						return path // renaming import
+					}
+				} else if pathpkg.Base(path) == pkgid.Name {
+					return path // ordinary import
+				}
+			}
+		}
+	}
+	return ""
+}
+
+// findPackageMember returns the type and position of the declaration of
+// pkg.member by loading and parsing the files of that package.
+// srcdir is the directory in which the import appears.
+func findPackageMember(ctxt *build.Context, fset *token.FileSet, srcdir, pkg, member string) (token.Token, token.Pos, error) {
+	bp, err := ctxt.Import(pkg, srcdir, 0)
+	if err != nil {
+		return 0, token.NoPos, err // no files for package
+	}
+
+	// TODO(adonovan): opt: parallelize.
+	for _, fname := range bp.GoFiles {
+		filename := filepath.Join(bp.Dir, fname)
+
+		// Parse the file, opening it the file via the build.Context
+		// so that we observe the effects of the -modified flag.
+		f, _ := buildutil.ParseFile(fset, ctxt, nil, ".", filename, parser.Mode(0))
+		if f == nil {
+			continue
+		}
+
+		// Find a package-level decl called 'member'.
+		for _, decl := range f.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				for _, spec := range decl.Specs {
+					switch spec := spec.(type) {
+					case *ast.ValueSpec:
+						// const or var
+						for _, id := range spec.Names {
+							if id.Name == member {
+								return decl.Tok, id.Pos(), nil
+							}
+						}
+					case *ast.TypeSpec:
+						if spec.Name.Name == member {
+							return token.TYPE, spec.Name.Pos(), nil
+						}
+					}
+				}
+			case *ast.FuncDecl:
+				if decl.Recv == nil && decl.Name.Name == member {
+					return token.FUNC, decl.Name.Pos(), nil
+				}
+			}
+		}
+	}
+
+	return 0, token.NoPos, fmt.Errorf("couldn't find declaration of %s in %q", member, pkg)
+}
+
+type definitionResult struct {
+	pos   token.Pos // (nonzero) location of definition
+	descr string    // description of object it denotes
+}
+
+func (r *definitionResult) PrintPlain(printf printfFunc) {
+	printf(r.pos, "defined here as %s", r.descr)
+}
+
+func (r *definitionResult) JSON(fset *token.FileSet) []byte {
+	return toJSON(&serial.Definition{
+		Desc:   r.descr,
+		ObjPos: fset.Position(r.pos).String(),
+	})
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/describe.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/describe.go
new file mode 100644
index 00000000..dd32911d
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/describe.go
@@ -0,0 +1,899 @@
+// 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 main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"os"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// describe describes the syntax node denoted by the query position,
+// including:
+// - its syntactic category
+// - the definition of its referent (for identifiers) [now redundant]
+// - its type, fields, and methods (for an expression or type expression)
+//
+func describe(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+	allowErrors(&lconf)
+
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := lconf.Load()
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, true) // (need exact pos)
+	if err != nil {
+		return err
+	}
+
+	if false { // debugging
+		fprintf(os.Stderr, lprog.Fset, qpos.path[0], "you selected: %s %s",
+			astutil.NodeDescription(qpos.path[0]), pathToString(qpos.path))
+	}
+
+	var qr QueryResult
+	path, action := findInterestingNode(qpos.info, qpos.path)
+	switch action {
+	case actionExpr:
+		qr, err = describeValue(qpos, path)
+
+	case actionType:
+		qr, err = describeType(qpos, path)
+
+	case actionPackage:
+		qr, err = describePackage(qpos, path)
+
+	case actionStmt:
+		qr, err = describeStmt(qpos, path)
+
+	case actionUnknown:
+		qr = &describeUnknownResult{path[0]}
+
+	default:
+		panic(action) // unreachable
+	}
+	if err != nil {
+		return err
+	}
+	q.Output(lprog.Fset, qr)
+	return nil
+}
+
+type describeUnknownResult struct {
+	node ast.Node
+}
+
+func (r *describeUnknownResult) PrintPlain(printf printfFunc) {
+	// Nothing much to say about misc syntax.
+	printf(r.node, "%s", astutil.NodeDescription(r.node))
+}
+
+func (r *describeUnknownResult) JSON(fset *token.FileSet) []byte {
+	return toJSON(&serial.Describe{
+		Desc: astutil.NodeDescription(r.node),
+		Pos:  fset.Position(r.node.Pos()).String(),
+	})
+}
+
+type action int
+
+const (
+	actionUnknown action = iota // None of the below
+	actionExpr                  // FuncDecl, true Expr or Ident(types.{Const,Var})
+	actionType                  // type Expr or Ident(types.TypeName).
+	actionStmt                  // Stmt or Ident(types.Label)
+	actionPackage               // Ident(types.Package) or ImportSpec
+)
+
+// findInterestingNode classifies the syntax node denoted by path as one of:
+//    - an expression, part of an expression or a reference to a constant
+//      or variable;
+//    - a type, part of a type, or a reference to a named type;
+//    - a statement, part of a statement, or a label referring to a statement;
+//    - part of a package declaration or import spec.
+//    - none of the above.
+// and returns the most "interesting" associated node, which may be
+// the same node, an ancestor or a descendent.
+//
+func findInterestingNode(pkginfo *loader.PackageInfo, path []ast.Node) ([]ast.Node, action) {
+	// TODO(adonovan): integrate with go/types/stdlib_test.go and
+	// apply this to every AST node we can find to make sure it
+	// doesn't crash.
+
+	// TODO(adonovan): audit for ParenExpr safety, esp. since we
+	// traverse up and down.
+
+	// TODO(adonovan): if the users selects the "." in
+	// "fmt.Fprintf()", they'll get an ambiguous selection error;
+	// we won't even reach here.  Can we do better?
+
+	// TODO(adonovan): describing a field within 'type T struct {...}'
+	// describes the (anonymous) struct type and concludes "no methods".
+	// We should ascend to the enclosing type decl, if any.
+
+	for len(path) > 0 {
+		switch n := path[0].(type) {
+		case *ast.GenDecl:
+			if len(n.Specs) == 1 {
+				// Descend to sole {Import,Type,Value}Spec child.
+				path = append([]ast.Node{n.Specs[0]}, path...)
+				continue
+			}
+			return path, actionUnknown // uninteresting
+
+		case *ast.FuncDecl:
+			// Descend to function name.
+			path = append([]ast.Node{n.Name}, path...)
+			continue
+
+		case *ast.ImportSpec:
+			return path, actionPackage
+
+		case *ast.ValueSpec:
+			if len(n.Names) == 1 {
+				// Descend to sole Ident child.
+				path = append([]ast.Node{n.Names[0]}, path...)
+				continue
+			}
+			return path, actionUnknown // uninteresting
+
+		case *ast.TypeSpec:
+			// Descend to type name.
+			path = append([]ast.Node{n.Name}, path...)
+			continue
+
+		case ast.Stmt:
+			return path, actionStmt
+
+		case *ast.ArrayType,
+			*ast.StructType,
+			*ast.FuncType,
+			*ast.InterfaceType,
+			*ast.MapType,
+			*ast.ChanType:
+			return path, actionType
+
+		case *ast.Comment, *ast.CommentGroup, *ast.File, *ast.KeyValueExpr, *ast.CommClause:
+			return path, actionUnknown // uninteresting
+
+		case *ast.Ellipsis:
+			// Continue to enclosing node.
+			// e.g. [...]T in ArrayType
+			//      f(x...) in CallExpr
+			//      f(x...T) in FuncType
+
+		case *ast.Field:
+			// TODO(adonovan): this needs more thought,
+			// since fields can be so many things.
+			if len(n.Names) == 1 {
+				// Descend to sole Ident child.
+				path = append([]ast.Node{n.Names[0]}, path...)
+				continue
+			}
+			// Zero names (e.g. anon field in struct)
+			// or multiple field or param names:
+			// continue to enclosing field list.
+
+		case *ast.FieldList:
+			// Continue to enclosing node:
+			// {Struct,Func,Interface}Type or FuncDecl.
+
+		case *ast.BasicLit:
+			if _, ok := path[1].(*ast.ImportSpec); ok {
+				return path[1:], actionPackage
+			}
+			return path, actionExpr
+
+		case *ast.SelectorExpr:
+			// TODO(adonovan): use Selections info directly.
+			if pkginfo.Uses[n.Sel] == nil {
+				// TODO(adonovan): is this reachable?
+				return path, actionUnknown
+			}
+			// Descend to .Sel child.
+			path = append([]ast.Node{n.Sel}, path...)
+			continue
+
+		case *ast.Ident:
+			switch pkginfo.ObjectOf(n).(type) {
+			case *types.PkgName:
+				return path, actionPackage
+
+			case *types.Const:
+				return path, actionExpr
+
+			case *types.Label:
+				return path, actionStmt
+
+			case *types.TypeName:
+				return path, actionType
+
+			case *types.Var:
+				// For x in 'struct {x T}', return struct type, for now.
+				if _, ok := path[1].(*ast.Field); ok {
+					_ = path[2].(*ast.FieldList) // assertion
+					if _, ok := path[3].(*ast.StructType); ok {
+						return path[3:], actionType
+					}
+				}
+				return path, actionExpr
+
+			case *types.Func:
+				return path, actionExpr
+
+			case *types.Builtin:
+				// For reference to built-in function, return enclosing call.
+				path = path[1:] // ascend to enclosing function call
+				continue
+
+			case *types.Nil:
+				return path, actionExpr
+			}
+
+			// No object.
+			switch path[1].(type) {
+			case *ast.SelectorExpr:
+				// Return enclosing selector expression.
+				return path[1:], actionExpr
+
+			case *ast.Field:
+				// TODO(adonovan): test this.
+				// e.g. all f in:
+				//  struct { f, g int }
+				//  interface { f() }
+				//  func (f T) method(f, g int) (f, g bool)
+				//
+				// switch path[3].(type) {
+				// case *ast.FuncDecl:
+				// case *ast.StructType:
+				// case *ast.InterfaceType:
+				// }
+				//
+				// return path[1:], actionExpr
+				//
+				// Unclear what to do with these.
+				// Struct.Fields             -- field
+				// Interface.Methods         -- field
+				// FuncType.{Params.Results} -- actionExpr
+				// FuncDecl.Recv             -- actionExpr
+
+			case *ast.File:
+				// 'package foo'
+				return path, actionPackage
+
+			case *ast.ImportSpec:
+				return path[1:], actionPackage
+
+			default:
+				// e.g. blank identifier
+				// or y in "switch y := x.(type)"
+				// or code in a _test.go file that's not part of the package.
+				return path, actionUnknown
+			}
+
+		case *ast.StarExpr:
+			if pkginfo.Types[n].IsType() {
+				return path, actionType
+			}
+			return path, actionExpr
+
+		case ast.Expr:
+			// All Expr but {BasicLit,Ident,StarExpr} are
+			// "true" expressions that evaluate to a value.
+			return path, actionExpr
+		}
+
+		// Ascend to parent.
+		path = path[1:]
+	}
+
+	return nil, actionUnknown // unreachable
+}
+
+func describeValue(qpos *queryPos, path []ast.Node) (*describeValueResult, error) {
+	var expr ast.Expr
+	var obj types.Object
+	switch n := path[0].(type) {
+	case *ast.ValueSpec:
+		// ambiguous ValueSpec containing multiple names
+		return nil, fmt.Errorf("multiple value specification")
+	case *ast.Ident:
+		obj = qpos.info.ObjectOf(n)
+		expr = n
+	case ast.Expr:
+		expr = n
+	default:
+		// TODO(adonovan): is this reachable?
+		return nil, fmt.Errorf("unexpected AST for expr: %T", n)
+	}
+
+	typ := qpos.info.TypeOf(expr)
+	if typ == nil {
+		typ = types.Typ[types.Invalid]
+	}
+	constVal := qpos.info.Types[expr].Value
+	if c, ok := obj.(*types.Const); ok {
+		constVal = c.Val()
+	}
+
+	return &describeValueResult{
+		qpos:     qpos,
+		expr:     expr,
+		typ:      typ,
+		constVal: constVal,
+		obj:      obj,
+		methods:  accessibleMethods(typ, qpos.info.Pkg),
+		fields:   accessibleFields(typ, qpos.info.Pkg),
+	}, nil
+}
+
+type describeValueResult struct {
+	qpos     *queryPos
+	expr     ast.Expr     // query node
+	typ      types.Type   // type of expression
+	constVal exact.Value  // value of expression, if constant
+	obj      types.Object // var/func/const object, if expr was Ident
+	methods  []*types.Selection
+	fields   []describeField
+}
+
+func (r *describeValueResult) PrintPlain(printf printfFunc) {
+	var prefix, suffix string
+	if r.constVal != nil {
+		suffix = fmt.Sprintf(" of value %s", r.constVal)
+	}
+	switch obj := r.obj.(type) {
+	case *types.Func:
+		if recv := obj.Type().(*types.Signature).Recv(); recv != nil {
+			if _, ok := recv.Type().Underlying().(*types.Interface); ok {
+				prefix = "interface method "
+			} else {
+				prefix = "method "
+			}
+		}
+	}
+
+	// Describe the expression.
+	if r.obj != nil {
+		if r.obj.Pos() == r.expr.Pos() {
+			// defining ident
+			printf(r.expr, "definition of %s%s%s", prefix, r.qpos.objectString(r.obj), suffix)
+		} else {
+			// referring ident
+			printf(r.expr, "reference to %s%s%s", prefix, r.qpos.objectString(r.obj), suffix)
+			if def := r.obj.Pos(); def != token.NoPos {
+				printf(def, "defined here")
+			}
+		}
+	} else {
+		desc := astutil.NodeDescription(r.expr)
+		if suffix != "" {
+			// constant expression
+			printf(r.expr, "%s%s", desc, suffix)
+		} else {
+			// non-constant expression
+			printf(r.expr, "%s of type %s", desc, r.qpos.typeString(r.typ))
+		}
+	}
+
+	printMethods(printf, r.expr, r.methods)
+	printFields(printf, r.expr, r.fields)
+}
+
+func (r *describeValueResult) JSON(fset *token.FileSet) []byte {
+	var value, objpos string
+	if r.constVal != nil {
+		value = r.constVal.String()
+	}
+	if r.obj != nil {
+		objpos = fset.Position(r.obj.Pos()).String()
+	}
+
+	return toJSON(&serial.Describe{
+		Desc:   astutil.NodeDescription(r.expr),
+		Pos:    fset.Position(r.expr.Pos()).String(),
+		Detail: "value",
+		Value: &serial.DescribeValue{
+			Type:   r.qpos.typeString(r.typ),
+			Value:  value,
+			ObjPos: objpos,
+		},
+	})
+}
+
+// ---- TYPE ------------------------------------------------------------
+
+func describeType(qpos *queryPos, path []ast.Node) (*describeTypeResult, error) {
+	var description string
+	var typ types.Type
+	switch n := path[0].(type) {
+	case *ast.Ident:
+		obj := qpos.info.ObjectOf(n).(*types.TypeName)
+		typ = obj.Type()
+		if isAlias(obj) {
+			description = "alias of "
+		} else if obj.Pos() == n.Pos() {
+			description = "definition of " // (Named type)
+		} else if _, ok := typ.(*types.Basic); ok {
+			description = "reference to built-in "
+		} else {
+			description = "reference to " // (Named type)
+		}
+
+	case ast.Expr:
+		typ = qpos.info.TypeOf(n)
+
+	default:
+		// Unreachable?
+		return nil, fmt.Errorf("unexpected AST for type: %T", n)
+	}
+
+	description = description + "type " + qpos.typeString(typ)
+
+	// Show sizes for structs and named types (it's fairly obvious for others).
+	switch typ.(type) {
+	case *types.Named, *types.Struct:
+		szs := types.StdSizes{WordSize: 8, MaxAlign: 8} // assume amd64
+		description = fmt.Sprintf("%s (size %d, align %d)", description,
+			szs.Sizeof(typ), szs.Alignof(typ))
+	}
+
+	return &describeTypeResult{
+		qpos:        qpos,
+		node:        path[0],
+		description: description,
+		typ:         typ,
+		methods:     accessibleMethods(typ, qpos.info.Pkg),
+		fields:      accessibleFields(typ, qpos.info.Pkg),
+	}, nil
+}
+
+type describeTypeResult struct {
+	qpos        *queryPos
+	node        ast.Node
+	description string
+	typ         types.Type
+	methods     []*types.Selection
+	fields      []describeField
+}
+
+type describeField struct {
+	implicits []*types.Named
+	field     *types.Var
+}
+
+func printMethods(printf printfFunc, node ast.Node, methods []*types.Selection) {
+	if len(methods) > 0 {
+		printf(node, "Methods:")
+	}
+	for _, meth := range methods {
+		// Print the method type relative to the package
+		// in which it was defined, not the query package,
+		printf(meth.Obj(), "\t%s",
+			types.SelectionString(meth, types.RelativeTo(meth.Obj().Pkg())))
+	}
+}
+
+func printFields(printf printfFunc, node ast.Node, fields []describeField) {
+	if len(fields) > 0 {
+		printf(node, "Fields:")
+	}
+
+	// Align the names and the types (requires two passes).
+	var width int
+	var names []string
+	for _, f := range fields {
+		var buf bytes.Buffer
+		for _, fld := range f.implicits {
+			buf.WriteString(fld.Obj().Name())
+			buf.WriteByte('.')
+		}
+		buf.WriteString(f.field.Name())
+		name := buf.String()
+		if n := utf8.RuneCountInString(name); n > width {
+			width = n
+		}
+		names = append(names, name)
+	}
+
+	for i, f := range fields {
+		// Print the field type relative to the package
+		// in which it was defined, not the query package,
+		printf(f.field, "\t%*s %s", -width, names[i],
+			types.TypeString(f.field.Type(), types.RelativeTo(f.field.Pkg())))
+	}
+}
+
+func (r *describeTypeResult) PrintPlain(printf printfFunc) {
+	printf(r.node, "%s", r.description)
+
+	// Show the underlying type for a reference to a named type.
+	if nt, ok := r.typ.(*types.Named); ok && r.node.Pos() != nt.Obj().Pos() {
+		// TODO(adonovan): improve display of complex struct/interface types.
+		printf(nt.Obj(), "defined as %s", r.qpos.typeString(nt.Underlying()))
+	}
+
+	printMethods(printf, r.node, r.methods)
+	if len(r.methods) == 0 {
+		// Only report null result for type kinds
+		// capable of bearing methods.
+		switch r.typ.(type) {
+		case *types.Interface, *types.Struct, *types.Named:
+			printf(r.node, "No methods.")
+		}
+	}
+
+	printFields(printf, r.node, r.fields)
+}
+
+func (r *describeTypeResult) JSON(fset *token.FileSet) []byte {
+	var namePos, nameDef string
+	if nt, ok := r.typ.(*types.Named); ok {
+		namePos = fset.Position(nt.Obj().Pos()).String()
+		nameDef = nt.Underlying().String()
+	}
+	return toJSON(&serial.Describe{
+		Desc:   r.description,
+		Pos:    fset.Position(r.node.Pos()).String(),
+		Detail: "type",
+		Type: &serial.DescribeType{
+			Type:    r.qpos.typeString(r.typ),
+			NamePos: namePos,
+			NameDef: nameDef,
+			Methods: methodsToSerial(r.qpos.info.Pkg, r.methods, fset),
+		},
+	})
+}
+
+// ---- PACKAGE ------------------------------------------------------------
+
+func describePackage(qpos *queryPos, path []ast.Node) (*describePackageResult, error) {
+	var description string
+	var pkg *types.Package
+	switch n := path[0].(type) {
+	case *ast.ImportSpec:
+		var obj types.Object
+		if n.Name != nil {
+			obj = qpos.info.Defs[n.Name]
+		} else {
+			obj = qpos.info.Implicits[n]
+		}
+		pkgname, _ := obj.(*types.PkgName)
+		if pkgname == nil {
+			return nil, fmt.Errorf("can't import package %s", n.Path.Value)
+		}
+		pkg = pkgname.Imported()
+		description = fmt.Sprintf("import of package %q", pkg.Path())
+
+	case *ast.Ident:
+		if _, isDef := path[1].(*ast.File); isDef {
+			// e.g. package id
+			pkg = qpos.info.Pkg
+			description = fmt.Sprintf("definition of package %q", pkg.Path())
+		} else {
+			// e.g. import id "..."
+			//  or  id.F()
+			pkg = qpos.info.ObjectOf(n).(*types.PkgName).Imported()
+			description = fmt.Sprintf("reference to package %q", pkg.Path())
+		}
+
+	default:
+		// Unreachable?
+		return nil, fmt.Errorf("unexpected AST for package: %T", n)
+	}
+
+	var members []*describeMember
+	// NB: "unsafe" has no types.Package
+	if pkg != nil {
+		// Enumerate the accessible package members
+		// in lexicographic order.
+		for _, name := range pkg.Scope().Names() {
+			if pkg == qpos.info.Pkg || ast.IsExported(name) {
+				mem := pkg.Scope().Lookup(name)
+				var methods []*types.Selection
+				if mem, ok := mem.(*types.TypeName); ok {
+					methods = accessibleMethods(mem.Type(), qpos.info.Pkg)
+				}
+				members = append(members, &describeMember{
+					mem,
+					methods,
+				})
+
+			}
+		}
+	}
+
+	return &describePackageResult{qpos.fset, path[0], description, pkg, members}, nil
+}
+
+type describePackageResult struct {
+	fset        *token.FileSet
+	node        ast.Node
+	description string
+	pkg         *types.Package
+	members     []*describeMember // in lexicographic name order
+}
+
+type describeMember struct {
+	obj     types.Object
+	methods []*types.Selection // in types.MethodSet order
+}
+
+func (r *describePackageResult) PrintPlain(printf printfFunc) {
+	printf(r.node, "%s", r.description)
+
+	// Compute max width of name "column".
+	maxname := 0
+	for _, mem := range r.members {
+		if l := len(mem.obj.Name()); l > maxname {
+			maxname = l
+		}
+	}
+
+	for _, mem := range r.members {
+		printf(mem.obj, "\t%s", formatMember(mem.obj, maxname))
+		for _, meth := range mem.methods {
+			printf(meth.Obj(), "\t\t%s", types.SelectionString(meth, types.RelativeTo(r.pkg)))
+		}
+	}
+}
+
+func formatMember(obj types.Object, maxname int) string {
+	qualifier := types.RelativeTo(obj.Pkg())
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "%-5s %-*s", tokenOf(obj), maxname, obj.Name())
+	switch obj := obj.(type) {
+	case *types.Const:
+		fmt.Fprintf(&buf, " %s = %s", types.TypeString(obj.Type(), qualifier), obj.Val())
+
+	case *types.Func:
+		fmt.Fprintf(&buf, " %s", types.TypeString(obj.Type(), qualifier))
+
+	case *types.TypeName:
+		typ := obj.Type()
+		if isAlias(obj) {
+			buf.WriteString(" = ")
+		} else {
+			buf.WriteByte(' ')
+			typ = typ.Underlying()
+		}
+		var typestr string
+		// Abbreviate long aggregate type names.
+		switch typ := typ.(type) {
+		case *types.Interface:
+			if typ.NumMethods() > 1 {
+				typestr = "interface{...}"
+			}
+		case *types.Struct:
+			if typ.NumFields() > 1 {
+				typestr = "struct{...}"
+			}
+		}
+		if typestr == "" {
+			typestr = types.TypeString(typ, qualifier)
+		}
+		buf.WriteString(typestr)
+
+	case *types.Var:
+		fmt.Fprintf(&buf, " %s", types.TypeString(obj.Type(), qualifier))
+	}
+	return buf.String()
+}
+
+func (r *describePackageResult) JSON(fset *token.FileSet) []byte {
+	var members []*serial.DescribeMember
+	for _, mem := range r.members {
+		obj := mem.obj
+		typ := obj.Type()
+		var val string
+		var alias string
+		switch obj := obj.(type) {
+		case *types.Const:
+			val = obj.Val().String()
+		case *types.TypeName:
+			if isAlias(obj) {
+				alias = "= " // kludgy
+			} else {
+				typ = typ.Underlying()
+			}
+		}
+		members = append(members, &serial.DescribeMember{
+			Name:    obj.Name(),
+			Type:    alias + typ.String(),
+			Value:   val,
+			Pos:     fset.Position(obj.Pos()).String(),
+			Kind:    tokenOf(obj),
+			Methods: methodsToSerial(r.pkg, mem.methods, fset),
+		})
+	}
+	return toJSON(&serial.Describe{
+		Desc:   r.description,
+		Pos:    fset.Position(r.node.Pos()).String(),
+		Detail: "package",
+		Package: &serial.DescribePackage{
+			Path:    r.pkg.Path(),
+			Members: members,
+		},
+	})
+}
+
+func tokenOf(o types.Object) string {
+	switch o.(type) {
+	case *types.Func:
+		return "func"
+	case *types.Var:
+		return "var"
+	case *types.TypeName:
+		return "type"
+	case *types.Const:
+		return "const"
+	case *types.PkgName:
+		return "package"
+	case *types.Builtin:
+		return "builtin" // e.g. when describing package "unsafe"
+	case *types.Nil:
+		return "nil"
+	case *types.Label:
+		return "label"
+	}
+	panic(o)
+}
+
+// ---- STATEMENT ------------------------------------------------------------
+
+func describeStmt(qpos *queryPos, path []ast.Node) (*describeStmtResult, error) {
+	var description string
+	switch n := path[0].(type) {
+	case *ast.Ident:
+		if qpos.info.Defs[n] != nil {
+			description = "labelled statement"
+		} else {
+			description = "reference to labelled statement"
+		}
+
+	default:
+		// Nothing much to say about statements.
+		description = astutil.NodeDescription(n)
+	}
+	return &describeStmtResult{qpos.fset, path[0], description}, nil
+}
+
+type describeStmtResult struct {
+	fset        *token.FileSet
+	node        ast.Node
+	description string
+}
+
+func (r *describeStmtResult) PrintPlain(printf printfFunc) {
+	printf(r.node, "%s", r.description)
+}
+
+func (r *describeStmtResult) JSON(fset *token.FileSet) []byte {
+	return toJSON(&serial.Describe{
+		Desc:   r.description,
+		Pos:    fset.Position(r.node.Pos()).String(),
+		Detail: "unknown",
+	})
+}
+
+// ------------------- Utilities -------------------
+
+// pathToString returns a string containing the concrete types of the
+// nodes in path.
+func pathToString(path []ast.Node) string {
+	var buf bytes.Buffer
+	fmt.Fprint(&buf, "[")
+	for i, n := range path {
+		if i > 0 {
+			fmt.Fprint(&buf, " ")
+		}
+		fmt.Fprint(&buf, strings.TrimPrefix(fmt.Sprintf("%T", n), "*ast."))
+	}
+	fmt.Fprint(&buf, "]")
+	return buf.String()
+}
+
+func accessibleMethods(t types.Type, from *types.Package) []*types.Selection {
+	var methods []*types.Selection
+	for _, meth := range typeutil.IntuitiveMethodSet(t, nil) {
+		if isAccessibleFrom(meth.Obj(), from) {
+			methods = append(methods, meth)
+		}
+	}
+	return methods
+}
+
+// accessibleFields returns the set of accessible
+// field selections on a value of type recv.
+func accessibleFields(recv types.Type, from *types.Package) []describeField {
+	wantField := func(f *types.Var) bool {
+		if !isAccessibleFrom(f, from) {
+			return false
+		}
+		// Check that the field is not shadowed.
+		obj, _, _ := types.LookupFieldOrMethod(recv, true, f.Pkg(), f.Name())
+		return obj == f
+	}
+
+	var fields []describeField
+	var visit func(t types.Type, stack []*types.Named)
+	visit = func(t types.Type, stack []*types.Named) {
+		tStruct, ok := deref(t).Underlying().(*types.Struct)
+		if !ok {
+			return
+		}
+	fieldloop:
+		for i := 0; i < tStruct.NumFields(); i++ {
+			f := tStruct.Field(i)
+
+			// Handle recursion through anonymous fields.
+			if f.Anonymous() {
+				tf := f.Type()
+				if ptr, ok := tf.(*types.Pointer); ok {
+					tf = ptr.Elem()
+				}
+				if named, ok := tf.(*types.Named); ok { // (be defensive)
+					// If we've already visited this named type
+					// on this path, break the cycle.
+					for _, x := range stack {
+						if x == named {
+							continue fieldloop
+						}
+					}
+					visit(f.Type(), append(stack, named))
+				}
+			}
+
+			// Save accessible fields.
+			if wantField(f) {
+				fields = append(fields, describeField{
+					implicits: append([]*types.Named(nil), stack...),
+					field:     f,
+				})
+			}
+		}
+	}
+	visit(recv, nil)
+
+	return fields
+}
+
+func isAccessibleFrom(obj types.Object, pkg *types.Package) bool {
+	return ast.IsExported(obj.Name()) || obj.Pkg() == pkg
+}
+
+func methodsToSerial(this *types.Package, methods []*types.Selection, fset *token.FileSet) []serial.DescribeMethod {
+	qualifier := types.RelativeTo(this)
+	var jmethods []serial.DescribeMethod
+	for _, meth := range methods {
+		var ser serial.DescribeMethod
+		if meth != nil { // may contain nils when called by implements (on a method)
+			ser = serial.DescribeMethod{
+				Name: types.SelectionString(meth, qualifier),
+				Pos:  fset.Position(meth.Obj().Pos()).String(),
+			}
+		}
+		jmethods = append(jmethods, ser)
+	}
+	return jmethods
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/freevars.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/freevars.go
new file mode 100644
index 00000000..a36d1f80
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/freevars.go
@@ -0,0 +1,223 @@
+// 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 main
+
+import (
+	"bytes"
+	"go/ast"
+	"go/printer"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/loader"
+)
+
+// freevars displays the lexical (not package-level) free variables of
+// the selection.
+//
+// It treats A.B.C as a separate variable from A to reveal the parts
+// of an aggregate type that are actually needed.
+// This aids refactoring.
+//
+// TODO(adonovan): optionally display the free references to
+// file/package scope objects, and to objects from other packages.
+// Depending on where the resulting function abstraction will go,
+// these might be interesting.  Perhaps group the results into three
+// bands.
+//
+func freevars(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+	allowErrors(&lconf)
+
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := lconf.Load()
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	file := qpos.path[len(qpos.path)-1] // the enclosing file
+	fileScope := qpos.info.Scopes[file]
+	pkgScope := fileScope.Parent()
+
+	// The id and sel functions return non-nil if they denote an
+	// object o or selection o.x.y that is referenced by the
+	// selection but defined neither within the selection nor at
+	// file scope, i.e. it is in the lexical environment.
+	var id func(n *ast.Ident) types.Object
+	var sel func(n *ast.SelectorExpr) types.Object
+
+	sel = func(n *ast.SelectorExpr) types.Object {
+		switch x := unparen(n.X).(type) {
+		case *ast.SelectorExpr:
+			return sel(x)
+		case *ast.Ident:
+			return id(x)
+		}
+		return nil
+	}
+
+	id = func(n *ast.Ident) types.Object {
+		obj := qpos.info.Uses[n]
+		if obj == nil {
+			return nil // not a reference
+		}
+		if _, ok := obj.(*types.PkgName); ok {
+			return nil // imported package
+		}
+		if !(file.Pos() <= obj.Pos() && obj.Pos() <= file.End()) {
+			return nil // not defined in this file
+		}
+		scope := obj.Parent()
+		if scope == nil {
+			return nil // e.g. interface method, struct field
+		}
+		if scope == fileScope || scope == pkgScope {
+			return nil // defined at file or package scope
+		}
+		if qpos.start <= obj.Pos() && obj.Pos() <= qpos.end {
+			return nil // defined within selection => not free
+		}
+		return obj
+	}
+
+	// Maps each reference that is free in the selection
+	// to the object it refers to.
+	// The map de-duplicates repeated references.
+	refsMap := make(map[string]freevarsRef)
+
+	// Visit all the identifiers in the selected ASTs.
+	ast.Inspect(qpos.path[0], func(n ast.Node) bool {
+		if n == nil {
+			return true // popping DFS stack
+		}
+
+		// Is this node contained within the selection?
+		// (freevars permits inexact selections,
+		// like two stmts in a block.)
+		if qpos.start <= n.Pos() && n.End() <= qpos.end {
+			var obj types.Object
+			var prune bool
+			switch n := n.(type) {
+			case *ast.Ident:
+				obj = id(n)
+
+			case *ast.SelectorExpr:
+				obj = sel(n)
+				prune = true
+			}
+
+			if obj != nil {
+				var kind string
+				switch obj.(type) {
+				case *types.Var:
+					kind = "var"
+				case *types.Func:
+					kind = "func"
+				case *types.TypeName:
+					kind = "type"
+				case *types.Const:
+					kind = "const"
+				case *types.Label:
+					kind = "label"
+				default:
+					panic(obj)
+				}
+
+				typ := qpos.info.TypeOf(n.(ast.Expr))
+				ref := freevarsRef{kind, printNode(lprog.Fset, n), typ, obj}
+				refsMap[ref.ref] = ref
+
+				if prune {
+					return false // don't descend
+				}
+			}
+		}
+
+		return true // descend
+	})
+
+	refs := make([]freevarsRef, 0, len(refsMap))
+	for _, ref := range refsMap {
+		refs = append(refs, ref)
+	}
+	sort.Sort(byRef(refs))
+
+	q.Output(lprog.Fset, &freevarsResult{
+		qpos: qpos,
+		refs: refs,
+	})
+	return nil
+}
+
+type freevarsResult struct {
+	qpos *queryPos
+	refs []freevarsRef
+}
+
+type freevarsRef struct {
+	kind string
+	ref  string
+	typ  types.Type
+	obj  types.Object
+}
+
+func (r *freevarsResult) PrintPlain(printf printfFunc) {
+	if len(r.refs) == 0 {
+		printf(r.qpos, "No free identifiers.")
+	} else {
+		printf(r.qpos, "Free identifiers:")
+		qualifier := types.RelativeTo(r.qpos.info.Pkg)
+		for _, ref := range r.refs {
+			// Avoid printing "type T T".
+			var typstr string
+			if ref.kind != "type" && ref.kind != "label" {
+				typstr = " " + types.TypeString(ref.typ, qualifier)
+			}
+			printf(ref.obj, "%s %s%s", ref.kind, ref.ref, typstr)
+		}
+	}
+}
+
+func (r *freevarsResult) JSON(fset *token.FileSet) []byte {
+	var buf bytes.Buffer
+	for i, ref := range r.refs {
+		if i > 0 {
+			buf.WriteByte('\n')
+		}
+		buf.Write(toJSON(serial.FreeVar{
+			Pos:  fset.Position(ref.obj.Pos()).String(),
+			Kind: ref.kind,
+			Ref:  ref.ref,
+			Type: ref.typ.String(),
+		}))
+	}
+	return buf.Bytes()
+}
+
+// -------- utils --------
+
+type byRef []freevarsRef
+
+func (p byRef) Len() int           { return len(p) }
+func (p byRef) Less(i, j int) bool { return p[i].ref < p[j].ref }
+func (p byRef) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+// printNode returns the pretty-printed syntax of n.
+func printNode(fset *token.FileSet, n ast.Node) string {
+	var buf bytes.Buffer
+	printer.Fprint(&buf, fset, n)
+	return buf.String()
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/guru.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/guru.go
new file mode 100644
index 00000000..8dea3b53
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/guru.go
@@ -0,0 +1,401 @@
+// 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.
+
+package main
+
+// TODO(adonovan): new queries
+// - show all statements that may update the selected lvalue
+//   (local, global, field, etc).
+// - show all places where an object of type T is created
+//   (&T{}, var t T, new(T), new(struct{array [3]T}), etc.
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"log"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/pointer"
+	"golang.org/x/tools/go/ssa"
+)
+
+type printfFunc func(pos interface{}, format string, args ...interface{})
+
+// A QueryResult is an item of output.  Each query produces a stream of
+// query results, calling Query.Output for each one.
+type QueryResult interface {
+	// JSON returns the QueryResult in JSON form.
+	JSON(fset *token.FileSet) []byte
+
+	// PrintPlain prints the QueryResult in plain text form.
+	// The implementation calls printfFunc to print each line of output.
+	PrintPlain(printf printfFunc)
+}
+
+// A QueryPos represents the position provided as input to a query:
+// a textual extent in the program's source code, the AST node it
+// corresponds to, and the package to which it belongs.
+// Instances are created by parseQueryPos.
+type queryPos struct {
+	fset       *token.FileSet
+	start, end token.Pos           // source extent of query
+	path       []ast.Node          // AST path from query node to root of ast.File
+	exact      bool                // 2nd result of PathEnclosingInterval
+	info       *loader.PackageInfo // type info for the queried package (nil for fastQueryPos)
+}
+
+// TypeString prints type T relative to the query position.
+func (qpos *queryPos) typeString(T types.Type) string {
+	return types.TypeString(T, types.RelativeTo(qpos.info.Pkg))
+}
+
+// ObjectString prints object obj relative to the query position.
+func (qpos *queryPos) objectString(obj types.Object) string {
+	return types.ObjectString(obj, types.RelativeTo(qpos.info.Pkg))
+}
+
+// A Query specifies a single guru query.
+type Query struct {
+	Pos   string         // query position
+	Build *build.Context // package loading configuration
+
+	// pointer analysis options
+	Scope      []string  // main packages in (*loader.Config).FromArgs syntax
+	PTALog     io.Writer // (optional) pointer-analysis log file
+	Reflection bool      // model reflection soundly (currently slow).
+
+	// result-printing function, safe for concurrent use
+	Output func(*token.FileSet, QueryResult)
+}
+
+// Run runs an guru query and populates its Fset and Result.
+func Run(mode string, q *Query) error {
+	switch mode {
+	case "callees":
+		return callees(q)
+	case "callers":
+		return callers(q)
+	case "callstack":
+		return callstack(q)
+	case "peers":
+		return peers(q)
+	case "pointsto":
+		return pointsto(q)
+	case "whicherrs":
+		return whicherrs(q)
+	case "definition":
+		return definition(q)
+	case "describe":
+		return describe(q)
+	case "freevars":
+		return freevars(q)
+	case "implements":
+		return implements(q)
+	case "referrers":
+		return referrers(q)
+	case "what":
+		return what(q)
+	default:
+		return fmt.Errorf("invalid mode: %q", mode)
+	}
+}
+
+func setPTAScope(lconf *loader.Config, scope []string) error {
+	pkgs := buildutil.ExpandPatterns(lconf.Build, scope)
+	if len(pkgs) == 0 {
+		return fmt.Errorf("no packages specified for pointer analysis scope")
+	}
+	// The value of each entry in pkgs is true,
+	// giving ImportWithTests (not Import) semantics.
+	lconf.ImportPkgs = pkgs
+	return nil
+}
+
+// Create a pointer.Config whose scope is the initial packages of lprog
+// and their dependencies.
+func setupPTA(prog *ssa.Program, lprog *loader.Program, ptaLog io.Writer, reflection bool) (*pointer.Config, error) {
+	// For each initial package (specified on the command line),
+	// if it has a main function, analyze that,
+	// otherwise analyze its tests, if any.
+	var mains []*ssa.Package
+	for _, info := range lprog.InitialPackages() {
+		p := prog.Package(info.Pkg)
+
+		// Add package to the pointer analysis scope.
+		if p.Pkg.Name() == "main" && p.Func("main") != nil {
+			mains = append(mains, p)
+		} else if main := prog.CreateTestMainPackage(p); main != nil {
+			mains = append(mains, main)
+		}
+	}
+	if mains == nil {
+		return nil, fmt.Errorf("analysis scope has no main and no tests")
+	}
+	return &pointer.Config{
+		Log:        ptaLog,
+		Reflection: reflection,
+		Mains:      mains,
+	}, nil
+}
+
+// importQueryPackage finds the package P containing the
+// query position and tells conf to import it.
+// It returns the package's path.
+func importQueryPackage(pos string, conf *loader.Config) (string, error) {
+	fqpos, err := fastQueryPos(conf.Build, pos)
+	if err != nil {
+		return "", err // bad query
+	}
+	filename := fqpos.fset.File(fqpos.start).Name()
+
+	_, importPath, err := guessImportPath(filename, conf.Build)
+	if err != nil {
+		// Can't find GOPATH dir.
+		// Treat the query file as its own package.
+		importPath = "command-line-arguments"
+		conf.CreateFromFilenames(importPath, filename)
+	} else {
+		// Check that it's possible to load the queried package.
+		// (e.g. guru tests contain different 'package' decls in same dir.)
+		// Keep consistent with logic in loader/util.go!
+		cfg2 := *conf.Build
+		cfg2.CgoEnabled = false
+		bp, err := cfg2.Import(importPath, "", 0)
+		if err != nil {
+			return "", err // no files for package
+		}
+
+		switch pkgContainsFile(bp, filename) {
+		case 'T':
+			conf.ImportWithTests(importPath)
+		case 'X':
+			conf.ImportWithTests(importPath)
+			importPath += "_test" // for TypeCheckFuncBodies
+		case 'G':
+			conf.Import(importPath)
+		default:
+			// This happens for ad-hoc packages like
+			// $GOROOT/src/net/http/triv.go.
+			return "", fmt.Errorf("package %q doesn't contain file %s",
+				importPath, filename)
+		}
+	}
+
+	conf.TypeCheckFuncBodies = func(p string) bool { return p == importPath }
+
+	return importPath, nil
+}
+
+// pkgContainsFile reports whether file was among the packages Go
+// files, Test files, eXternal test files, or not found.
+func pkgContainsFile(bp *build.Package, filename string) byte {
+	for i, files := range [][]string{bp.GoFiles, bp.TestGoFiles, bp.XTestGoFiles} {
+		for _, file := range files {
+			if sameFile(filepath.Join(bp.Dir, file), filename) {
+				return "GTX"[i]
+			}
+		}
+	}
+	return 0 // not found
+}
+
+// ParseQueryPos parses the source query position pos and returns the
+// AST node of the loaded program lprog that it identifies.
+// If needExact, it must identify a single AST subtree;
+// this is appropriate for queries that allow fairly arbitrary syntax,
+// e.g. "describe".
+//
+func parseQueryPos(lprog *loader.Program, pos string, needExact bool) (*queryPos, error) {
+	filename, startOffset, endOffset, err := parsePos(pos)
+	if err != nil {
+		return nil, err
+	}
+
+	// Find the named file among those in the loaded program.
+	var file *token.File
+	lprog.Fset.Iterate(func(f *token.File) bool {
+		if sameFile(filename, f.Name()) {
+			file = f
+			return false // done
+		}
+		return true // continue
+	})
+	if file == nil {
+		return nil, fmt.Errorf("file %s not found in loaded program", filename)
+	}
+
+	start, end, err := fileOffsetToPos(file, startOffset, endOffset)
+	if err != nil {
+		return nil, err
+	}
+	info, path, exact := lprog.PathEnclosingInterval(start, end)
+	if path == nil {
+		return nil, fmt.Errorf("no syntax here")
+	}
+	if needExact && !exact {
+		return nil, fmt.Errorf("ambiguous selection within %s", astutil.NodeDescription(path[0]))
+	}
+	return &queryPos{lprog.Fset, start, end, path, exact, info}, nil
+}
+
+// ---------- Utilities ----------
+
+// loadWithSoftErrors calls lconf.Load, suppressing "soft" errors.  (See Go issue 16530.)
+// TODO(adonovan): Once the loader has an option to allow soft errors,
+// replace calls to loadWithSoftErrors with loader calls with that parameter.
+func loadWithSoftErrors(lconf *loader.Config) (*loader.Program, error) {
+	lconf.AllowErrors = true
+
+	// Ideally we would just return conf.Load() here, but go/types
+	// reports certain "soft" errors that gc does not (Go issue 14596).
+	// As a workaround, we set AllowErrors=true and then duplicate
+	// the loader's error checking but allow soft errors.
+	// It would be nice if the loader API permitted "AllowErrors: soft".
+	prog, err := lconf.Load()
+	if err != nil {
+		return nil, err
+	}
+	var errpkgs []string
+	// Report hard errors in indirectly imported packages.
+	for _, info := range prog.AllPackages {
+		if containsHardErrors(info.Errors) {
+			errpkgs = append(errpkgs, info.Pkg.Path())
+		} else {
+			// Enable SSA construction for packages containing only soft errors.
+			info.TransitivelyErrorFree = true
+		}
+	}
+	if errpkgs != nil {
+		var more string
+		if len(errpkgs) > 3 {
+			more = fmt.Sprintf(" and %d more", len(errpkgs)-3)
+			errpkgs = errpkgs[:3]
+		}
+		return nil, fmt.Errorf("couldn't load packages due to errors: %s%s",
+			strings.Join(errpkgs, ", "), more)
+	}
+	return prog, err
+}
+
+func containsHardErrors(errors []error) bool {
+	for _, err := range errors {
+		if err, ok := err.(types.Error); ok && err.Soft {
+			continue
+		}
+		return true
+	}
+	return false
+}
+
+// allowErrors causes type errors to be silently ignored.
+// (Not suitable if SSA construction follows.)
+func allowErrors(lconf *loader.Config) {
+	ctxt := *lconf.Build // copy
+	ctxt.CgoEnabled = false
+	lconf.Build = &ctxt
+	lconf.AllowErrors = true
+	// AllErrors makes the parser always return an AST instead of
+	// bailing out after 10 errors and returning an empty ast.File.
+	lconf.ParserMode = parser.AllErrors
+	lconf.TypeChecker.Error = func(err error) {}
+}
+
+// ptrAnalysis runs the pointer analysis and returns its result.
+func ptrAnalysis(conf *pointer.Config) *pointer.Result {
+	result, err := pointer.Analyze(conf)
+	if err != nil {
+		panic(err) // pointer analysis internal error
+	}
+	return result
+}
+
+func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
+
+// deref returns a pointer's element type; otherwise it returns typ.
+func deref(typ types.Type) types.Type {
+	if p, ok := typ.Underlying().(*types.Pointer); ok {
+		return p.Elem()
+	}
+	return typ
+}
+
+// fprintf prints to w a message of the form "location: message\n"
+// where location is derived from pos.
+//
+// pos must be one of:
+//    - a token.Pos, denoting a position
+//    - an ast.Node, denoting an interval
+//    - anything with a Pos() method:
+//         ssa.Member, ssa.Value, ssa.Instruction, types.Object, pointer.Label, etc.
+//    - a QueryPos, denoting the extent of the user's query.
+//    - nil, meaning no position at all.
+//
+// The output format is is compatible with the 'gnu'
+// compilation-error-regexp in Emacs' compilation mode.
+//
+func fprintf(w io.Writer, fset *token.FileSet, pos interface{}, format string, args ...interface{}) {
+	var start, end token.Pos
+	switch pos := pos.(type) {
+	case ast.Node:
+		start = pos.Pos()
+		end = pos.End()
+	case token.Pos:
+		start = pos
+		end = start
+	case *types.PkgName:
+		// The Pos of most PkgName objects does not coincide with an identifier,
+		// so we suppress the usual start+len(name) heuristic for types.Objects.
+		start = pos.Pos()
+		end = start
+	case types.Object:
+		start = pos.Pos()
+		end = start + token.Pos(len(pos.Name())) // heuristic
+	case interface {
+		Pos() token.Pos
+	}:
+		start = pos.Pos()
+		end = start
+	case *queryPos:
+		start = pos.start
+		end = pos.end
+	case nil:
+		// no-op
+	default:
+		panic(fmt.Sprintf("invalid pos: %T", pos))
+	}
+
+	if sp := fset.Position(start); start == end {
+		// (prints "-: " for token.NoPos)
+		fmt.Fprintf(w, "%s: ", sp)
+	} else {
+		ep := fset.Position(end)
+		// The -1 below is a concession to Emacs's broken use of
+		// inclusive (not half-open) intervals.
+		// Other editors may not want it.
+		// TODO(adonovan): add an -editor=vim|emacs|acme|auto
+		// flag; auto uses EMACS=t / VIM=... / etc env vars.
+		fmt.Fprintf(w, "%s:%d.%d-%d.%d: ",
+			sp.Filename, sp.Line, sp.Column, ep.Line, ep.Column-1)
+	}
+	fmt.Fprintf(w, format, args...)
+	io.WriteString(w, "\n")
+}
+
+func toJSON(x interface{}) []byte {
+	b, err := json.MarshalIndent(x, "", "\t")
+	if err != nil {
+		log.Fatalf("JSON error: %v", err)
+	}
+	return b
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/implements.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/implements.go
new file mode 100644
index 00000000..2d89b2d7
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/implements.go
@@ -0,0 +1,364 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"reflect"
+	"sort"
+	"strings"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/types/typeutil"
+	"golang.org/x/tools/refactor/importgraph"
+)
+
+// Implements displays the "implements" relation as it pertains to the
+// selected type.
+// If the selection is a method, 'implements' displays
+// the corresponding methods of the types that would have been reported
+// by an implements query on the receiver type.
+//
+func implements(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+	allowErrors(&lconf)
+
+	qpkg, err := importQueryPackage(q.Pos, &lconf)
+	if err != nil {
+		return err
+	}
+
+	// Set the packages to search.
+	if len(q.Scope) > 0 {
+		// Inspect all packages in the analysis scope, if specified.
+		if err := setPTAScope(&lconf, q.Scope); err != nil {
+			return err
+		}
+	} else {
+		// Otherwise inspect the forward and reverse
+		// transitive closure of the selected package.
+		// (In theory even this is incomplete.)
+		_, rev, _ := importgraph.Build(q.Build)
+		for path := range rev.Search(qpkg) {
+			lconf.ImportWithTests(path)
+		}
+
+		// TODO(adonovan): for completeness, we should also
+		// type-check and inspect function bodies in all
+		// imported packages.  This would be expensive, but we
+		// could optimize by skipping functions that do not
+		// contain type declarations.  This would require
+		// changing the loader's TypeCheckFuncBodies hook to
+		// provide the []*ast.File.
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := lconf.Load()
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	// Find the selected type.
+	path, action := findInterestingNode(qpos.info, qpos.path)
+
+	var method *types.Func
+	var T types.Type // selected type (receiver if method != nil)
+
+	switch action {
+	case actionExpr:
+		// method?
+		if id, ok := path[0].(*ast.Ident); ok {
+			if obj, ok := qpos.info.ObjectOf(id).(*types.Func); ok {
+				recv := obj.Type().(*types.Signature).Recv()
+				if recv == nil {
+					return fmt.Errorf("this function is not a method")
+				}
+				method = obj
+				T = recv.Type()
+			}
+		}
+
+		// If not a method, use the expression's type.
+		if T == nil {
+			T = qpos.info.TypeOf(path[0].(ast.Expr))
+		}
+
+	case actionType:
+		T = qpos.info.TypeOf(path[0].(ast.Expr))
+	}
+	if T == nil {
+		return fmt.Errorf("not a type, method, or value")
+	}
+
+	// Find all named types, even local types (which can have
+	// methods due to promotion) and the built-in "error".
+	// We ignore aliases 'type M = N' to avoid duplicate
+	// reporting of the Named type N.
+	var allNamed []*types.Named
+	for _, info := range lprog.AllPackages {
+		for _, obj := range info.Defs {
+			if obj, ok := obj.(*types.TypeName); ok && !isAlias(obj) {
+				if named, ok := obj.Type().(*types.Named); ok {
+					allNamed = append(allNamed, named)
+				}
+			}
+		}
+	}
+	allNamed = append(allNamed, types.Universe.Lookup("error").Type().(*types.Named))
+
+	var msets typeutil.MethodSetCache
+
+	// Test each named type.
+	var to, from, fromPtr []types.Type
+	for _, U := range allNamed {
+		if isInterface(T) {
+			if msets.MethodSet(T).Len() == 0 {
+				continue // empty interface
+			}
+			if isInterface(U) {
+				if msets.MethodSet(U).Len() == 0 {
+					continue // empty interface
+				}
+
+				// T interface, U interface
+				if !types.Identical(T, U) {
+					if types.AssignableTo(U, T) {
+						to = append(to, U)
+					}
+					if types.AssignableTo(T, U) {
+						from = append(from, U)
+					}
+				}
+			} else {
+				// T interface, U concrete
+				if types.AssignableTo(U, T) {
+					to = append(to, U)
+				} else if pU := types.NewPointer(U); types.AssignableTo(pU, T) {
+					to = append(to, pU)
+				}
+			}
+		} else if isInterface(U) {
+			if msets.MethodSet(U).Len() == 0 {
+				continue // empty interface
+			}
+
+			// T concrete, U interface
+			if types.AssignableTo(T, U) {
+				from = append(from, U)
+			} else if pT := types.NewPointer(T); types.AssignableTo(pT, U) {
+				fromPtr = append(fromPtr, U)
+			}
+		}
+	}
+
+	var pos interface{} = qpos
+	if nt, ok := deref(T).(*types.Named); ok {
+		pos = nt.Obj()
+	}
+
+	// Sort types (arbitrarily) to ensure test determinism.
+	sort.Sort(typesByString(to))
+	sort.Sort(typesByString(from))
+	sort.Sort(typesByString(fromPtr))
+
+	var toMethod, fromMethod, fromPtrMethod []*types.Selection // contain nils
+	if method != nil {
+		for _, t := range to {
+			toMethod = append(toMethod,
+				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
+		}
+		for _, t := range from {
+			fromMethod = append(fromMethod,
+				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
+		}
+		for _, t := range fromPtr {
+			fromPtrMethod = append(fromPtrMethod,
+				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
+		}
+	}
+
+	q.Output(lprog.Fset, &implementsResult{
+		qpos, T, pos, to, from, fromPtr, method, toMethod, fromMethod, fromPtrMethod,
+	})
+	return nil
+}
+
+type implementsResult struct {
+	qpos *queryPos
+
+	t       types.Type   // queried type (not necessarily named)
+	pos     interface{}  // pos of t (*types.Name or *QueryPos)
+	to      []types.Type // named or ptr-to-named types assignable to interface T
+	from    []types.Type // named interfaces assignable from T
+	fromPtr []types.Type // named interfaces assignable only from *T
+
+	// if a method was queried:
+	method        *types.Func        // queried method
+	toMethod      []*types.Selection // method of type to[i], if any
+	fromMethod    []*types.Selection // method of type from[i], if any
+	fromPtrMethod []*types.Selection // method of type fromPtrMethod[i], if any
+}
+
+func (r *implementsResult) PrintPlain(printf printfFunc) {
+	relation := "is implemented by"
+
+	meth := func(sel *types.Selection) {
+		if sel != nil {
+			printf(sel.Obj(), "\t%s method (%s).%s",
+				relation, r.qpos.typeString(sel.Recv()), sel.Obj().Name())
+		}
+	}
+
+	if isInterface(r.t) {
+		if types.NewMethodSet(r.t).Len() == 0 { // TODO(adonovan): cache mset
+			printf(r.pos, "empty interface type %s", r.qpos.typeString(r.t))
+			return
+		}
+
+		if r.method == nil {
+			printf(r.pos, "interface type %s", r.qpos.typeString(r.t))
+		} else {
+			printf(r.method, "abstract method %s", r.qpos.objectString(r.method))
+		}
+
+		// Show concrete types (or methods) first; use two passes.
+		for i, sub := range r.to {
+			if !isInterface(sub) {
+				if r.method == nil {
+					printf(deref(sub).(*types.Named).Obj(), "\t%s %s type %s",
+						relation, typeKind(sub), r.qpos.typeString(sub))
+				} else {
+					meth(r.toMethod[i])
+				}
+			}
+		}
+		for i, sub := range r.to {
+			if isInterface(sub) {
+				if r.method == nil {
+					printf(sub.(*types.Named).Obj(), "\t%s %s type %s",
+						relation, typeKind(sub), r.qpos.typeString(sub))
+				} else {
+					meth(r.toMethod[i])
+				}
+			}
+		}
+
+		relation = "implements"
+		for i, super := range r.from {
+			if r.method == nil {
+				printf(super.(*types.Named).Obj(), "\t%s %s",
+					relation, r.qpos.typeString(super))
+			} else {
+				meth(r.fromMethod[i])
+			}
+		}
+	} else {
+		relation = "implements"
+
+		if r.from != nil {
+			if r.method == nil {
+				printf(r.pos, "%s type %s",
+					typeKind(r.t), r.qpos.typeString(r.t))
+			} else {
+				printf(r.method, "concrete method %s",
+					r.qpos.objectString(r.method))
+			}
+			for i, super := range r.from {
+				if r.method == nil {
+					printf(super.(*types.Named).Obj(), "\t%s %s",
+						relation, r.qpos.typeString(super))
+				} else {
+					meth(r.fromMethod[i])
+				}
+			}
+		}
+		if r.fromPtr != nil {
+			if r.method == nil {
+				printf(r.pos, "pointer type *%s", r.qpos.typeString(r.t))
+			} else {
+				// TODO(adonovan): de-dup (C).f and (*C).f implementing (I).f.
+				printf(r.method, "concrete method %s",
+					r.qpos.objectString(r.method))
+			}
+
+			for i, psuper := range r.fromPtr {
+				if r.method == nil {
+					printf(psuper.(*types.Named).Obj(), "\t%s %s",
+						relation, r.qpos.typeString(psuper))
+				} else {
+					meth(r.fromPtrMethod[i])
+				}
+			}
+		} else if r.from == nil {
+			printf(r.pos, "%s type %s implements only interface{}",
+				typeKind(r.t), r.qpos.typeString(r.t))
+		}
+	}
+}
+
+func (r *implementsResult) JSON(fset *token.FileSet) []byte {
+	var method *serial.DescribeMethod
+	if r.method != nil {
+		method = &serial.DescribeMethod{
+			Name: r.qpos.objectString(r.method),
+			Pos:  fset.Position(r.method.Pos()).String(),
+		}
+	}
+	return toJSON(&serial.Implements{
+		T:                       makeImplementsType(r.t, fset),
+		AssignableTo:            makeImplementsTypes(r.to, fset),
+		AssignableFrom:          makeImplementsTypes(r.from, fset),
+		AssignableFromPtr:       makeImplementsTypes(r.fromPtr, fset),
+		AssignableToMethod:      methodsToSerial(r.qpos.info.Pkg, r.toMethod, fset),
+		AssignableFromMethod:    methodsToSerial(r.qpos.info.Pkg, r.fromMethod, fset),
+		AssignableFromPtrMethod: methodsToSerial(r.qpos.info.Pkg, r.fromPtrMethod, fset),
+		Method:                  method,
+	})
+
+}
+
+func makeImplementsTypes(tt []types.Type, fset *token.FileSet) []serial.ImplementsType {
+	var r []serial.ImplementsType
+	for _, t := range tt {
+		r = append(r, makeImplementsType(t, fset))
+	}
+	return r
+}
+
+func makeImplementsType(T types.Type, fset *token.FileSet) serial.ImplementsType {
+	var pos token.Pos
+	if nt, ok := deref(T).(*types.Named); ok { // implementsResult.t may be non-named
+		pos = nt.Obj().Pos()
+	}
+	return serial.ImplementsType{
+		Name: T.String(),
+		Pos:  fset.Position(pos).String(),
+		Kind: typeKind(T),
+	}
+}
+
+// typeKind returns a string describing the underlying kind of type,
+// e.g. "slice", "array", "struct".
+func typeKind(T types.Type) string {
+	s := reflect.TypeOf(T.Underlying()).String()
+	return strings.ToLower(strings.TrimPrefix(s, "*types."))
+}
+
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
+
+type typesByString []types.Type
+
+func (p typesByString) Len() int           { return len(p) }
+func (p typesByString) Less(i, j int) bool { return p[i].String() < p[j].String() }
+func (p typesByString) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias18.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias18.go
new file mode 100644
index 00000000..6a2a4c0d
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias18.go
@@ -0,0 +1,15 @@
+// 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 main
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return false // there are no type aliases before Go 1.9
+}
+
+const HasAlias = false
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias19.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias19.go
new file mode 100644
index 00000000..25096ab8
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/isAlias19.go
@@ -0,0 +1,15 @@
+// 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 main
+
+import "go/types"
+
+func isAlias(obj *types.TypeName) bool {
+	return obj.IsAlias()
+}
+
+const HasAlias = true
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/main.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/main.go
new file mode 100644
index 00000000..761828a0
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/main.go
@@ -0,0 +1,215 @@
+// 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.
+
+// guru: a tool for answering questions about Go source code.
+//
+//    http://golang.org/s/using-guru
+//
+// Run with -help flag or help subcommand for usage information.
+//
+package main // import "golang.org/x/tools/cmd/guru"
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"go/build"
+	"go/token"
+	"io"
+	"log"
+	"os"
+	"runtime/pprof"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+// flags
+var (
+	modifiedFlag   = flag.Bool("modified", false, "read archive of modified files from standard input")
+	scopeFlag      = flag.String("scope", "", "comma-separated list of `packages` the analysis should be limited to")
+	ptalogFlag     = flag.String("ptalog", "", "write points-to analysis log to `file`")
+	jsonFlag       = flag.Bool("json", false, "emit output in JSON format")
+	reflectFlag    = flag.Bool("reflect", false, "analyze reflection soundly (slow)")
+	cpuprofileFlag = flag.String("cpuprofile", "", "write CPU profile to `file`")
+)
+
+func init() {
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+}
+
+const useHelp = "Run 'guru -help' for more information.\n"
+
+const helpMessage = `Go source code guru.
+Usage: guru [flags] <mode> <position>
+
+The mode argument determines the query to perform:
+
+	callees	  	show possible targets of selected function call
+	callers	  	show possible callers of selected function
+	callstack 	show path from callgraph root to selected function
+	definition	show declaration of selected identifier
+	describe  	describe selected syntax: definition, methods, etc
+	freevars  	show free variables of selection
+	implements	show 'implements' relation for selected type or method
+	peers     	show send/receive corresponding to selected channel op
+	pointsto	show variables the selected pointer may point to
+	referrers 	show all refs to entity denoted by selected identifier
+	what		show basic information about the selected syntax node
+	whicherrs	show possible values of the selected error variable
+
+The position argument specifies the filename and byte offset (or range)
+of the syntax element to query.  For example:
+
+	foo.go:#123,#128
+	bar.go:#123
+
+The -json flag causes guru to emit output in JSON format;
+	golang.org/x/tools/cmd/guru/serial defines its schema.
+	Otherwise, the output is in an editor-friendly format in which
+	every line has the form "pos: text", where pos is "-" if unknown.
+
+The -modified flag causes guru to read an archive from standard input.
+	Files in this archive will be used in preference to those in
+	the file system.  In this way, a text editor may supply guru
+	with the contents of its unsaved buffers.  Each archive entry
+	consists of the file name, a newline, the decimal file size,
+	another newline, and the contents of the file.
+
+The -scope flag restricts analysis to the specified packages.
+	Its value is a comma-separated list of patterns of these forms:
+		golang.org/x/tools/cmd/guru     # a single package
+		golang.org/x/tools/...          # all packages beneath dir
+		...                             # the entire workspace.
+	A pattern preceded by '-' is negative, so the scope
+		encoding/...,-encoding/xml
+	matches all encoding packages except encoding/xml.
+
+User manual: http://golang.org/s/using-guru
+
+Example: describe syntax at offset 530 in this file (an import spec):
+
+  $ guru describe src/golang.org/x/tools/cmd/guru/main.go:#530
+`
+
+func printHelp() {
+	fmt.Fprintln(os.Stderr, helpMessage)
+	fmt.Fprintln(os.Stderr, "Flags:")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetPrefix("guru: ")
+	log.SetFlags(0)
+
+	// Don't print full help unless -help was requested.
+	// Just gently remind users that it's there.
+	flag.Usage = func() { fmt.Fprint(os.Stderr, useHelp) }
+	flag.CommandLine.Init(os.Args[0], flag.ContinueOnError) // hack
+	if err := flag.CommandLine.Parse(os.Args[1:]); err != nil {
+		// (err has already been printed)
+		if err == flag.ErrHelp {
+			printHelp()
+		}
+		os.Exit(2)
+	}
+
+	args := flag.Args()
+	if len(args) != 2 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	mode, posn := args[0], args[1]
+
+	if mode == "help" {
+		printHelp()
+		os.Exit(2)
+	}
+
+	// Set up points-to analysis log file.
+	var ptalog io.Writer
+	if *ptalogFlag != "" {
+		if f, err := os.Create(*ptalogFlag); err != nil {
+			log.Fatalf("Failed to create PTA log file: %s", err)
+		} else {
+			buf := bufio.NewWriter(f)
+			ptalog = buf
+			defer func() {
+				if err := buf.Flush(); err != nil {
+					log.Printf("flush: %s", err)
+				}
+				if err := f.Close(); err != nil {
+					log.Printf("close: %s", err)
+				}
+			}()
+		}
+	}
+
+	// Profiling support.
+	if *cpuprofileFlag != "" {
+		f, err := os.Create(*cpuprofileFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
+	ctxt := &build.Default
+
+	// If there were modified files,
+	// read them from the standard input and
+	// overlay them on the build context.
+	if *modifiedFlag {
+		modified, err := buildutil.ParseOverlayArchive(os.Stdin)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// All I/O done by guru needs to consult the modified map.
+		// The ReadFile done by referrers does,
+		// but the loader's cgo preprocessing currently does not.
+
+		if len(modified) > 0 {
+			ctxt = buildutil.OverlayContext(ctxt, modified)
+		}
+	}
+
+	var outputMu sync.Mutex
+	output := func(fset *token.FileSet, qr QueryResult) {
+		outputMu.Lock()
+		defer outputMu.Unlock()
+		if *jsonFlag {
+			// JSON output
+			fmt.Printf("%s\n", qr.JSON(fset))
+		} else {
+			// plain output
+			printf := func(pos interface{}, format string, args ...interface{}) {
+				fprintf(os.Stdout, fset, pos, format, args...)
+			}
+			qr.PrintPlain(printf)
+		}
+	}
+
+	// Avoid corner case of split("").
+	var scope []string
+	if *scopeFlag != "" {
+		scope = strings.Split(*scopeFlag, ",")
+	}
+
+	// Ask the guru.
+	query := Query{
+		Pos:        posn,
+		Build:      ctxt,
+		Scope:      scope,
+		PTALog:     ptalog,
+		Reflection: *reflectFlag,
+		Output:     output,
+	}
+
+	if err := Run(mode, &query); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/peers.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/peers.go
new file mode 100644
index 00000000..6e138bf0
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/peers.go
@@ -0,0 +1,252 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// peers enumerates, for a given channel send (or receive) operation,
+// the set of possible receives (or sends) that correspond to it.
+//
+// TODO(adonovan): support reflect.{Select,Recv,Send,Close}.
+// TODO(adonovan): permit the user to query based on a MakeChan (not send/recv),
+// or the implicit receive in "for v := range ch".
+func peers(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	opPos := findOp(qpos)
+	if opPos == token.NoPos {
+		return fmt.Errorf("there is no channel operation here")
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	var queryOp chanOp // the originating send or receive operation
+	var ops []chanOp   // all sends/receives of opposite direction
+
+	// Look at all channel operations in the whole ssa.Program.
+	// Build a list of those of same type as the query.
+	allFuncs := ssautil.AllFunctions(prog)
+	for fn := range allFuncs {
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				for _, op := range chanOps(instr) {
+					ops = append(ops, op)
+					if op.pos == opPos {
+						queryOp = op // we found the query op
+					}
+				}
+			}
+		}
+	}
+	if queryOp.ch == nil {
+		return fmt.Errorf("ssa.Instruction for send/receive not found")
+	}
+
+	// Discard operations of wrong channel element type.
+	// Build set of channel ssa.Values as query to pointer analysis.
+	// We compare channels by element types, not channel types, to
+	// ignore both directionality and type names.
+	queryType := queryOp.ch.Type()
+	queryElemType := queryType.Underlying().(*types.Chan).Elem()
+	ptaConfig.AddQuery(queryOp.ch)
+	i := 0
+	for _, op := range ops {
+		if types.Identical(op.ch.Type().Underlying().(*types.Chan).Elem(), queryElemType) {
+			ptaConfig.AddQuery(op.ch)
+			ops[i] = op
+			i++
+		}
+	}
+	ops = ops[:i]
+
+	// Run the pointer analysis.
+	ptares := ptrAnalysis(ptaConfig)
+
+	// Find the points-to set.
+	queryChanPtr := ptares.Queries[queryOp.ch]
+
+	// Ascertain which make(chan) labels the query's channel can alias.
+	var makes []token.Pos
+	for _, label := range queryChanPtr.PointsTo().Labels() {
+		makes = append(makes, label.Pos())
+	}
+	sort.Sort(byPos(makes))
+
+	// Ascertain which channel operations can alias the same make(chan) labels.
+	var sends, receives, closes []token.Pos
+	for _, op := range ops {
+		if ptr, ok := ptares.Queries[op.ch]; ok && ptr.MayAlias(queryChanPtr) {
+			switch op.dir {
+			case types.SendOnly:
+				sends = append(sends, op.pos)
+			case types.RecvOnly:
+				receives = append(receives, op.pos)
+			case types.SendRecv:
+				closes = append(closes, op.pos)
+			}
+		}
+	}
+	sort.Sort(byPos(sends))
+	sort.Sort(byPos(receives))
+	sort.Sort(byPos(closes))
+
+	q.Output(lprog.Fset, &peersResult{
+		queryPos:  opPos,
+		queryType: queryType,
+		makes:     makes,
+		sends:     sends,
+		receives:  receives,
+		closes:    closes,
+	})
+	return nil
+}
+
+// findOp returns the position of the enclosing send/receive/close op.
+// For send and receive operations, this is the position of the <- token;
+// for close operations, it's the Lparen of the function call.
+//
+// TODO(adonovan): handle implicit receive operations from 'for...range chan' statements.
+func findOp(qpos *queryPos) token.Pos {
+	for _, n := range qpos.path {
+		switch n := n.(type) {
+		case *ast.UnaryExpr:
+			if n.Op == token.ARROW {
+				return n.OpPos
+			}
+		case *ast.SendStmt:
+			return n.Arrow
+		case *ast.CallExpr:
+			// close function call can only exist as a direct identifier
+			if close, ok := unparen(n.Fun).(*ast.Ident); ok {
+				if b, ok := qpos.info.Info.Uses[close].(*types.Builtin); ok && b.Name() == "close" {
+					return n.Lparen
+				}
+			}
+		}
+	}
+	return token.NoPos
+}
+
+// chanOp abstracts an ssa.Send, ssa.Unop(ARROW), or a SelectState.
+type chanOp struct {
+	ch  ssa.Value
+	dir types.ChanDir // SendOnly=send, RecvOnly=recv, SendRecv=close
+	pos token.Pos
+}
+
+// chanOps returns a slice of all the channel operations in the instruction.
+func chanOps(instr ssa.Instruction) []chanOp {
+	// TODO(adonovan): handle calls to reflect.{Select,Recv,Send,Close} too.
+	var ops []chanOp
+	switch instr := instr.(type) {
+	case *ssa.UnOp:
+		if instr.Op == token.ARROW {
+			ops = append(ops, chanOp{instr.X, types.RecvOnly, instr.Pos()})
+		}
+	case *ssa.Send:
+		ops = append(ops, chanOp{instr.Chan, types.SendOnly, instr.Pos()})
+	case *ssa.Select:
+		for _, st := range instr.States {
+			ops = append(ops, chanOp{st.Chan, st.Dir, st.Pos})
+		}
+	case ssa.CallInstruction:
+		cc := instr.Common()
+		if b, ok := cc.Value.(*ssa.Builtin); ok && b.Name() == "close" {
+			ops = append(ops, chanOp{cc.Args[0], types.SendRecv, cc.Pos()})
+		}
+	}
+	return ops
+}
+
+// TODO(adonovan): show the line of text for each pos, like "referrers" does.
+type peersResult struct {
+	queryPos                       token.Pos   // of queried channel op
+	queryType                      types.Type  // type of queried channel
+	makes, sends, receives, closes []token.Pos // positions of aliased makechan/send/receive/close instrs
+}
+
+func (r *peersResult) PrintPlain(printf printfFunc) {
+	if len(r.makes) == 0 {
+		printf(r.queryPos, "This channel can't point to anything.")
+		return
+	}
+	printf(r.queryPos, "This channel of type %s may be:", r.queryType)
+	for _, alloc := range r.makes {
+		printf(alloc, "\tallocated here")
+	}
+	for _, send := range r.sends {
+		printf(send, "\tsent to, here")
+	}
+	for _, receive := range r.receives {
+		printf(receive, "\treceived from, here")
+	}
+	for _, clos := range r.closes {
+		printf(clos, "\tclosed, here")
+	}
+}
+
+func (r *peersResult) JSON(fset *token.FileSet) []byte {
+	peers := &serial.Peers{
+		Pos:  fset.Position(r.queryPos).String(),
+		Type: r.queryType.String(),
+	}
+	for _, alloc := range r.makes {
+		peers.Allocs = append(peers.Allocs, fset.Position(alloc).String())
+	}
+	for _, send := range r.sends {
+		peers.Sends = append(peers.Sends, fset.Position(send).String())
+	}
+	for _, receive := range r.receives {
+		peers.Receives = append(peers.Receives, fset.Position(receive).String())
+	}
+	for _, clos := range r.closes {
+		peers.Closes = append(peers.Closes, fset.Position(clos).String())
+	}
+	return toJSON(peers)
+}
+
+// -------- utils --------
+
+// NB: byPos is not deterministic across packages since it depends on load order.
+// Use lessPos if the tests need it.
+type byPos []token.Pos
+
+func (p byPos) Len() int           { return len(p) }
+func (p byPos) Less(i, j int) bool { return p[i] < p[j] }
+func (p byPos) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pointsto.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pointsto.go
new file mode 100644
index 00000000..782277f3
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pointsto.go
@@ -0,0 +1,290 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/pointer"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// pointsto runs the pointer analysis on the selected expression,
+// and reports its points-to set (for a pointer-like expression)
+// or its dynamic types (for an interface, reflect.Value, or
+// reflect.Type expression) and their points-to sets.
+//
+// All printed sets are sorted to ensure determinism.
+//
+func pointsto(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
+	if err != nil {
+		return err
+	}
+
+	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	path, action := findInterestingNode(qpos.info, qpos.path)
+	if action != actionExpr {
+		return fmt.Errorf("pointer analysis wants an expression; got %s",
+			astutil.NodeDescription(qpos.path[0]))
+	}
+
+	var expr ast.Expr
+	var obj types.Object
+	switch n := path[0].(type) {
+	case *ast.ValueSpec:
+		// ambiguous ValueSpec containing multiple names
+		return fmt.Errorf("multiple value specification")
+	case *ast.Ident:
+		obj = qpos.info.ObjectOf(n)
+		expr = n
+	case ast.Expr:
+		expr = n
+	default:
+		// TODO(adonovan): is this reachable?
+		return fmt.Errorf("unexpected AST for expr: %T", n)
+	}
+
+	// Reject non-pointerlike types (includes all constants---except nil).
+	// TODO(adonovan): reject nil too.
+	typ := qpos.info.TypeOf(expr)
+	if !pointer.CanPoint(typ) {
+		return fmt.Errorf("pointer analysis wants an expression of reference type; got %s", typ)
+	}
+
+	// Determine the ssa.Value for the expression.
+	var value ssa.Value
+	var isAddr bool
+	if obj != nil {
+		// def/ref of func/var object
+		value, isAddr, err = ssaValueForIdent(prog, qpos.info, obj, path)
+	} else {
+		value, isAddr, err = ssaValueForExpr(prog, qpos.info, path)
+	}
+	if err != nil {
+		return err // e.g. trivially dead code
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	// Run the pointer analysis.
+	ptrs, err := runPTA(ptaConfig, value, isAddr)
+	if err != nil {
+		return err // e.g. analytically unreachable
+	}
+
+	q.Output(lprog.Fset, &pointstoResult{
+		qpos: qpos,
+		typ:  typ,
+		ptrs: ptrs,
+	})
+	return nil
+}
+
+// ssaValueForIdent returns the ssa.Value for the ast.Ident whose path
+// to the root of the AST is path.  isAddr reports whether the
+// ssa.Value is the address denoted by the ast.Ident, not its value.
+//
+func ssaValueForIdent(prog *ssa.Program, qinfo *loader.PackageInfo, obj types.Object, path []ast.Node) (value ssa.Value, isAddr bool, err error) {
+	switch obj := obj.(type) {
+	case *types.Var:
+		pkg := prog.Package(qinfo.Pkg)
+		pkg.Build()
+		if v, addr := prog.VarValue(obj, pkg, path); v != nil {
+			return v, addr, nil
+		}
+		return nil, false, fmt.Errorf("can't locate SSA Value for var %s", obj.Name())
+
+	case *types.Func:
+		fn := prog.FuncValue(obj)
+		if fn == nil {
+			return nil, false, fmt.Errorf("%s is an interface method", obj)
+		}
+		// TODO(adonovan): there's no point running PTA on a *Func ident.
+		// Eliminate this feature.
+		return fn, false, nil
+	}
+	panic(obj)
+}
+
+// ssaValueForExpr returns the ssa.Value of the non-ast.Ident
+// expression whose path to the root of the AST is path.
+//
+func ssaValueForExpr(prog *ssa.Program, qinfo *loader.PackageInfo, path []ast.Node) (value ssa.Value, isAddr bool, err error) {
+	pkg := prog.Package(qinfo.Pkg)
+	pkg.SetDebugMode(true)
+	pkg.Build()
+
+	fn := ssa.EnclosingFunction(pkg, path)
+	if fn == nil {
+		return nil, false, fmt.Errorf("no SSA function built for this location (dead code?)")
+	}
+
+	if v, addr := fn.ValueForExpr(path[0].(ast.Expr)); v != nil {
+		return v, addr, nil
+	}
+
+	return nil, false, fmt.Errorf("can't locate SSA Value for expression in %s", fn)
+}
+
+// runPTA runs the pointer analysis of the selected SSA value or address.
+func runPTA(conf *pointer.Config, v ssa.Value, isAddr bool) (ptrs []pointerResult, err error) {
+	T := v.Type()
+	if isAddr {
+		conf.AddIndirectQuery(v)
+		T = deref(T)
+	} else {
+		conf.AddQuery(v)
+	}
+	ptares := ptrAnalysis(conf)
+
+	var ptr pointer.Pointer
+	if isAddr {
+		ptr = ptares.IndirectQueries[v]
+	} else {
+		ptr = ptares.Queries[v]
+	}
+	if ptr == (pointer.Pointer{}) {
+		return nil, fmt.Errorf("pointer analysis did not find expression (dead code?)")
+	}
+	pts := ptr.PointsTo()
+
+	if pointer.CanHaveDynamicTypes(T) {
+		// Show concrete types for interface/reflect.Value expression.
+		if concs := pts.DynamicTypes(); concs.Len() > 0 {
+			concs.Iterate(func(conc types.Type, pta interface{}) {
+				labels := pta.(pointer.PointsToSet).Labels()
+				sort.Sort(byPosAndString(labels)) // to ensure determinism
+				ptrs = append(ptrs, pointerResult{conc, labels})
+			})
+		}
+	} else {
+		// Show labels for other expressions.
+		labels := pts.Labels()
+		sort.Sort(byPosAndString(labels)) // to ensure determinism
+		ptrs = append(ptrs, pointerResult{T, labels})
+	}
+	sort.Sort(byTypeString(ptrs)) // to ensure determinism
+	return ptrs, nil
+}
+
+type pointerResult struct {
+	typ    types.Type       // type of the pointer (always concrete)
+	labels []*pointer.Label // set of labels
+}
+
+type pointstoResult struct {
+	qpos *queryPos
+	typ  types.Type      // type of expression
+	ptrs []pointerResult // pointer info (typ is concrete => len==1)
+}
+
+func (r *pointstoResult) PrintPlain(printf printfFunc) {
+	if pointer.CanHaveDynamicTypes(r.typ) {
+		// Show concrete types for interface, reflect.Type or
+		// reflect.Value expression.
+
+		if len(r.ptrs) > 0 {
+			printf(r.qpos, "this %s may contain these dynamic types:", r.qpos.typeString(r.typ))
+			for _, ptr := range r.ptrs {
+				var obj types.Object
+				if nt, ok := deref(ptr.typ).(*types.Named); ok {
+					obj = nt.Obj()
+				}
+				if len(ptr.labels) > 0 {
+					printf(obj, "\t%s, may point to:", r.qpos.typeString(ptr.typ))
+					printLabels(printf, ptr.labels, "\t\t")
+				} else {
+					printf(obj, "\t%s", r.qpos.typeString(ptr.typ))
+				}
+			}
+		} else {
+			printf(r.qpos, "this %s cannot contain any dynamic types.", r.typ)
+		}
+	} else {
+		// Show labels for other expressions.
+		if ptr := r.ptrs[0]; len(ptr.labels) > 0 {
+			printf(r.qpos, "this %s may point to these objects:",
+				r.qpos.typeString(r.typ))
+			printLabels(printf, ptr.labels, "\t")
+		} else {
+			printf(r.qpos, "this %s may not point to anything.",
+				r.qpos.typeString(r.typ))
+		}
+	}
+}
+
+func (r *pointstoResult) JSON(fset *token.FileSet) []byte {
+	var pts []serial.PointsTo
+	for _, ptr := range r.ptrs {
+		var namePos string
+		if nt, ok := deref(ptr.typ).(*types.Named); ok {
+			namePos = fset.Position(nt.Obj().Pos()).String()
+		}
+		var labels []serial.PointsToLabel
+		for _, l := range ptr.labels {
+			labels = append(labels, serial.PointsToLabel{
+				Pos:  fset.Position(l.Pos()).String(),
+				Desc: l.String(),
+			})
+		}
+		pts = append(pts, serial.PointsTo{
+			Type:    r.qpos.typeString(ptr.typ),
+			NamePos: namePos,
+			Labels:  labels,
+		})
+	}
+	return toJSON(pts)
+}
+
+type byTypeString []pointerResult
+
+func (a byTypeString) Len() int           { return len(a) }
+func (a byTypeString) Less(i, j int) bool { return a[i].typ.String() < a[j].typ.String() }
+func (a byTypeString) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+type byPosAndString []*pointer.Label
+
+func (a byPosAndString) Len() int { return len(a) }
+func (a byPosAndString) Less(i, j int) bool {
+	cmp := a[i].Pos() - a[j].Pos()
+	return cmp < 0 || (cmp == 0 && a[i].String() < a[j].String())
+}
+func (a byPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+func printLabels(printf printfFunc, labels []*pointer.Label, prefix string) {
+	// TODO(adonovan): due to context-sensitivity, many of these
+	// labels may differ only by context, which isn't apparent.
+	for _, label := range labels {
+		printf(label, "%s%s", prefix, label)
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pos.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pos.go
new file mode 100644
index 00000000..2e659fe4
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/pos.go
@@ -0,0 +1,142 @@
+// 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 main
+
+// This file defines utilities for working with file positions.
+
+import (
+	"fmt"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/buildutil"
+)
+
+// parseOctothorpDecimal returns the numeric value if s matches "#%d",
+// otherwise -1.
+func parseOctothorpDecimal(s string) int {
+	if s != "" && s[0] == '#' {
+		if s, err := strconv.ParseInt(s[1:], 10, 32); err == nil {
+			return int(s)
+		}
+	}
+	return -1
+}
+
+// parsePos parses a string of the form "file:pos" or
+// file:start,end" where pos, start, end match #%d and represent byte
+// offsets, and returns its components.
+//
+// (Numbers without a '#' prefix are reserved for future use,
+// e.g. to indicate line/column positions.)
+//
+func parsePos(pos string) (filename string, startOffset, endOffset int, err error) {
+	if pos == "" {
+		err = fmt.Errorf("no source position specified")
+		return
+	}
+
+	colon := strings.LastIndex(pos, ":")
+	if colon < 0 {
+		err = fmt.Errorf("bad position syntax %q", pos)
+		return
+	}
+	filename, offset := pos[:colon], pos[colon+1:]
+	startOffset = -1
+	endOffset = -1
+	if comma := strings.Index(offset, ","); comma < 0 {
+		// e.g. "foo.go:#123"
+		startOffset = parseOctothorpDecimal(offset)
+		endOffset = startOffset
+	} else {
+		// e.g. "foo.go:#123,#456"
+		startOffset = parseOctothorpDecimal(offset[:comma])
+		endOffset = parseOctothorpDecimal(offset[comma+1:])
+	}
+	if startOffset < 0 || endOffset < 0 {
+		err = fmt.Errorf("invalid offset %q in query position", offset)
+		return
+	}
+	return
+}
+
+// fileOffsetToPos translates the specified file-relative byte offsets
+// into token.Pos form.  It returns an error if the file was not found
+// or the offsets were out of bounds.
+//
+func fileOffsetToPos(file *token.File, startOffset, endOffset int) (start, end token.Pos, err error) {
+	// Range check [start..end], inclusive of both end-points.
+
+	if 0 <= startOffset && startOffset <= file.Size() {
+		start = file.Pos(int(startOffset))
+	} else {
+		err = fmt.Errorf("start position is beyond end of file")
+		return
+	}
+
+	if 0 <= endOffset && endOffset <= file.Size() {
+		end = file.Pos(int(endOffset))
+	} else {
+		err = fmt.Errorf("end position is beyond end of file")
+		return
+	}
+
+	return
+}
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+//
+func sameFile(x, y string) bool {
+	if filepath.Base(x) == filepath.Base(y) { // (optimisation)
+		if xi, err := os.Stat(x); err == nil {
+			if yi, err := os.Stat(y); err == nil {
+				return os.SameFile(xi, yi)
+			}
+		}
+	}
+	return false
+}
+
+// fastQueryPos parses the position string and returns a queryPos.
+// It parses only a single file and does not run the type checker.
+func fastQueryPos(ctxt *build.Context, pos string) (*queryPos, error) {
+	filename, startOffset, endOffset, err := parsePos(pos)
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse the file, opening it the file via the build.Context
+	// so that we observe the effects of the -modified flag.
+	fset := token.NewFileSet()
+	cwd, _ := os.Getwd()
+	f, err := buildutil.ParseFile(fset, ctxt, nil, cwd, filename, parser.Mode(0))
+	// ParseFile usually returns a partial file along with an error.
+	// Only fail if there is no file.
+	if f == nil {
+		return nil, err
+	}
+	if !f.Pos().IsValid() {
+		return nil, fmt.Errorf("%s is not a Go source file", filename)
+	}
+
+	start, end, err := fileOffsetToPos(fset.File(f.Pos()), startOffset, endOffset)
+	if err != nil {
+		return nil, err
+	}
+
+	path, exact := astutil.PathEnclosingInterval(f, start, end)
+	if path == nil {
+		return nil, fmt.Errorf("no syntax here")
+	}
+
+	return &queryPos{fset, start, end, path, exact, nil}, nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/referrers.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/referrers.go
new file mode 100644
index 00000000..d079e274
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/referrers.go
@@ -0,0 +1,802 @@
+// 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 main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"log"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/imports"
+	"golang.org/x/tools/refactor/importgraph"
+)
+
+// Referrers reports all identifiers that resolve to the same object
+// as the queried identifier, within any package in the workspace.
+func referrers(q *Query) error {
+	fset := token.NewFileSet()
+	lconf := loader.Config{Fset: fset, Build: q.Build}
+	allowErrors(&lconf)
+
+	if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
+		return err
+	}
+
+	// Load tests of the query package
+	// even if the query location is not in the tests.
+	for path := range lconf.ImportPkgs {
+		lconf.ImportPkgs[path] = true
+	}
+
+	// Load/parse/type-check the query package.
+	lprog, err := lconf.Load()
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, false)
+	if err != nil {
+		return err
+	}
+
+	id, _ := qpos.path[0].(*ast.Ident)
+	if id == nil {
+		return fmt.Errorf("no identifier here")
+	}
+
+	obj := qpos.info.ObjectOf(id)
+	if obj == nil {
+		// Happens for y in "switch y := x.(type)",
+		// the package declaration,
+		// and unresolved identifiers.
+		if _, ok := qpos.path[1].(*ast.File); ok { // package decl?
+			return packageReferrers(q, qpos.info.Pkg.Path())
+		}
+		return fmt.Errorf("no object for identifier: %T", qpos.path[1])
+	}
+
+	// Imported package name?
+	if pkgname, ok := obj.(*types.PkgName); ok {
+		return packageReferrers(q, pkgname.Imported().Path())
+	}
+
+	if obj.Pkg() == nil {
+		return fmt.Errorf("references to predeclared %q are everywhere!", obj.Name())
+	}
+
+	q.Output(fset, &referrersInitialResult{
+		qinfo: qpos.info,
+		obj:   obj,
+	})
+
+	// For a globally accessible object defined in package P, we
+	// must load packages that depend on P.  Specifically, for a
+	// package-level object, we need load only direct importers
+	// of P, but for a field or method, we must load
+	// any package that transitively imports P.
+
+	if global, pkglevel := classify(obj); global {
+		if pkglevel {
+			return globalReferrersPkgLevel(q, obj, fset)
+		}
+		// We'll use the the object's position to identify it in the larger program.
+		objposn := fset.Position(obj.Pos())
+		defpkg := obj.Pkg().Path() // defining package
+		return globalReferrers(q, qpos.info.Pkg.Path(), defpkg, objposn)
+	}
+
+	outputUses(q, fset, usesOf(obj, qpos.info), obj.Pkg())
+
+	return nil // success
+}
+
+// classify classifies objects by how far
+// we have to look to find references to them.
+func classify(obj types.Object) (global, pkglevel bool) {
+	if obj.Exported() {
+		if obj.Parent() == nil {
+			// selectable object (field or method)
+			return true, false
+		}
+		if obj.Parent() == obj.Pkg().Scope() {
+			// lexical object (package-level var/const/func/type)
+			return true, true
+		}
+	}
+	// object with unexported named or defined in local scope
+	return false, false
+}
+
+// packageReferrers reports all references to the specified package
+// throughout the workspace.
+func packageReferrers(q *Query, path string) error {
+	// Scan the workspace and build the import graph.
+	// Ignore broken packages.
+	_, rev, _ := importgraph.Build(q.Build)
+
+	// Find the set of packages that directly import the query package.
+	// Only those packages need typechecking of function bodies.
+	users := rev[path]
+
+	// Load the larger program.
+	fset := token.NewFileSet()
+	lconf := loader.Config{
+		Fset:  fset,
+		Build: q.Build,
+		TypeCheckFuncBodies: func(p string) bool {
+			return users[strings.TrimSuffix(p, "_test")]
+		},
+	}
+	allowErrors(&lconf)
+
+	// The importgraph doesn't treat external test packages
+	// as separate nodes, so we must use ImportWithTests.
+	for path := range users {
+		lconf.ImportWithTests(path)
+	}
+
+	// Subtle!  AfterTypeCheck needs no mutex for qpkg because the
+	// topological import order gives us the necessary happens-before edges.
+	// TODO(adonovan): what about import cycles?
+	var qpkg *types.Package
+
+	// For efficiency, we scan each package for references
+	// just after it has been type-checked.  The loader calls
+	// AfterTypeCheck (concurrently), providing us with a stream of
+	// packages.
+	lconf.AfterTypeCheck = func(info *loader.PackageInfo, files []*ast.File) {
+		// AfterTypeCheck may be called twice for the same package due to augmentation.
+
+		if info.Pkg.Path() == path && qpkg == nil {
+			// Found the package of interest.
+			qpkg = info.Pkg
+			fakepkgname := types.NewPkgName(token.NoPos, qpkg, qpkg.Name(), qpkg)
+			q.Output(fset, &referrersInitialResult{
+				qinfo: info,
+				obj:   fakepkgname, // bogus
+			})
+		}
+
+		// Only inspect packages that directly import the
+		// declaring package (and thus were type-checked).
+		if lconf.TypeCheckFuncBodies(info.Pkg.Path()) {
+			// Find PkgNames that refer to qpkg.
+			// TODO(adonovan): perhaps more useful would be to show imports
+			// of the package instead of qualified identifiers.
+			var refs []*ast.Ident
+			for id, obj := range info.Uses {
+				if obj, ok := obj.(*types.PkgName); ok && obj.Imported() == qpkg {
+					refs = append(refs, id)
+				}
+			}
+			outputUses(q, fset, refs, info.Pkg)
+		}
+
+		clearInfoFields(info) // save memory
+	}
+
+	lconf.Load() // ignore error
+
+	if qpkg == nil {
+		log.Fatalf("query package %q not found during reloading", path)
+	}
+
+	return nil
+}
+
+func usesOf(queryObj types.Object, info *loader.PackageInfo) []*ast.Ident {
+	var refs []*ast.Ident
+	for id, obj := range info.Uses {
+		if sameObj(queryObj, obj) {
+			refs = append(refs, id)
+		}
+	}
+	return refs
+}
+
+// outputUses outputs a result describing refs, which appear in the package denoted by info.
+func outputUses(q *Query, fset *token.FileSet, refs []*ast.Ident, pkg *types.Package) {
+	if len(refs) > 0 {
+		sort.Sort(byNamePos{fset, refs})
+		q.Output(fset, &referrersPackageResult{
+			pkg:   pkg,
+			build: q.Build,
+			fset:  fset,
+			refs:  refs,
+		})
+	}
+}
+
+// globalReferrers reports references throughout the entire workspace to the
+// object (a field or method) at the specified source position.
+// Its defining package is defpkg, and the query package is qpkg.
+func globalReferrers(q *Query, qpkg, defpkg string, objposn token.Position) error {
+	// Scan the workspace and build the import graph.
+	// Ignore broken packages.
+	_, rev, _ := importgraph.Build(q.Build)
+
+	// Find the set of packages that depend on defpkg.
+	// Only function bodies in those packages need type-checking.
+	users := rev.Search(defpkg) // transitive importers
+
+	// Prepare to load the larger program.
+	fset := token.NewFileSet()
+	lconf := loader.Config{
+		Fset:  fset,
+		Build: q.Build,
+		TypeCheckFuncBodies: func(p string) bool {
+			return users[strings.TrimSuffix(p, "_test")]
+		},
+	}
+	allowErrors(&lconf)
+
+	// The importgraph doesn't treat external test packages
+	// as separate nodes, so we must use ImportWithTests.
+	for path := range users {
+		lconf.ImportWithTests(path)
+	}
+
+	// The remainder of this function is somewhat tricky because it
+	// operates on the concurrent stream of packages observed by the
+	// loader's AfterTypeCheck hook.  Most of guru's helper
+	// functions assume the entire program has already been loaded,
+	// so we can't use them here.
+	// TODO(adonovan): smooth things out once the other changes have landed.
+
+	// Results are reported concurrently from within the
+	// AfterTypeCheck hook.  The program may provide a useful stream
+	// of information even if the user doesn't let the program run
+	// to completion.
+
+	var (
+		mu   sync.Mutex
+		qobj types.Object
+	)
+
+	// For efficiency, we scan each package for references
+	// just after it has been type-checked.  The loader calls
+	// AfterTypeCheck (concurrently), providing us with a stream of
+	// packages.
+	lconf.AfterTypeCheck = func(info *loader.PackageInfo, files []*ast.File) {
+		// AfterTypeCheck may be called twice for the same package due to augmentation.
+
+		// Only inspect packages that depend on the declaring package
+		// (and thus were type-checked).
+		if lconf.TypeCheckFuncBodies(info.Pkg.Path()) {
+			// Record the query object and its package when we see it.
+			mu.Lock()
+			if qobj == nil && info.Pkg.Path() == defpkg {
+				// Find the object by its position (slightly ugly).
+				qobj = findObject(fset, &info.Info, objposn)
+				if qobj == nil {
+					// It really ought to be there;
+					// we found it once already.
+					log.Fatalf("object at %s not found in package %s",
+						objposn, defpkg)
+				}
+			}
+			obj := qobj
+			mu.Unlock()
+
+			// Look for references to the query object.
+			if obj != nil {
+				outputUses(q, fset, usesOf(obj, info), info.Pkg)
+			}
+		}
+
+		clearInfoFields(info) // save memory
+	}
+
+	lconf.Load() // ignore error
+
+	if qobj == nil {
+		log.Fatal("query object not found during reloading")
+	}
+
+	return nil // success
+}
+
+// globalReferrersPkgLevel reports references throughout the entire workspace to the package-level object obj.
+// It assumes that the query object itself has already been reported.
+func globalReferrersPkgLevel(q *Query, obj types.Object, fset *token.FileSet) error {
+	// globalReferrersPkgLevel uses go/ast and friends instead of go/types.
+	// This affords a considerable performance benefit.
+	// It comes at the cost of some code complexity.
+	//
+	// Here's a high level summary.
+	//
+	// The goal is to find references to the query object p.Q.
+	// There are several possible scenarios, each handled differently.
+	//
+	// 1. We are looking in a package other than p, and p is not dot-imported.
+	//    This is the simplest case. Q must be referred to as n.Q,
+	//    where n is the name under which p is imported.
+	//    We look at all imports of p to gather all names under which it is imported.
+	//    (In the typical case, it is imported only once, under its default name.)
+	//    Then we look at all selector expressions and report any matches.
+	//
+	// 2. We are looking in a package other than p, and p is dot-imported.
+	//    In this case, Q will be referred to just as Q.
+	//    Furthermore, go/ast's object resolution will not be able to resolve
+	//    Q to any other object, unlike any local (file- or function- or block-scoped) object.
+	//    So we look at all matching identifiers and report all unresolvable ones.
+	//
+	// 3. We are looking in package p.
+	//    (Care must be taken to separate p and p_test (an xtest package),
+	//    and make sure that they are treated as separate packages.)
+	//    In this case, we give go/ast the entire package for object resolution,
+	//    instead of going file by file.
+	//    We then iterate over all identifiers that resolve to the query object.
+	//    (The query object itself has already been reported, so we don't re-report it.)
+	//
+	// We always skip all files that don't contain the string Q, as they cannot be
+	// relevant to finding references to Q.
+	//
+	// We parse all files leniently. In the presence of parsing errors, results are best-effort.
+
+	// Scan the workspace and build the import graph.
+	// Ignore broken packages.
+	_, rev, _ := importgraph.Build(q.Build)
+
+	// Find the set of packages that directly import defpkg.
+	defpkg := obj.Pkg().Path()
+	defpkg = strings.TrimSuffix(defpkg, "_test") // package x_test actually has package name x
+	defpkg = imports.VendorlessPath(defpkg)      // remove vendor goop
+
+	users := rev[defpkg]
+	if len(users) == 0 {
+		users = make(map[string]bool)
+	}
+	// We also need to check defpkg itself, and its xtests.
+	// For the reverse graph packages, we process xtests with the main package.
+	// defpkg gets special handling; we must distinguish between in-package vs out-of-package.
+	// To make the control flow below simpler, add defpkg and defpkg xtest placeholders.
+	// Use "!test" instead of "_test" because "!" is not a valid character in an import path.
+	// (More precisely, it is not guaranteed to be a valid character in an import path,
+	// so it is unlikely that it will be in use. See https://golang.org/ref/spec#Import_declarations.)
+	users[defpkg] = true
+	users[defpkg+"!test"] = true
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	defname := obj.Pkg().Name()                    // name of defining package, used for imports using import path only
+	isxtest := strings.HasSuffix(defname, "_test") // indicates whether the query object is defined in an xtest package
+
+	name := obj.Name()
+	namebytes := []byte(name)          // byte slice version of query object name, for early filtering
+	objpos := fset.Position(obj.Pos()) // position of query object, used to prevent re-emitting original decl
+
+	sema := make(chan struct{}, 20) // counting semaphore to limit I/O concurrency
+	var wg sync.WaitGroup
+
+	for u := range users {
+		u := u
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			uIsXTest := strings.HasSuffix(u, "!test") // indicates whether this package is the special defpkg xtest package
+			u = strings.TrimSuffix(u, "!test")
+
+			// Resolve package.
+			sema <- struct{}{} // acquire token
+			pkg, err := q.Build.Import(u, cwd, build.IgnoreVendor)
+			<-sema // release token
+			if err != nil {
+				return
+			}
+
+			// If we're not in the query package,
+			// the object is in another package regardless,
+			// so we want to process all files.
+			// If we are in the query package,
+			// we want to only process the files that are
+			// part of that query package;
+			// that set depends on whether the query package itself is an xtest.
+			inQueryPkg := u == defpkg && isxtest == uIsXTest
+			var files []string
+			if !inQueryPkg || !isxtest {
+				files = append(files, pkg.GoFiles...)
+				files = append(files, pkg.TestGoFiles...)
+				files = append(files, pkg.CgoFiles...) // use raw cgo files, as we're only parsing
+			}
+			if !inQueryPkg || isxtest {
+				files = append(files, pkg.XTestGoFiles...)
+			}
+
+			if len(files) == 0 {
+				return
+			}
+
+			var deffiles map[string]*ast.File
+			if inQueryPkg {
+				deffiles = make(map[string]*ast.File)
+			}
+
+			buf := new(bytes.Buffer) // reusable buffer for reading files
+
+			for _, file := range files {
+				if !buildutil.IsAbsPath(q.Build, file) {
+					file = buildutil.JoinPath(q.Build, pkg.Dir, file)
+				}
+				buf.Reset()
+				sema <- struct{}{} // acquire token
+				src, err := readFile(q.Build, file, buf)
+				<-sema // release token
+				if err != nil {
+					continue
+				}
+
+				// Fast path: If the object's name isn't present anywhere in the source, ignore the file.
+				if !bytes.Contains(src, namebytes) {
+					continue
+				}
+
+				if inQueryPkg {
+					// If we're in the query package, we defer final processing until we have
+					// parsed all of the candidate files in the package.
+					// Best effort; allow errors and use what we can from what remains.
+					f, _ := parser.ParseFile(fset, file, src, parser.AllErrors)
+					if f != nil {
+						deffiles[file] = f
+					}
+					continue
+				}
+
+				// We aren't in the query package. Go file by file.
+
+				// Parse out only the imports, to check whether the defining package
+				// was imported, and if so, under what names.
+				// Best effort; allow errors and use what we can from what remains.
+				f, _ := parser.ParseFile(fset, file, src, parser.ImportsOnly|parser.AllErrors)
+				if f == nil {
+					continue
+				}
+
+				// pkgnames is the set of names by which defpkg is imported in this file.
+				// (Multiple imports in the same file are legal but vanishingly rare.)
+				pkgnames := make([]string, 0, 1)
+				var isdotimport bool
+				for _, imp := range f.Imports {
+					path, err := strconv.Unquote(imp.Path.Value)
+					if err != nil || path != defpkg {
+						continue
+					}
+					switch {
+					case imp.Name == nil:
+						pkgnames = append(pkgnames, defname)
+					case imp.Name.Name == ".":
+						isdotimport = true
+					default:
+						pkgnames = append(pkgnames, imp.Name.Name)
+					}
+				}
+				if len(pkgnames) == 0 && !isdotimport {
+					// Defining package not imported, bail.
+					continue
+				}
+
+				// Re-parse the entire file.
+				// Parse errors are ok; we'll do the best we can with a partial AST, if we have one.
+				f, _ = parser.ParseFile(fset, file, src, parser.AllErrors)
+				if f == nil {
+					continue
+				}
+
+				// Walk the AST looking for references.
+				var refs []*ast.Ident
+				ast.Inspect(f, func(n ast.Node) bool {
+					// Check selector expressions.
+					// If the selector matches the target name,
+					// and the expression is one of the names
+					// that the defining package was imported under,
+					// then we have a match.
+					if sel, ok := n.(*ast.SelectorExpr); ok && sel.Sel.Name == name {
+						if id, ok := sel.X.(*ast.Ident); ok {
+							for _, n := range pkgnames {
+								if n == id.Name {
+									refs = append(refs, sel.Sel)
+									// Don't recurse further, to avoid duplicate entries
+									// from the dot import check below.
+									return false
+								}
+							}
+						}
+					}
+					// Dot imports are special.
+					// Objects imported from the defining package are placed in the package scope.
+					// go/ast does not resolve them to an object.
+					// At all other scopes (file, local), go/ast can do the resolution.
+					// So we're looking for object-free idents with the right name.
+					// The only other way to get something with the right name at the package scope
+					// is to *be* the defining package. We handle that case separately (inQueryPkg).
+					if isdotimport {
+						if id, ok := n.(*ast.Ident); ok && id.Obj == nil && id.Name == name {
+							refs = append(refs, id)
+							return false
+						}
+					}
+					return true
+				})
+
+				// Emit any references we found.
+				if len(refs) > 0 {
+					q.Output(fset, &referrersPackageResult{
+						pkg:   types.NewPackage(pkg.ImportPath, pkg.Name),
+						build: q.Build,
+						fset:  fset,
+						refs:  refs,
+					})
+				}
+			}
+
+			// If we're in the query package, we've now collected all the files in the package.
+			// (Or at least the ones that might contain references to the object.)
+			// Find and emit refs.
+			if inQueryPkg {
+				// Bundle the files together into a package.
+				// This does package-level object resolution.
+				qpkg, _ := ast.NewPackage(fset, deffiles, nil, nil)
+				// Look up the query object; we know that it is defined in the package scope.
+				pkgobj := qpkg.Scope.Objects[name]
+				if pkgobj == nil {
+					panic("missing defpkg object for " + defpkg + "." + name)
+				}
+				// Find all references to the query object.
+				var refs []*ast.Ident
+				ast.Inspect(qpkg, func(n ast.Node) bool {
+					if id, ok := n.(*ast.Ident); ok {
+						// Check both that this is a reference to the query object
+						// and that it is not the query object itself;
+						// the query object itself was already emitted.
+						if id.Obj == pkgobj && objpos != fset.Position(id.Pos()) {
+							refs = append(refs, id)
+							return false
+						}
+					}
+					return true
+				})
+				if len(refs) > 0 {
+					q.Output(fset, &referrersPackageResult{
+						pkg:   types.NewPackage(pkg.ImportPath, pkg.Name),
+						build: q.Build,
+						fset:  fset,
+						refs:  refs,
+					})
+				}
+				deffiles = nil // allow GC
+			}
+		}()
+	}
+
+	wg.Wait()
+
+	return nil
+}
+
+// findObject returns the object defined at the specified position.
+func findObject(fset *token.FileSet, info *types.Info, objposn token.Position) types.Object {
+	good := func(obj types.Object) bool {
+		if obj == nil {
+			return false
+		}
+		posn := fset.Position(obj.Pos())
+		return posn.Filename == objposn.Filename && posn.Offset == objposn.Offset
+	}
+	for _, obj := range info.Defs {
+		if good(obj) {
+			return obj
+		}
+	}
+	for _, obj := range info.Implicits {
+		if good(obj) {
+			return obj
+		}
+	}
+	return nil
+}
+
+// same reports whether x and y are identical, or both are PkgNames
+// that import the same Package.
+//
+func sameObj(x, y types.Object) bool {
+	if x == y {
+		return true
+	}
+	if x, ok := x.(*types.PkgName); ok {
+		if y, ok := y.(*types.PkgName); ok {
+			return x.Imported() == y.Imported()
+		}
+	}
+	return false
+}
+
+func clearInfoFields(info *loader.PackageInfo) {
+	// TODO(adonovan): opt: save memory by eliminating unneeded scopes/objects.
+	// (Requires go/types change for Go 1.7.)
+	//   info.Pkg.Scope().ClearChildren()
+
+	// Discard the file ASTs and their accumulated type
+	// information to save memory.
+	info.Files = nil
+	info.Defs = make(map[*ast.Ident]types.Object)
+	info.Uses = make(map[*ast.Ident]types.Object)
+	info.Implicits = make(map[ast.Node]types.Object)
+
+	// Also, disable future collection of wholly unneeded
+	// type information for the package in case there is
+	// more type-checking to do (augmentation).
+	info.Types = nil
+	info.Scopes = nil
+	info.Selections = nil
+}
+
+// -------- utils --------
+
+// An deterministic ordering for token.Pos that doesn't
+// depend on the order in which packages were loaded.
+func lessPos(fset *token.FileSet, x, y token.Pos) bool {
+	fx := fset.File(x)
+	fy := fset.File(y)
+	if fx != fy {
+		return fx.Name() < fy.Name()
+	}
+	return x < y
+}
+
+type byNamePos struct {
+	fset *token.FileSet
+	ids  []*ast.Ident
+}
+
+func (p byNamePos) Len() int      { return len(p.ids) }
+func (p byNamePos) Swap(i, j int) { p.ids[i], p.ids[j] = p.ids[j], p.ids[i] }
+func (p byNamePos) Less(i, j int) bool {
+	return lessPos(p.fset, p.ids[i].NamePos, p.ids[j].NamePos)
+}
+
+// referrersInitialResult is the initial result of a "referrers" query.
+type referrersInitialResult struct {
+	qinfo *loader.PackageInfo
+	obj   types.Object // object it denotes
+}
+
+func (r *referrersInitialResult) PrintPlain(printf printfFunc) {
+	printf(r.obj, "references to %s",
+		types.ObjectString(r.obj, types.RelativeTo(r.qinfo.Pkg)))
+}
+
+func (r *referrersInitialResult) JSON(fset *token.FileSet) []byte {
+	var objpos string
+	if pos := r.obj.Pos(); pos.IsValid() {
+		objpos = fset.Position(pos).String()
+	}
+	return toJSON(&serial.ReferrersInitial{
+		Desc:   r.obj.String(),
+		ObjPos: objpos,
+	})
+}
+
+// referrersPackageResult is the streaming result for one package of a "referrers" query.
+type referrersPackageResult struct {
+	pkg   *types.Package
+	build *build.Context
+	fset  *token.FileSet
+	refs  []*ast.Ident // set of all other references to it
+}
+
+// forEachRef calls f(id, text) for id in r.refs, in order.
+// Text is the text of the line on which id appears.
+func (r *referrersPackageResult) foreachRef(f func(id *ast.Ident, text string)) {
+	// Show referring lines, like grep.
+	type fileinfo struct {
+		refs     []*ast.Ident
+		linenums []int            // line number of refs[i]
+		data     chan interface{} // file contents or error
+	}
+	var fileinfos []*fileinfo
+	fileinfosByName := make(map[string]*fileinfo)
+
+	// First pass: start the file reads concurrently.
+	sema := make(chan struct{}, 20) // counting semaphore to limit I/O concurrency
+	for _, ref := range r.refs {
+		posn := r.fset.Position(ref.Pos())
+		fi := fileinfosByName[posn.Filename]
+		if fi == nil {
+			fi = &fileinfo{data: make(chan interface{})}
+			fileinfosByName[posn.Filename] = fi
+			fileinfos = append(fileinfos, fi)
+
+			// First request for this file:
+			// start asynchronous read.
+			go func() {
+				sema <- struct{}{} // acquire token
+				content, err := readFile(r.build, posn.Filename, nil)
+				<-sema // release token
+				if err != nil {
+					fi.data <- err
+				} else {
+					fi.data <- content
+				}
+			}()
+		}
+		fi.refs = append(fi.refs, ref)
+		fi.linenums = append(fi.linenums, posn.Line)
+	}
+
+	// Second pass: print refs in original order.
+	// One line may have several refs at different columns.
+	for _, fi := range fileinfos {
+		v := <-fi.data // wait for I/O completion
+
+		// Print one item for all refs in a file that could not
+		// be loaded (perhaps due to //line directives).
+		if err, ok := v.(error); ok {
+			var suffix string
+			if more := len(fi.refs) - 1; more > 0 {
+				suffix = fmt.Sprintf(" (+ %d more refs in this file)", more)
+			}
+			f(fi.refs[0], err.Error()+suffix)
+			continue
+		}
+
+		lines := bytes.Split(v.([]byte), []byte("\n"))
+		for i, ref := range fi.refs {
+			f(ref, string(lines[fi.linenums[i]-1]))
+		}
+	}
+}
+
+// readFile is like ioutil.ReadFile, but
+// it goes through the virtualized build.Context.
+// If non-nil, buf must have been reset.
+func readFile(ctxt *build.Context, filename string, buf *bytes.Buffer) ([]byte, error) {
+	rc, err := buildutil.OpenFile(ctxt, filename)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	if buf == nil {
+		buf = new(bytes.Buffer)
+	}
+	if _, err := io.Copy(buf, rc); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (r *referrersPackageResult) PrintPlain(printf printfFunc) {
+	r.foreachRef(func(id *ast.Ident, text string) {
+		printf(id, "%s", text)
+	})
+}
+
+func (r *referrersPackageResult) JSON(fset *token.FileSet) []byte {
+	refs := serial.ReferrersPackage{Package: r.pkg.Path()}
+	r.foreachRef(func(id *ast.Ident, text string) {
+		refs.Refs = append(refs.Refs, serial.Ref{
+			Pos:  fset.Position(id.NamePos).String(),
+			Text: text,
+		})
+	})
+	return toJSON(refs)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/serial/serial.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/serial/serial.go
new file mode 100644
index 00000000..95287977
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/serial/serial.go
@@ -0,0 +1,259 @@
+// 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 serial defines the guru's schema for -json output.
+//
+// The output of a guru query is a stream of one or more JSON objects.
+// This table shows the types of objects in the result stream for each
+// query type.
+//
+//      Query      Result stream
+//      -----      -------------
+//      callees    Callees
+//      callers    Caller ...
+//      callstack  CallStack
+//      definition Definition
+//      describe   Describe
+//      freevars   FreeVar ...
+//      implements Implements
+//      peers      Peers
+//      pointsto   PointsTo ...
+//      referrers  ReferrersInitial ReferrersPackage ...
+//      what       What
+//      whicherrs  WhichErrs
+//
+// All 'pos' strings in the output are of the form "file:line:col",
+// where line is the 1-based line number and col is the 1-based byte index.
+package serial
+
+// A Peers is the result of a 'peers' query.
+// If Allocs is empty, the selected channel can't point to anything.
+type Peers struct {
+	Pos      string   `json:"pos"`                // location of the selected channel op (<-)
+	Type     string   `json:"type"`               // type of the selected channel
+	Allocs   []string `json:"allocs,omitempty"`   // locations of aliased make(chan) ops
+	Sends    []string `json:"sends,omitempty"`    // locations of aliased ch<-x ops
+	Receives []string `json:"receives,omitempty"` // locations of aliased <-ch ops
+	Closes   []string `json:"closes,omitempty"`   // locations of aliased close(ch) ops
+}
+
+// A "referrers" query emits a ReferrersInitial object followed by zero or
+// more ReferrersPackage objects, one per package that contains a reference.
+type (
+	ReferrersInitial struct {
+		ObjPos string `json:"objpos,omitempty"` // location of the definition
+		Desc   string `json:"desc"`             // description of the denoted object
+	}
+	ReferrersPackage struct {
+		Package string `json:"package"`
+		Refs    []Ref  `json:"refs"` // non-empty list of references within this package
+	}
+	Ref struct {
+		Pos  string `json:"pos"`  // location of all references
+		Text string `json:"text"` // text of the referring line
+	}
+)
+
+// A Definition is the result of a 'definition' query.
+type Definition struct {
+	ObjPos string `json:"objpos,omitempty"` // location of the definition
+	Desc   string `json:"desc"`             // description of the denoted object
+}
+
+// A Callees is the result of a 'callees' query.
+//
+// Callees is nonempty unless the call was a dynamic call on a
+// provably nil func or interface value.
+type (
+	Callees struct {
+		Pos     string    `json:"pos"`  // location of selected call site
+		Desc    string    `json:"desc"` // description of call site
+		Callees []*Callee `json:"callees"`
+	}
+	Callee struct {
+		Name string `json:"name"` // full name of called function
+		Pos  string `json:"pos"`  // location of called function
+	}
+)
+
+// A Caller is one element of the slice returned by a 'callers' query.
+// (Callstack also contains a similar slice.)
+//
+// The root of the callgraph has an unspecified "Caller" string.
+type Caller struct {
+	Pos    string `json:"pos,omitempty"` // location of the calling function
+	Desc   string `json:"desc"`          // description of call site
+	Caller string `json:"caller"`        // full name of calling function
+}
+
+// A CallStack is the result of a 'callstack' query.
+// It indicates an arbitrary path from the root of the callgraph to
+// the query function.
+//
+// If the Callers slice is empty, the function was unreachable in this
+// analysis scope.
+type CallStack struct {
+	Pos     string   `json:"pos"`     // location of the selected function
+	Target  string   `json:"target"`  // the selected function
+	Callers []Caller `json:"callers"` // enclosing calls, innermost first.
+}
+
+// A FreeVar is one element of the slice returned by a 'freevars'
+// query.  Each one identifies an expression referencing a local
+// identifier defined outside the selected region.
+type FreeVar struct {
+	Pos  string `json:"pos"`  // location of the identifier's definition
+	Kind string `json:"kind"` // one of {var,func,type,const,label}
+	Ref  string `json:"ref"`  // referring expression (e.g. "x" or "x.y.z")
+	Type string `json:"type"` // type of the expression
+}
+
+// An Implements contains the result of an 'implements' query.
+// It describes the queried type, the set of named non-empty interface
+// types to which it is assignable, and the set of named/*named types
+// (concrete or non-empty interface) which may be assigned to it.
+//
+type Implements struct {
+	T                 ImplementsType   `json:"type,omitempty"`    // the queried type
+	AssignableTo      []ImplementsType `json:"to,omitempty"`      // types assignable to T
+	AssignableFrom    []ImplementsType `json:"from,omitempty"`    // interface types assignable from T
+	AssignableFromPtr []ImplementsType `json:"fromptr,omitempty"` // interface types assignable only from *T
+
+	// The following fields are set only if the query was a method.
+	// Assignable{To,From,FromPtr}Method[i] is the corresponding
+	// method of type Assignable{To,From,FromPtr}[i], or blank
+	// {"",""} if that type lacks the method.
+	Method                  *DescribeMethod  `json:"method,omitempty"` //  the queried method
+	AssignableToMethod      []DescribeMethod `json:"to_method,omitempty"`
+	AssignableFromMethod    []DescribeMethod `json:"from_method,omitempty"`
+	AssignableFromPtrMethod []DescribeMethod `json:"fromptr_method,omitempty"`
+}
+
+// An ImplementsType describes a single type as part of an 'implements' query.
+type ImplementsType struct {
+	Name string `json:"name"` // full name of the type
+	Pos  string `json:"pos"`  // location of its definition
+	Kind string `json:"kind"` // "basic", "array", etc
+}
+
+// A SyntaxNode is one element of a stack of enclosing syntax nodes in
+// a "what" query.
+type SyntaxNode struct {
+	Description string `json:"desc"`  // description of syntax tree
+	Start       int    `json:"start"` // start byte offset, 0-based
+	End         int    `json:"end"`   // end byte offset
+}
+
+// A What is the result of the "what" query, which quickly identifies
+// the selection, parsing only a single file.  It is intended for use
+// in low-latency GUIs.
+type What struct {
+	Enclosing  []SyntaxNode `json:"enclosing"`            // enclosing nodes of syntax tree
+	Modes      []string     `json:"modes"`                // query modes enabled for this selection.
+	SrcDir     string       `json:"srcdir,omitempty"`     // $GOROOT src directory containing queried package
+	ImportPath string       `json:"importpath,omitempty"` // import path of queried package
+	Object     string       `json:"object,omitempty"`     // name of identified object, if any
+	SameIDs    []string     `json:"sameids,omitempty"`    // locations of references to same object
+}
+
+// A PointsToLabel describes a pointer analysis label.
+//
+// A "label" is an object that may be pointed to by a pointer, map,
+// channel, 'func', slice or interface.  Labels include:
+//    - functions
+//    - globals
+//    - arrays created by literals (e.g. []byte("foo")) and conversions ([]byte(s))
+//    - stack- and heap-allocated variables (including composite literals)
+//    - arrays allocated by append()
+//    - channels, maps and arrays created by make()
+//    - and their subelements, e.g. "alloc.y[*].z"
+//
+type PointsToLabel struct {
+	Pos  string `json:"pos"`  // location of syntax that allocated the object
+	Desc string `json:"desc"` // description of the label
+}
+
+// A PointsTo is one element of the result of a 'pointsto' query on an
+// expression.  It describes a single pointer: its type and the set of
+// "labels" it points to.
+//
+// If the pointer is of interface type, it will have one PTS entry
+// describing each concrete type that it may contain.  For each
+// concrete type that is a pointer, the PTS entry describes the labels
+// it may point to.  The same is true for reflect.Values, except the
+// dynamic types needn't be concrete.
+//
+type PointsTo struct {
+	Type    string          `json:"type"`              // (concrete) type of the pointer
+	NamePos string          `json:"namepos,omitempty"` // location of type defn, if Named
+	Labels  []PointsToLabel `json:"labels,omitempty"`  // pointed-to objects
+}
+
+// A DescribeValue is the additional result of a 'describe' query
+// if the selection indicates a value or expression.
+type DescribeValue struct {
+	Type   string `json:"type"`             // type of the expression
+	Value  string `json:"value,omitempty"`  // value of the expression, if constant
+	ObjPos string `json:"objpos,omitempty"` // location of the definition, if an Ident
+}
+
+type DescribeMethod struct {
+	Name string `json:"name"` // method name, as defined by types.Selection.String()
+	Pos  string `json:"pos"`  // location of the method's definition
+}
+
+// A DescribeType is the additional result of a 'describe' query
+// if the selection indicates a type.
+type DescribeType struct {
+	Type    string           `json:"type"`              // the string form of the type
+	NamePos string           `json:"namepos,omitempty"` // location of definition of type, if named
+	NameDef string           `json:"namedef,omitempty"` // underlying definition of type, if named
+	Methods []DescribeMethod `json:"methods,omitempty"` // methods of the type
+}
+
+type DescribeMember struct {
+	Name    string           `json:"name"`              // name of member
+	Type    string           `json:"type,omitempty"`    // type of member (underlying, if 'type')
+	Value   string           `json:"value,omitempty"`   // value of member (if 'const')
+	Pos     string           `json:"pos"`               // location of definition of member
+	Kind    string           `json:"kind"`              // one of {var,const,func,type}
+	Methods []DescribeMethod `json:"methods,omitempty"` // methods (if member is a type)
+}
+
+// A DescribePackage is the additional result of a 'describe' if
+// the selection indicates a package.
+type DescribePackage struct {
+	Path    string            `json:"path"`              // import path of the package
+	Members []*DescribeMember `json:"members,omitempty"` // accessible members of the package
+}
+
+// A Describe is the result of a 'describe' query.
+// It may contain an element describing the selected semantic entity
+// in detail.
+type Describe struct {
+	Desc   string `json:"desc"`             // description of the selected syntax node
+	Pos    string `json:"pos"`              // location of the selected syntax node
+	Detail string `json:"detail,omitempty"` // one of {package, type, value}, or "".
+
+	// At most one of the following fields is populated:
+	// the one specified by 'detail'.
+	Package *DescribePackage `json:"package,omitempty"`
+	Type    *DescribeType    `json:"type,omitempty"`
+	Value   *DescribeValue   `json:"value,omitempty"`
+}
+
+// A WhichErrs is the result of a 'whicherrs' query.
+// It contains the position of the queried error and the possible globals,
+// constants, and types it may point to.
+type WhichErrs struct {
+	ErrPos    string          `json:"errpos,omitempty"`    // location of queried error
+	Globals   []string        `json:"globals,omitempty"`   // locations of globals
+	Constants []string        `json:"constants,omitempty"` // locations of constants
+	Types     []WhichErrsType `json:"types,omitempty"`     // Types
+}
+
+type WhichErrsType struct {
+	Type     string `json:"type,omitempty"`
+	Position string `json:"position,omitempty"`
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/what.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/what.go
new file mode 100644
index 00000000..fabc3e80
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/what.go
@@ -0,0 +1,282 @@
+// 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 main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/token"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// what reports all the information about the query selection that can be
+// obtained from parsing only its containing source file.
+// It is intended to be a very low-latency query callable from GUI
+// tools, e.g. to populate a menu of options of slower queries about
+// the selected location.
+//
+func what(q *Query) error {
+	qpos, err := fastQueryPos(q.Build, q.Pos)
+	if err != nil {
+		return err
+	}
+
+	// (ignore errors)
+	srcdir, importPath, _ := guessImportPath(qpos.fset.File(qpos.start).Name(), q.Build)
+
+	// Determine which query modes are applicable to the selection.
+	enable := map[string]bool{
+		"describe": true, // any syntax; always enabled
+	}
+
+	if qpos.end > qpos.start {
+		enable["freevars"] = true // nonempty selection?
+	}
+
+	for _, n := range qpos.path {
+		switch n := n.(type) {
+		case *ast.Ident:
+			enable["definition"] = true
+			enable["referrers"] = true
+			enable["implements"] = true
+		case *ast.CallExpr:
+			enable["callees"] = true
+		case *ast.FuncDecl:
+			enable["callers"] = true
+			enable["callstack"] = true
+		case *ast.SendStmt:
+			enable["peers"] = true
+		case *ast.UnaryExpr:
+			if n.Op == token.ARROW {
+				enable["peers"] = true
+			}
+		}
+
+		// For implements, we approximate findInterestingNode.
+		if _, ok := enable["implements"]; !ok {
+			switch n.(type) {
+			case *ast.ArrayType,
+				*ast.StructType,
+				*ast.FuncType,
+				*ast.InterfaceType,
+				*ast.MapType,
+				*ast.ChanType:
+				enable["implements"] = true
+			}
+		}
+
+		// For pointsto and whicherrs, we approximate findInterestingNode.
+		if _, ok := enable["pointsto"]; !ok {
+			switch n.(type) {
+			case ast.Stmt,
+				*ast.ArrayType,
+				*ast.StructType,
+				*ast.FuncType,
+				*ast.InterfaceType,
+				*ast.MapType,
+				*ast.ChanType:
+				// not an expression
+				enable["pointsto"] = false
+				enable["whicherrs"] = false
+
+			case ast.Expr, ast.Decl, *ast.ValueSpec:
+				// an expression, maybe
+				enable["pointsto"] = true
+				enable["whicherrs"] = true
+
+			default:
+				// Comment, Field, KeyValueExpr, etc: ascend.
+			}
+		}
+	}
+
+	// If we don't have an exact selection, disable modes that need one.
+	if !qpos.exact {
+		enable["callees"] = false
+		enable["pointsto"] = false
+		enable["whicherrs"] = false
+		enable["describe"] = false
+	}
+
+	var modes []string
+	for mode := range enable {
+		modes = append(modes, mode)
+	}
+	sort.Strings(modes)
+
+	// Find the object referred to by the selection (if it's an
+	// identifier) and report the position of each identifier
+	// that refers to the same object.
+	//
+	// This may return spurious matches (e.g. struct fields) because
+	// it uses the best-effort name resolution done by go/parser.
+	var sameids []token.Pos
+	var object string
+	if id, ok := qpos.path[0].(*ast.Ident); ok {
+		if id.Obj == nil {
+			// An unresolved identifier is potentially a package name.
+			// Resolve them with a simple importer (adds ~100µs).
+			importer := func(imports map[string]*ast.Object, path string) (*ast.Object, error) {
+				pkg, ok := imports[path]
+				if !ok {
+					pkg = &ast.Object{
+						Kind: ast.Pkg,
+						Name: filepath.Base(path), // a guess
+					}
+					imports[path] = pkg
+				}
+				return pkg, nil
+			}
+			f := qpos.path[len(qpos.path)-1].(*ast.File)
+			ast.NewPackage(qpos.fset, map[string]*ast.File{"": f}, importer, nil)
+		}
+
+		if id.Obj != nil {
+			object = id.Obj.Name
+			decl := qpos.path[len(qpos.path)-1]
+			ast.Inspect(decl, func(n ast.Node) bool {
+				if n, ok := n.(*ast.Ident); ok && n.Obj == id.Obj {
+					sameids = append(sameids, n.Pos())
+				}
+				return true
+			})
+		}
+	}
+
+	q.Output(qpos.fset, &whatResult{
+		path:       qpos.path,
+		srcdir:     srcdir,
+		importPath: importPath,
+		modes:      modes,
+		object:     object,
+		sameids:    sameids,
+	})
+	return nil
+}
+
+// guessImportPath finds the package containing filename, and returns
+// its source directory (an element of $GOPATH) and its import path
+// relative to it.
+//
+// TODO(adonovan): what about _test.go files that are not part of the
+// package?
+//
+func guessImportPath(filename string, buildContext *build.Context) (srcdir, importPath string, err error) {
+	absFile, err := filepath.Abs(filename)
+	if err != nil {
+		return "", "", fmt.Errorf("can't form absolute path of %s: %v", filename, err)
+	}
+
+	absFileDir := filepath.Dir(absFile)
+	resolvedAbsFileDir, err := filepath.EvalSymlinks(absFileDir)
+	if err != nil {
+		return "", "", fmt.Errorf("can't evaluate symlinks of %s: %v", absFileDir, err)
+	}
+
+	segmentedAbsFileDir := segments(resolvedAbsFileDir)
+	// Find the innermost directory in $GOPATH that encloses filename.
+	minD := 1024
+	for _, gopathDir := range buildContext.SrcDirs() {
+		absDir, err := filepath.Abs(gopathDir)
+		if err != nil {
+			continue // e.g. non-existent dir on $GOPATH
+		}
+		resolvedAbsDir, err := filepath.EvalSymlinks(absDir)
+		if err != nil {
+			continue // e.g. non-existent dir on $GOPATH
+		}
+
+		d := prefixLen(segments(resolvedAbsDir), segmentedAbsFileDir)
+		// If there are multiple matches,
+		// prefer the innermost enclosing directory
+		// (smallest d).
+		if d >= 0 && d < minD {
+			minD = d
+			srcdir = gopathDir
+			importPath = strings.Join(segmentedAbsFileDir[len(segmentedAbsFileDir)-minD:], string(os.PathSeparator))
+		}
+	}
+	if srcdir == "" {
+		return "", "", fmt.Errorf("directory %s is not beneath any of these GOROOT/GOPATH directories: %s",
+			filepath.Dir(absFile), strings.Join(buildContext.SrcDirs(), ", "))
+	}
+	if importPath == "" {
+		// This happens for e.g. $GOPATH/src/a.go, but
+		// "" is not a valid path for (*go/build).Import.
+		return "", "", fmt.Errorf("cannot load package in root of source directory %s", srcdir)
+	}
+	return srcdir, importPath, nil
+}
+
+func segments(path string) []string {
+	return strings.Split(path, string(os.PathSeparator))
+}
+
+// prefixLen returns the length of the remainder of y if x is a prefix
+// of y, a negative number otherwise.
+func prefixLen(x, y []string) int {
+	d := len(y) - len(x)
+	if d >= 0 {
+		for i := range x {
+			if y[i] != x[i] {
+				return -1 // not a prefix
+			}
+		}
+	}
+	return d
+}
+
+type whatResult struct {
+	path       []ast.Node
+	modes      []string
+	srcdir     string
+	importPath string
+	object     string
+	sameids    []token.Pos
+}
+
+func (r *whatResult) PrintPlain(printf printfFunc) {
+	for _, n := range r.path {
+		printf(n, "%s", astutil.NodeDescription(n))
+	}
+	printf(nil, "modes: %s", r.modes)
+	printf(nil, "srcdir: %s", r.srcdir)
+	printf(nil, "import path: %s", r.importPath)
+	for _, pos := range r.sameids {
+		printf(pos, "%s", r.object)
+	}
+}
+
+func (r *whatResult) JSON(fset *token.FileSet) []byte {
+	var enclosing []serial.SyntaxNode
+	for _, n := range r.path {
+		enclosing = append(enclosing, serial.SyntaxNode{
+			Description: astutil.NodeDescription(n),
+			Start:       fset.Position(n.Pos()).Offset,
+			End:         fset.Position(n.End()).Offset,
+		})
+	}
+
+	var sameids []string
+	for _, pos := range r.sameids {
+		sameids = append(sameids, fset.Position(pos).String())
+	}
+
+	return toJSON(&serial.What{
+		Modes:      r.modes,
+		SrcDir:     r.srcdir,
+		ImportPath: r.importPath,
+		Enclosing:  enclosing,
+		Object:     r.object,
+		SameIDs:    sameids,
+	})
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/whicherrs.go b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/whicherrs.go
new file mode 100644
index 00000000..3a81bf56
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/cmd/guru/whicherrs.go
@@ -0,0 +1,327 @@
+// 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.
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"sort"
+
+	"golang.org/x/tools/cmd/guru/serial"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/pointer"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+var builtinErrorType = types.Universe.Lookup("error").Type()
+
+// whicherrs takes an position to an error and tries to find all types, constants
+// and global value which a given error can point to and which can be checked from the
+// scope where the error lives.
+// In short, it returns a list of things that can be checked against in order to handle
+// an error properly.
+//
+// TODO(dmorsing): figure out if fields in errors like *os.PathError.Err
+// can be queried recursively somehow.
+func whicherrs(q *Query) error {
+	lconf := loader.Config{Build: q.Build}
+
+	if err := setPTAScope(&lconf, q.Scope); err != nil {
+		return err
+	}
+
+	// Load/parse/type-check the program.
+	lprog, err := loadWithSoftErrors(&lconf)
+	if err != nil {
+		return err
+	}
+
+	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
+	if err != nil {
+		return err
+	}
+
+	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
+
+	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
+	if err != nil {
+		return err
+	}
+
+	path, action := findInterestingNode(qpos.info, qpos.path)
+	if action != actionExpr {
+		return fmt.Errorf("whicherrs wants an expression; got %s",
+			astutil.NodeDescription(qpos.path[0]))
+	}
+	var expr ast.Expr
+	var obj types.Object
+	switch n := path[0].(type) {
+	case *ast.ValueSpec:
+		// ambiguous ValueSpec containing multiple names
+		return fmt.Errorf("multiple value specification")
+	case *ast.Ident:
+		obj = qpos.info.ObjectOf(n)
+		expr = n
+	case ast.Expr:
+		expr = n
+	default:
+		return fmt.Errorf("unexpected AST for expr: %T", n)
+	}
+
+	typ := qpos.info.TypeOf(expr)
+	if !types.Identical(typ, builtinErrorType) {
+		return fmt.Errorf("selection is not an expression of type 'error'")
+	}
+	// Determine the ssa.Value for the expression.
+	var value ssa.Value
+	if obj != nil {
+		// def/ref of func/var object
+		value, _, err = ssaValueForIdent(prog, qpos.info, obj, path)
+	} else {
+		value, _, err = ssaValueForExpr(prog, qpos.info, path)
+	}
+	if err != nil {
+		return err // e.g. trivially dead code
+	}
+
+	// Defer SSA construction till after errors are reported.
+	prog.Build()
+
+	globals := findVisibleErrs(prog, qpos)
+	constants := findVisibleConsts(prog, qpos)
+
+	res := &whicherrsResult{
+		qpos:   qpos,
+		errpos: expr.Pos(),
+	}
+
+	// TODO(adonovan): the following code is heavily duplicated
+	// w.r.t.  "pointsto".  Refactor?
+
+	// Find the instruction which initialized the
+	// global error. If more than one instruction has stored to the global
+	// remove the global from the set of values that we want to query.
+	allFuncs := ssautil.AllFunctions(prog)
+	for fn := range allFuncs {
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				store, ok := instr.(*ssa.Store)
+				if !ok {
+					continue
+				}
+				gval, ok := store.Addr.(*ssa.Global)
+				if !ok {
+					continue
+				}
+				gbl, ok := globals[gval]
+				if !ok {
+					continue
+				}
+				// we already found a store to this global
+				// The normal error define is just one store in the init
+				// so we just remove this global from the set we want to query
+				if gbl != nil {
+					delete(globals, gval)
+				}
+				globals[gval] = store.Val
+			}
+		}
+	}
+
+	ptaConfig.AddQuery(value)
+	for _, v := range globals {
+		ptaConfig.AddQuery(v)
+	}
+
+	ptares := ptrAnalysis(ptaConfig)
+	valueptr := ptares.Queries[value]
+	if valueptr == (pointer.Pointer{}) {
+		return fmt.Errorf("pointer analysis did not find expression (dead code?)")
+	}
+	for g, v := range globals {
+		ptr, ok := ptares.Queries[v]
+		if !ok {
+			continue
+		}
+		if !ptr.MayAlias(valueptr) {
+			continue
+		}
+		res.globals = append(res.globals, g)
+	}
+	pts := valueptr.PointsTo()
+	dedup := make(map[*ssa.NamedConst]bool)
+	for _, label := range pts.Labels() {
+		// These values are either MakeInterfaces or reflect
+		// generated interfaces. For the purposes of this
+		// analysis, we don't care about reflect generated ones
+		makeiface, ok := label.Value().(*ssa.MakeInterface)
+		if !ok {
+			continue
+		}
+		constval, ok := makeiface.X.(*ssa.Const)
+		if !ok {
+			continue
+		}
+		c := constants[*constval]
+		if c != nil && !dedup[c] {
+			dedup[c] = true
+			res.consts = append(res.consts, c)
+		}
+	}
+	concs := pts.DynamicTypes()
+	concs.Iterate(func(conc types.Type, _ interface{}) {
+		// go/types is a bit annoying here.
+		// We want to find all the types that we can
+		// typeswitch or assert to. This means finding out
+		// if the type pointed to can be seen by us.
+		//
+		// For the purposes of this analysis, we care only about
+		// TypeNames of Named or pointer-to-Named types.
+		// We ignore other types (e.g. structs) that implement error.
+		var name *types.TypeName
+		switch t := conc.(type) {
+		case *types.Pointer:
+			named, ok := t.Elem().(*types.Named)
+			if !ok {
+				return
+			}
+			name = named.Obj()
+		case *types.Named:
+			name = t.Obj()
+		default:
+			return
+		}
+		if !isAccessibleFrom(name, qpos.info.Pkg) {
+			return
+		}
+		res.types = append(res.types, &errorType{conc, name})
+	})
+	sort.Sort(membersByPosAndString(res.globals))
+	sort.Sort(membersByPosAndString(res.consts))
+	sort.Sort(sorterrorType(res.types))
+
+	q.Output(lprog.Fset, res)
+	return nil
+}
+
+// findVisibleErrs returns a mapping from each package-level variable of type "error" to nil.
+func findVisibleErrs(prog *ssa.Program, qpos *queryPos) map[*ssa.Global]ssa.Value {
+	globals := make(map[*ssa.Global]ssa.Value)
+	for _, pkg := range prog.AllPackages() {
+		for _, mem := range pkg.Members {
+			gbl, ok := mem.(*ssa.Global)
+			if !ok {
+				continue
+			}
+			gbltype := gbl.Type()
+			// globals are always pointers
+			if !types.Identical(deref(gbltype), builtinErrorType) {
+				continue
+			}
+			if !isAccessibleFrom(gbl.Object(), qpos.info.Pkg) {
+				continue
+			}
+			globals[gbl] = nil
+		}
+	}
+	return globals
+}
+
+// findVisibleConsts returns a mapping from each package-level constant assignable to type "error", to nil.
+func findVisibleConsts(prog *ssa.Program, qpos *queryPos) map[ssa.Const]*ssa.NamedConst {
+	constants := make(map[ssa.Const]*ssa.NamedConst)
+	for _, pkg := range prog.AllPackages() {
+		for _, mem := range pkg.Members {
+			obj, ok := mem.(*ssa.NamedConst)
+			if !ok {
+				continue
+			}
+			consttype := obj.Type()
+			if !types.AssignableTo(consttype, builtinErrorType) {
+				continue
+			}
+			if !isAccessibleFrom(obj.Object(), qpos.info.Pkg) {
+				continue
+			}
+			constants[*obj.Value] = obj
+		}
+	}
+
+	return constants
+}
+
+type membersByPosAndString []ssa.Member
+
+func (a membersByPosAndString) Len() int { return len(a) }
+func (a membersByPosAndString) Less(i, j int) bool {
+	cmp := a[i].Pos() - a[j].Pos()
+	return cmp < 0 || cmp == 0 && a[i].String() < a[j].String()
+}
+func (a membersByPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+type sorterrorType []*errorType
+
+func (a sorterrorType) Len() int { return len(a) }
+func (a sorterrorType) Less(i, j int) bool {
+	cmp := a[i].obj.Pos() - a[j].obj.Pos()
+	return cmp < 0 || cmp == 0 && a[i].typ.String() < a[j].typ.String()
+}
+func (a sorterrorType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+type errorType struct {
+	typ types.Type      // concrete type N or *N that implements error
+	obj *types.TypeName // the named type N
+}
+
+type whicherrsResult struct {
+	qpos    *queryPos
+	errpos  token.Pos
+	globals []ssa.Member
+	consts  []ssa.Member
+	types   []*errorType
+}
+
+func (r *whicherrsResult) PrintPlain(printf printfFunc) {
+	if len(r.globals) > 0 {
+		printf(r.qpos, "this error may point to these globals:")
+		for _, g := range r.globals {
+			printf(g.Pos(), "\t%s", g.RelString(r.qpos.info.Pkg))
+		}
+	}
+	if len(r.consts) > 0 {
+		printf(r.qpos, "this error may contain these constants:")
+		for _, c := range r.consts {
+			printf(c.Pos(), "\t%s", c.RelString(r.qpos.info.Pkg))
+		}
+	}
+	if len(r.types) > 0 {
+		printf(r.qpos, "this error may contain these dynamic types:")
+		for _, t := range r.types {
+			printf(t.obj.Pos(), "\t%s", r.qpos.typeString(t.typ))
+		}
+	}
+}
+
+func (r *whicherrsResult) JSON(fset *token.FileSet) []byte {
+	we := &serial.WhichErrs{}
+	we.ErrPos = fset.Position(r.errpos).String()
+	for _, g := range r.globals {
+		we.Globals = append(we.Globals, fset.Position(g.Pos()).String())
+	}
+	for _, c := range r.consts {
+		we.Constants = append(we.Constants, fset.Position(c.Pos()).String())
+	}
+	for _, t := range r.types {
+		var et serial.WhichErrsType
+		et.Type = r.qpos.typeString(t.typ)
+		et.Position = fset.Position(t.obj.Pos()).String()
+		we.Types = append(we.Types, et)
+	}
+	return toJSON(we)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.go b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.go
new file mode 100644
index 00000000..99ea813d
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.go
@@ -0,0 +1,20 @@
+// 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.
+
+// +build amd64,!appengine,!gccgo
+
+package intsets
+
+func popcnt(x word) int
+func havePOPCNT() bool
+
+var hasPOPCNT = havePOPCNT()
+
+// popcount returns the population count (number of set bits) of x.
+func popcount(x word) int {
+	if hasPOPCNT {
+		return popcnt(x)
+	}
+	return popcountTable(x) // faster than Hacker's Delight
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.s b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.s
new file mode 100644
index 00000000..05c3d6fb
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_amd64.s
@@ -0,0 +1,30 @@
+// 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.
+
+// +build amd64,!appengine,!gccgo
+
+#include "textflag.h"
+
+// func havePOPCNT() bool
+TEXT ·havePOPCNT(SB),4,$0
+	MOVQ	$1, AX
+	CPUID
+	SHRQ	$23, CX
+	ANDQ	$1, CX
+	MOVB	CX, ret+0(FP)
+	RET
+
+// func popcnt(word) int
+TEXT ·popcnt(SB),NOSPLIT,$0-8
+	XORQ	AX, AX
+	MOVQ	x+0(FP), SI
+	// POPCNT (SI), AX is not recognized by Go assembler,
+	// so we assemble it ourselves.
+	BYTE	$0xf3
+	BYTE	$0x48
+	BYTE	$0x0f
+	BYTE	$0xb8
+	BYTE	$0xc6
+	MOVQ	AX, ret+8(FP)
+	RET
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo.go b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo.go
new file mode 100644
index 00000000..82a8875c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo.go
@@ -0,0 +1,9 @@
+// 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.
+
+// +build gccgo
+
+package intsets
+
+func popcount(x word) int
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo_c.c b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo_c.c
new file mode 100644
index 00000000..08abb32e
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_gccgo_c.c
@@ -0,0 +1,19 @@
+// 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.
+
+// +build gccgo
+
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#define _STRINGIFY2_(x) #x
+#define _STRINGIFY_(x) _STRINGIFY2_(x)
+#define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)
+
+extern intptr_t popcount(uintptr_t x) __asm__(GOSYM_PREFIX GOPKGPATH ".popcount");
+
+intptr_t popcount(uintptr_t x) {
+	return __builtin_popcountl((unsigned long)(x));
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_generic.go b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_generic.go
new file mode 100644
index 00000000..3985a1da
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/popcnt_generic.go
@@ -0,0 +1,33 @@
+// 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.
+
+// +build !amd64 appengine
+// +build !gccgo
+
+package intsets
+
+import "runtime"
+
+// We compared three algorithms---Hacker's Delight, table lookup,
+// and AMD64's SSE4.1 hardware POPCNT---on a 2.67GHz Xeon X5550.
+//
+// % GOARCH=amd64 go test -run=NONE -bench=Popcount
+// POPCNT               5.12 ns/op
+// Table                8.53 ns/op
+// HackersDelight       9.96 ns/op
+//
+// % GOARCH=386 go test -run=NONE -bench=Popcount
+// Table               10.4  ns/op
+// HackersDelight       5.23 ns/op
+//
+// (AMD64's ABM1 hardware supports ntz and nlz too,
+// but they aren't critical.)
+
+// popcount returns the population count (number of set bits) of x.
+func popcount(x word) int {
+	if runtime.GOARCH == "386" {
+		return popcountHD(uint32(x))
+	}
+	return popcountTable(x)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/sparse.go b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/sparse.go
new file mode 100644
index 00000000..5db01c1a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/sparse.go
@@ -0,0 +1,1091 @@
+// 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.
+
+// Package intsets provides Sparse, a compact and fast representation
+// for sparse sets of int values.
+//
+// The time complexity of the operations Len, Insert, Remove and Has
+// is in O(n) but in practice those methods are faster and more
+// space-efficient than equivalent operations on sets based on the Go
+// map type.  The IsEmpty, Min, Max, Clear and TakeMin operations
+// require constant time.
+//
+package intsets // import "golang.org/x/tools/container/intsets"
+
+// TODO(adonovan):
+// - Add InsertAll(...int), RemoveAll(...int)
+// - Add 'bool changed' results for {Intersection,Difference}With too.
+//
+// TODO(adonovan): implement Dense, a dense bit vector with a similar API.
+// The space usage would be proportional to Max(), not Len(), and the
+// implementation would be based upon big.Int.
+//
+// TODO(adonovan): opt: make UnionWith and Difference faster.
+// These are the hot-spots for go/pointer.
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// A Sparse is a set of int values.
+// Sparse operations (even queries) are not concurrency-safe.
+//
+// The zero value for Sparse is a valid empty set.
+//
+// Sparse sets must be copied using the Copy method, not by assigning
+// a Sparse value.
+//
+type Sparse struct {
+	// An uninitialized Sparse represents an empty set.
+	// An empty set may also be represented by
+	//  root.next == root.prev == &root.
+	//
+	// The root is always the block with the smallest offset.
+	// It can be empty, but only if it is the only block; in that case, offset is
+	// MaxInt (which is not a valid offset).
+	root block
+}
+
+type word uintptr
+
+const (
+	_m            = ^word(0)
+	bitsPerWord   = 8 << (_m>>8&1 + _m>>16&1 + _m>>32&1)
+	bitsPerBlock  = 256 // optimal value for go/pointer solver performance
+	wordsPerBlock = bitsPerBlock / bitsPerWord
+)
+
+// Limit values of implementation-specific int type.
+const (
+	MaxInt = int(^uint(0) >> 1)
+	MinInt = -MaxInt - 1
+)
+
+// -- block ------------------------------------------------------------
+
+// A set is represented as a circular doubly-linked list of blocks,
+// each containing an offset and a bit array of fixed size
+// bitsPerBlock; the blocks are ordered by increasing offset.
+//
+// The set contains an element x iff the block whose offset is x - (x
+// mod bitsPerBlock) has the bit (x mod bitsPerBlock) set, where mod
+// is the Euclidean remainder.
+//
+// A block may only be empty transiently.
+//
+type block struct {
+	offset     int                 // offset mod bitsPerBlock == 0
+	bits       [wordsPerBlock]word // contains at least one set bit
+	next, prev *block              // doubly-linked list of blocks
+}
+
+// wordMask returns the word index (in block.bits)
+// and single-bit mask for the block's ith bit.
+func wordMask(i uint) (w uint, mask word) {
+	w = i / bitsPerWord
+	mask = 1 << (i % bitsPerWord)
+	return
+}
+
+// insert sets the block b's ith bit and
+// returns true if it was not already set.
+//
+func (b *block) insert(i uint) bool {
+	w, mask := wordMask(i)
+	if b.bits[w]&mask == 0 {
+		b.bits[w] |= mask
+		return true
+	}
+	return false
+}
+
+// remove clears the block's ith bit and
+// returns true if the bit was previously set.
+// NB: may leave the block empty.
+//
+func (b *block) remove(i uint) bool {
+	w, mask := wordMask(i)
+	if b.bits[w]&mask != 0 {
+		b.bits[w] &^= mask
+		return true
+	}
+	return false
+}
+
+// has reports whether the block's ith bit is set.
+func (b *block) has(i uint) bool {
+	w, mask := wordMask(i)
+	return b.bits[w]&mask != 0
+}
+
+// empty reports whether b.len()==0, but more efficiently.
+func (b *block) empty() bool {
+	for _, w := range b.bits {
+		if w != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// len returns the number of set bits in block b.
+func (b *block) len() int {
+	var l int
+	for _, w := range b.bits {
+		l += popcount(w)
+	}
+	return l
+}
+
+// max returns the maximum element of the block.
+// The block must not be empty.
+func (b *block) max() int {
+	bi := b.offset + bitsPerBlock
+	// Decrement bi by number of high zeros in last.bits.
+	for i := len(b.bits) - 1; i >= 0; i-- {
+		if w := b.bits[i]; w != 0 {
+			return bi - nlz(w) - 1
+		}
+		bi -= bitsPerWord
+	}
+	panic("BUG: empty block")
+}
+
+// min returns the minimum element of the block,
+// and also removes it if take is set.
+// The block must not be initially empty.
+// NB: may leave the block empty.
+func (b *block) min(take bool) int {
+	for i, w := range b.bits {
+		if w != 0 {
+			tz := ntz(w)
+			if take {
+				b.bits[i] = w &^ (1 << uint(tz))
+			}
+			return b.offset + int(i*bitsPerWord) + tz
+		}
+	}
+	panic("BUG: empty block")
+}
+
+// lowerBound returns the smallest element of the block that is greater than or
+// equal to the element corresponding to the ith bit. If there is no such
+// element, the second return value is false.
+func (b *block) lowerBound(i uint) (int, bool) {
+	w := i / bitsPerWord
+	bit := i % bitsPerWord
+
+	if val := b.bits[w] >> bit; val != 0 {
+		return b.offset + int(i) + ntz(val), true
+	}
+
+	for w++; w < wordsPerBlock; w++ {
+		if val := b.bits[w]; val != 0 {
+			return b.offset + int(w*bitsPerWord) + ntz(val), true
+		}
+	}
+
+	return 0, false
+}
+
+// forEach calls f for each element of block b.
+// f must not mutate b's enclosing Sparse.
+func (b *block) forEach(f func(int)) {
+	for i, w := range b.bits {
+		offset := b.offset + i*bitsPerWord
+		for bi := 0; w != 0 && bi < bitsPerWord; bi++ {
+			if w&1 != 0 {
+				f(offset)
+			}
+			offset++
+			w >>= 1
+		}
+	}
+}
+
+// offsetAndBitIndex returns the offset of the block that would
+// contain x and the bit index of x within that block.
+//
+func offsetAndBitIndex(x int) (int, uint) {
+	mod := x % bitsPerBlock
+	if mod < 0 {
+		// Euclidean (non-negative) remainder
+		mod += bitsPerBlock
+	}
+	return x - mod, uint(mod)
+}
+
+// -- Sparse --------------------------------------------------------------
+
+// none is a shared, empty, sentinel block that indicates the end of a block
+// list.
+var none block
+
+// Dummy type used to generate an implicit panic. This must be defined at the
+// package level; if it is defined inside a function, it prevents the inlining
+// of that function.
+type to_copy_a_sparse_you_must_call_its_Copy_method struct{}
+
+// init ensures s is properly initialized.
+func (s *Sparse) init() {
+	root := &s.root
+	if root.next == nil {
+		root.offset = MaxInt
+		root.next = root
+		root.prev = root
+	} else if root.next.prev != root {
+		// Copying a Sparse x leads to pernicious corruption: the
+		// new Sparse y shares the old linked list, but iteration
+		// on y will never encounter &y.root so it goes into a
+		// loop.  Fail fast before this occurs.
+		// We don't want to call panic here because it prevents the
+		// inlining of this function.
+		_ = (interface{}(nil)).(to_copy_a_sparse_you_must_call_its_Copy_method)
+	}
+}
+
+func (s *Sparse) first() *block {
+	s.init()
+	if s.root.offset == MaxInt {
+		return &none
+	}
+	return &s.root
+}
+
+// next returns the next block in the list, or end if b is the last block.
+func (s *Sparse) next(b *block) *block {
+	if b.next == &s.root {
+		return &none
+	}
+	return b.next
+}
+
+// prev returns the previous block in the list, or end if b is the first block.
+func (s *Sparse) prev(b *block) *block {
+	if b.prev == &s.root {
+		return &none
+	}
+	return b.prev
+}
+
+// IsEmpty reports whether the set s is empty.
+func (s *Sparse) IsEmpty() bool {
+	return s.root.next == nil || s.root.offset == MaxInt
+}
+
+// Len returns the number of elements in the set s.
+func (s *Sparse) Len() int {
+	var l int
+	for b := s.first(); b != &none; b = s.next(b) {
+		l += b.len()
+	}
+	return l
+}
+
+// Max returns the maximum element of the set s, or MinInt if s is empty.
+func (s *Sparse) Max() int {
+	if s.IsEmpty() {
+		return MinInt
+	}
+	return s.root.prev.max()
+}
+
+// Min returns the minimum element of the set s, or MaxInt if s is empty.
+func (s *Sparse) Min() int {
+	if s.IsEmpty() {
+		return MaxInt
+	}
+	return s.root.min(false)
+}
+
+// LowerBound returns the smallest element >= x, or MaxInt if there is no such
+// element.
+func (s *Sparse) LowerBound(x int) int {
+	offset, i := offsetAndBitIndex(x)
+	for b := s.first(); b != &none; b = s.next(b) {
+		if b.offset > offset {
+			return b.min(false)
+		}
+		if b.offset == offset {
+			if y, ok := b.lowerBound(i); ok {
+				return y
+			}
+		}
+	}
+	return MaxInt
+}
+
+// block returns the block that would contain offset,
+// or nil if s contains no such block.
+// Precondition: offset is a multiple of bitsPerBlock.
+func (s *Sparse) block(offset int) *block {
+	for b := s.first(); b != &none && b.offset <= offset; b = s.next(b) {
+		if b.offset == offset {
+			return b
+		}
+	}
+	return nil
+}
+
+// Insert adds x to the set s, and reports whether the set grew.
+func (s *Sparse) Insert(x int) bool {
+	offset, i := offsetAndBitIndex(x)
+
+	b := s.first()
+	for ; b != &none && b.offset <= offset; b = s.next(b) {
+		if b.offset == offset {
+			return b.insert(i)
+		}
+	}
+
+	// Insert new block before b.
+	new := s.insertBlockBefore(b)
+	new.offset = offset
+	return new.insert(i)
+}
+
+// removeBlock removes a block and returns the block that followed it (or end if
+// it was the last block).
+func (s *Sparse) removeBlock(b *block) *block {
+	if b != &s.root {
+		b.prev.next = b.next
+		b.next.prev = b.prev
+		if b.next == &s.root {
+			return &none
+		}
+		return b.next
+	}
+
+	first := s.root.next
+	if first == &s.root {
+		// This was the only block.
+		s.Clear()
+		return &none
+	}
+	s.root.offset = first.offset
+	s.root.bits = first.bits
+	if first.next == &s.root {
+		// Single block remaining.
+		s.root.next = &s.root
+		s.root.prev = &s.root
+	} else {
+		s.root.next = first.next
+		first.next.prev = &s.root
+	}
+	return &s.root
+}
+
+// Remove removes x from the set s, and reports whether the set shrank.
+func (s *Sparse) Remove(x int) bool {
+	offset, i := offsetAndBitIndex(x)
+	if b := s.block(offset); b != nil {
+		if !b.remove(i) {
+			return false
+		}
+		if b.empty() {
+			s.removeBlock(b)
+		}
+		return true
+	}
+	return false
+}
+
+// Clear removes all elements from the set s.
+func (s *Sparse) Clear() {
+	s.root = block{
+		offset: MaxInt,
+		next:   &s.root,
+		prev:   &s.root,
+	}
+}
+
+// If set s is non-empty, TakeMin sets *p to the minimum element of
+// the set s, removes that element from the set and returns true.
+// Otherwise, it returns false and *p is undefined.
+//
+// This method may be used for iteration over a worklist like so:
+//
+// 	var x int
+// 	for worklist.TakeMin(&x) { use(x) }
+//
+func (s *Sparse) TakeMin(p *int) bool {
+	if s.IsEmpty() {
+		return false
+	}
+	*p = s.root.min(true)
+	if s.root.empty() {
+		s.removeBlock(&s.root)
+	}
+	return true
+}
+
+// Has reports whether x is an element of the set s.
+func (s *Sparse) Has(x int) bool {
+	offset, i := offsetAndBitIndex(x)
+	if b := s.block(offset); b != nil {
+		return b.has(i)
+	}
+	return false
+}
+
+// forEach applies function f to each element of the set s in order.
+//
+// f must not mutate s.  Consequently, forEach is not safe to expose
+// to clients.  In any case, using "range s.AppendTo()" allows more
+// natural control flow with continue/break/return.
+//
+func (s *Sparse) forEach(f func(int)) {
+	for b := s.first(); b != &none; b = s.next(b) {
+		b.forEach(f)
+	}
+}
+
+// Copy sets s to the value of x.
+func (s *Sparse) Copy(x *Sparse) {
+	if s == x {
+		return
+	}
+
+	xb := x.first()
+	sb := s.first()
+	for xb != &none {
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = xb.offset
+		sb.bits = xb.bits
+		xb = x.next(xb)
+		sb = s.next(sb)
+	}
+	s.discardTail(sb)
+}
+
+// insertBlockBefore returns a new block, inserting it before next.
+// If next is the root, the root is replaced. If next is end, the block is
+// inserted at the end.
+func (s *Sparse) insertBlockBefore(next *block) *block {
+	if s.IsEmpty() {
+		if next != &none {
+			panic("BUG: passed block with empty set")
+		}
+		return &s.root
+	}
+
+	if next == &s.root {
+		// Special case: we need to create a new block that will become the root
+		// block.The old root block becomes the second block.
+		second := s.root
+		s.root = block{
+			next: &second,
+		}
+		if second.next == &s.root {
+			s.root.prev = &second
+		} else {
+			s.root.prev = second.prev
+			second.next.prev = &second
+			second.prev = &s.root
+		}
+		return &s.root
+	}
+	if next == &none {
+		// Insert before root.
+		next = &s.root
+	}
+	b := new(block)
+	b.next = next
+	b.prev = next.prev
+	b.prev.next = b
+	next.prev = b
+	return b
+}
+
+// discardTail removes block b and all its successors from s.
+func (s *Sparse) discardTail(b *block) {
+	if b != &none {
+		if b == &s.root {
+			s.Clear()
+		} else {
+			b.prev.next = &s.root
+			s.root.prev = b.prev
+		}
+	}
+}
+
+// IntersectionWith sets s to the intersection s ∩ x.
+func (s *Sparse) IntersectionWith(x *Sparse) {
+	if s == x {
+		return
+	}
+
+	xb := x.first()
+	sb := s.first()
+	for xb != &none && sb != &none {
+		switch {
+		case xb.offset < sb.offset:
+			xb = x.next(xb)
+
+		case xb.offset > sb.offset:
+			sb = s.removeBlock(sb)
+
+		default:
+			var sum word
+			for i := range sb.bits {
+				r := xb.bits[i] & sb.bits[i]
+				sb.bits[i] = r
+				sum |= r
+			}
+			if sum != 0 {
+				sb = s.next(sb)
+			} else {
+				// sb will be overwritten or removed
+			}
+
+			xb = x.next(xb)
+		}
+	}
+
+	s.discardTail(sb)
+}
+
+// Intersection sets s to the intersection x ∩ y.
+func (s *Sparse) Intersection(x, y *Sparse) {
+	switch {
+	case s == x:
+		s.IntersectionWith(y)
+		return
+	case s == y:
+		s.IntersectionWith(x)
+		return
+	case x == y:
+		s.Copy(x)
+		return
+	}
+
+	xb := x.first()
+	yb := y.first()
+	sb := s.first()
+	for xb != &none && yb != &none {
+		switch {
+		case xb.offset < yb.offset:
+			xb = x.next(xb)
+			continue
+		case xb.offset > yb.offset:
+			yb = y.next(yb)
+			continue
+		}
+
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = xb.offset
+
+		var sum word
+		for i := range sb.bits {
+			r := xb.bits[i] & yb.bits[i]
+			sb.bits[i] = r
+			sum |= r
+		}
+		if sum != 0 {
+			sb = s.next(sb)
+		} else {
+			// sb will be overwritten or removed
+		}
+
+		xb = x.next(xb)
+		yb = y.next(yb)
+	}
+
+	s.discardTail(sb)
+}
+
+// Intersects reports whether s ∩ x ≠ ∅.
+func (s *Sparse) Intersects(x *Sparse) bool {
+	sb := s.first()
+	xb := x.first()
+	for sb != &none && xb != &none {
+		switch {
+		case xb.offset < sb.offset:
+			xb = x.next(xb)
+		case xb.offset > sb.offset:
+			sb = s.next(sb)
+		default:
+			for i := range sb.bits {
+				if sb.bits[i]&xb.bits[i] != 0 {
+					return true
+				}
+			}
+			sb = s.next(sb)
+			xb = x.next(xb)
+		}
+	}
+	return false
+}
+
+// UnionWith sets s to the union s ∪ x, and reports whether s grew.
+func (s *Sparse) UnionWith(x *Sparse) bool {
+	if s == x {
+		return false
+	}
+
+	var changed bool
+	xb := x.first()
+	sb := s.first()
+	for xb != &none {
+		if sb != &none && sb.offset == xb.offset {
+			for i := range xb.bits {
+				if sb.bits[i] != xb.bits[i] {
+					sb.bits[i] |= xb.bits[i]
+					changed = true
+				}
+			}
+			xb = x.next(xb)
+		} else if sb == &none || sb.offset > xb.offset {
+			sb = s.insertBlockBefore(sb)
+			sb.offset = xb.offset
+			sb.bits = xb.bits
+			changed = true
+
+			xb = x.next(xb)
+		}
+		sb = s.next(sb)
+	}
+	return changed
+}
+
+// Union sets s to the union x ∪ y.
+func (s *Sparse) Union(x, y *Sparse) {
+	switch {
+	case x == y:
+		s.Copy(x)
+		return
+	case s == x:
+		s.UnionWith(y)
+		return
+	case s == y:
+		s.UnionWith(x)
+		return
+	}
+
+	xb := x.first()
+	yb := y.first()
+	sb := s.first()
+	for xb != &none || yb != &none {
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		switch {
+		case yb == &none || (xb != &none && xb.offset < yb.offset):
+			sb.offset = xb.offset
+			sb.bits = xb.bits
+			xb = x.next(xb)
+
+		case xb == &none || (yb != &none && yb.offset < xb.offset):
+			sb.offset = yb.offset
+			sb.bits = yb.bits
+			yb = y.next(yb)
+
+		default:
+			sb.offset = xb.offset
+			for i := range xb.bits {
+				sb.bits[i] = xb.bits[i] | yb.bits[i]
+			}
+			xb = x.next(xb)
+			yb = y.next(yb)
+		}
+		sb = s.next(sb)
+	}
+
+	s.discardTail(sb)
+}
+
+// DifferenceWith sets s to the difference s ∖ x.
+func (s *Sparse) DifferenceWith(x *Sparse) {
+	if s == x {
+		s.Clear()
+		return
+	}
+
+	xb := x.first()
+	sb := s.first()
+	for xb != &none && sb != &none {
+		switch {
+		case xb.offset > sb.offset:
+			sb = s.next(sb)
+
+		case xb.offset < sb.offset:
+			xb = x.next(xb)
+
+		default:
+			var sum word
+			for i := range sb.bits {
+				r := sb.bits[i] & ^xb.bits[i]
+				sb.bits[i] = r
+				sum |= r
+			}
+			if sum == 0 {
+				sb = s.removeBlock(sb)
+			} else {
+				sb = s.next(sb)
+			}
+			xb = x.next(xb)
+		}
+	}
+}
+
+// Difference sets s to the difference x ∖ y.
+func (s *Sparse) Difference(x, y *Sparse) {
+	switch {
+	case x == y:
+		s.Clear()
+		return
+	case s == x:
+		s.DifferenceWith(y)
+		return
+	case s == y:
+		var y2 Sparse
+		y2.Copy(y)
+		s.Difference(x, &y2)
+		return
+	}
+
+	xb := x.first()
+	yb := y.first()
+	sb := s.first()
+	for xb != &none && yb != &none {
+		if xb.offset > yb.offset {
+			// y has block, x has &none
+			yb = y.next(yb)
+			continue
+		}
+
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = xb.offset
+
+		switch {
+		case xb.offset < yb.offset:
+			// x has block, y has &none
+			sb.bits = xb.bits
+
+			sb = s.next(sb)
+
+		default:
+			// x and y have corresponding blocks
+			var sum word
+			for i := range sb.bits {
+				r := xb.bits[i] & ^yb.bits[i]
+				sb.bits[i] = r
+				sum |= r
+			}
+			if sum != 0 {
+				sb = s.next(sb)
+			} else {
+				// sb will be overwritten or removed
+			}
+
+			yb = y.next(yb)
+		}
+		xb = x.next(xb)
+	}
+
+	for xb != &none {
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = xb.offset
+		sb.bits = xb.bits
+		sb = s.next(sb)
+
+		xb = x.next(xb)
+	}
+
+	s.discardTail(sb)
+}
+
+// SymmetricDifferenceWith sets s to the symmetric difference s ∆ x.
+func (s *Sparse) SymmetricDifferenceWith(x *Sparse) {
+	if s == x {
+		s.Clear()
+		return
+	}
+
+	sb := s.first()
+	xb := x.first()
+	for xb != &none && sb != &none {
+		switch {
+		case sb.offset < xb.offset:
+			sb = s.next(sb)
+		case xb.offset < sb.offset:
+			nb := s.insertBlockBefore(sb)
+			nb.offset = xb.offset
+			nb.bits = xb.bits
+			xb = x.next(xb)
+		default:
+			var sum word
+			for i := range sb.bits {
+				r := sb.bits[i] ^ xb.bits[i]
+				sb.bits[i] = r
+				sum |= r
+			}
+			if sum == 0 {
+				sb = s.removeBlock(sb)
+			} else {
+				sb = s.next(sb)
+			}
+			xb = x.next(xb)
+		}
+	}
+
+	for xb != &none { // append the tail of x to s
+		sb = s.insertBlockBefore(sb)
+		sb.offset = xb.offset
+		sb.bits = xb.bits
+		sb = s.next(sb)
+		xb = x.next(xb)
+	}
+}
+
+// SymmetricDifference sets s to the symmetric difference x ∆ y.
+func (s *Sparse) SymmetricDifference(x, y *Sparse) {
+	switch {
+	case x == y:
+		s.Clear()
+		return
+	case s == x:
+		s.SymmetricDifferenceWith(y)
+		return
+	case s == y:
+		s.SymmetricDifferenceWith(x)
+		return
+	}
+
+	sb := s.first()
+	xb := x.first()
+	yb := y.first()
+	for xb != &none && yb != &none {
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		switch {
+		case yb.offset < xb.offset:
+			sb.offset = yb.offset
+			sb.bits = yb.bits
+			sb = s.next(sb)
+			yb = y.next(yb)
+		case xb.offset < yb.offset:
+			sb.offset = xb.offset
+			sb.bits = xb.bits
+			sb = s.next(sb)
+			xb = x.next(xb)
+		default:
+			var sum word
+			for i := range sb.bits {
+				r := xb.bits[i] ^ yb.bits[i]
+				sb.bits[i] = r
+				sum |= r
+			}
+			if sum != 0 {
+				sb.offset = xb.offset
+				sb = s.next(sb)
+			}
+			xb = x.next(xb)
+			yb = y.next(yb)
+		}
+	}
+
+	for xb != &none { // append the tail of x to s
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = xb.offset
+		sb.bits = xb.bits
+		sb = s.next(sb)
+		xb = x.next(xb)
+	}
+
+	for yb != &none { // append the tail of y to s
+		if sb == &none {
+			sb = s.insertBlockBefore(sb)
+		}
+		sb.offset = yb.offset
+		sb.bits = yb.bits
+		sb = s.next(sb)
+		yb = y.next(yb)
+	}
+
+	s.discardTail(sb)
+}
+
+// SubsetOf reports whether s ∖ x = ∅.
+func (s *Sparse) SubsetOf(x *Sparse) bool {
+	if s == x {
+		return true
+	}
+
+	sb := s.first()
+	xb := x.first()
+	for sb != &none {
+		switch {
+		case xb == &none || xb.offset > sb.offset:
+			return false
+		case xb.offset < sb.offset:
+			xb = x.next(xb)
+		default:
+			for i := range sb.bits {
+				if sb.bits[i]&^xb.bits[i] != 0 {
+					return false
+				}
+			}
+			sb = s.next(sb)
+			xb = x.next(xb)
+		}
+	}
+	return true
+}
+
+// Equals reports whether the sets s and t have the same elements.
+func (s *Sparse) Equals(t *Sparse) bool {
+	if s == t {
+		return true
+	}
+	sb := s.first()
+	tb := t.first()
+	for {
+		switch {
+		case sb == &none && tb == &none:
+			return true
+		case sb == &none || tb == &none:
+			return false
+		case sb.offset != tb.offset:
+			return false
+		case sb.bits != tb.bits:
+			return false
+		}
+
+		sb = s.next(sb)
+		tb = t.next(tb)
+	}
+}
+
+// String returns a human-readable description of the set s.
+func (s *Sparse) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('{')
+	s.forEach(func(x int) {
+		if buf.Len() > 1 {
+			buf.WriteByte(' ')
+		}
+		fmt.Fprintf(&buf, "%d", x)
+	})
+	buf.WriteByte('}')
+	return buf.String()
+}
+
+// BitString returns the set as a string of 1s and 0s denoting the sum
+// of the i'th powers of 2, for each i in s.  A radix point, always
+// preceded by a digit, appears if the sum is non-integral.
+//
+// Examples:
+//              {}.BitString() =      "0"
+//           {4,5}.BitString() = "110000"
+//            {-3}.BitString() =      "0.001"
+//      {-3,0,4,5}.BitString() = "110001.001"
+//
+func (s *Sparse) BitString() string {
+	if s.IsEmpty() {
+		return "0"
+	}
+
+	min, max := s.Min(), s.Max()
+	var nbytes int
+	if max > 0 {
+		nbytes = max
+	}
+	nbytes++ // zero bit
+	radix := nbytes
+	if min < 0 {
+		nbytes += len(".") - min
+	}
+
+	b := make([]byte, nbytes)
+	for i := range b {
+		b[i] = '0'
+	}
+	if radix < nbytes {
+		b[radix] = '.'
+	}
+	s.forEach(func(x int) {
+		if x >= 0 {
+			x += len(".")
+		}
+		b[radix-x] = '1'
+	})
+	return string(b)
+}
+
+// GoString returns a string showing the internal representation of
+// the set s.
+//
+func (s *Sparse) GoString() string {
+	var buf bytes.Buffer
+	for b := s.first(); b != &none; b = s.next(b) {
+		fmt.Fprintf(&buf, "block %p {offset=%d next=%p prev=%p",
+			b, b.offset, b.next, b.prev)
+		for _, w := range b.bits {
+			fmt.Fprintf(&buf, " 0%016x", w)
+		}
+		fmt.Fprintf(&buf, "}\n")
+	}
+	return buf.String()
+}
+
+// AppendTo returns the result of appending the elements of s to slice
+// in order.
+func (s *Sparse) AppendTo(slice []int) []int {
+	s.forEach(func(x int) {
+		slice = append(slice, x)
+	})
+	return slice
+}
+
+// -- Testing/debugging ------------------------------------------------
+
+// check returns an error if the representation invariants of s are violated.
+func (s *Sparse) check() error {
+	s.init()
+	if s.root.empty() {
+		// An empty set must have only the root block with offset MaxInt.
+		if s.root.next != &s.root {
+			return fmt.Errorf("multiple blocks with empty root block")
+		}
+		if s.root.offset != MaxInt {
+			return fmt.Errorf("empty set has offset %d, should be MaxInt", s.root.offset)
+		}
+		return nil
+	}
+	for b := s.first(); ; b = s.next(b) {
+		if b.offset%bitsPerBlock != 0 {
+			return fmt.Errorf("bad offset modulo: %d", b.offset)
+		}
+		if b.empty() {
+			return fmt.Errorf("empty block")
+		}
+		if b.prev.next != b {
+			return fmt.Errorf("bad prev.next link")
+		}
+		if b.next.prev != b {
+			return fmt.Errorf("bad next.prev link")
+		}
+		if b.next == &s.root {
+			break
+		}
+		if b.offset >= b.next.offset {
+			return fmt.Errorf("bad offset order: b.offset=%d, b.next.offset=%d",
+				b.offset, b.next.offset)
+		}
+	}
+	return nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/container/intsets/util.go b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/util.go
new file mode 100644
index 00000000..dd1db86b
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/container/intsets/util.go
@@ -0,0 +1,84 @@
+// 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 intsets
+
+// From Hacker's Delight, fig 5.2.
+func popcountHD(x uint32) int {
+	x -= (x >> 1) & 0x55555555
+	x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
+	x = (x + (x >> 4)) & 0x0f0f0f0f
+	x = x + (x >> 8)
+	x = x + (x >> 16)
+	return int(x & 0x0000003f)
+}
+
+var a [1 << 8]byte
+
+func init() {
+	for i := range a {
+		var n byte
+		for x := i; x != 0; x >>= 1 {
+			if x&1 != 0 {
+				n++
+			}
+		}
+		a[i] = n
+	}
+}
+
+func popcountTable(x word) int {
+	return int(a[byte(x>>(0*8))] +
+		a[byte(x>>(1*8))] +
+		a[byte(x>>(2*8))] +
+		a[byte(x>>(3*8))] +
+		a[byte(x>>(4*8))] +
+		a[byte(x>>(5*8))] +
+		a[byte(x>>(6*8))] +
+		a[byte(x>>(7*8))])
+}
+
+// nlz returns the number of leading zeros of x.
+// From Hacker's Delight, fig 5.11.
+func nlz(x word) int {
+	x |= (x >> 1)
+	x |= (x >> 2)
+	x |= (x >> 4)
+	x |= (x >> 8)
+	x |= (x >> 16)
+	x |= (x >> 32)
+	return popcount(^x)
+}
+
+// ntz returns the number of trailing zeros of x.
+// From Hacker's Delight, fig 5.13.
+func ntz(x word) int {
+	if x == 0 {
+		return bitsPerWord
+	}
+	n := 1
+	if bitsPerWord == 64 {
+		if (x & 0xffffffff) == 0 {
+			n = n + 32
+			x = x >> 32
+		}
+	}
+	if (x & 0x0000ffff) == 0 {
+		n = n + 16
+		x = x >> 16
+	}
+	if (x & 0x000000ff) == 0 {
+		n = n + 8
+		x = x >> 8
+	}
+	if (x & 0x0000000f) == 0 {
+		n = n + 4
+		x = x >> 4
+	}
+	if (x & 0x00000003) == 0 {
+		n = n + 2
+		x = x >> 2
+	}
+	return n - int(x&1)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go b/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
new file mode 100644
index 00000000..6b7052b8
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/imports.go b/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/imports.go
new file mode 100644
index 00000000..83f196cd
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go b/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go
new file mode 100644
index 00000000..cf72ea99
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go
@@ -0,0 +1,477 @@
+// 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.
+
+package astutil
+
+import (
+	"fmt"
+	"go/ast"
+	"reflect"
+	"sort"
+)
+
+// An ApplyFunc is invoked by Apply for each node n, even if n is nil,
+// before and/or after the node's children, using a Cursor describing
+// the current node and providing operations on it.
+//
+// The return value of ApplyFunc controls the syntax tree traversal.
+// See Apply for details.
+type ApplyFunc func(*Cursor) bool
+
+// Apply traverses a syntax tree recursively, starting with root,
+// and calling pre and post for each node as described below.
+// Apply returns the syntax tree, possibly modified.
+//
+// If pre is not nil, it is called for each node before the node's
+// children are traversed (pre-order). If pre returns false, no
+// children are traversed, and post is not called for that node.
+//
+// If post is not nil, and a prior call of pre didn't return false,
+// post is called for each node after its children are traversed
+// (post-order). If post returns false, traversal is terminated and
+// Apply returns immediately.
+//
+// Only fields that refer to AST nodes are considered children;
+// i.e., token.Pos, Scopes, Objects, and fields of basic types
+// (strings, etc.) are ignored.
+//
+// Children are traversed in the order in which they appear in the
+// respective node's struct definition. A package's files are
+// traversed in the filenames' alphabetical order.
+//
+func Apply(root ast.Node, pre, post ApplyFunc) (result ast.Node) {
+	parent := &struct{ ast.Node }{root}
+	defer func() {
+		if r := recover(); r != nil && r != abort {
+			panic(r)
+		}
+		result = parent.Node
+	}()
+	a := &application{pre: pre, post: post}
+	a.apply(parent, "Node", nil, root)
+	return
+}
+
+var abort = new(int) // singleton, to signal termination of Apply
+
+// A Cursor describes a node encountered during Apply.
+// Information about the node and its parent is available
+// from the Node, Parent, Name, and Index methods.
+//
+// If p is a variable of type and value of the current parent node
+// c.Parent(), and f is the field identifier with name c.Name(),
+// the following invariants hold:
+//
+//   p.f            == c.Node()  if c.Index() <  0
+//   p.f[c.Index()] == c.Node()  if c.Index() >= 0
+//
+// The methods Replace, Delete, InsertBefore, and InsertAfter
+// can be used to change the AST without disrupting Apply.
+type Cursor struct {
+	parent ast.Node
+	name   string
+	iter   *iterator // valid if non-nil
+	node   ast.Node
+}
+
+// Node returns the current Node.
+func (c *Cursor) Node() ast.Node { return c.node }
+
+// Parent returns the parent of the current Node.
+func (c *Cursor) Parent() ast.Node { return c.parent }
+
+// Name returns the name of the parent Node field that contains the current Node.
+// If the parent is a *ast.Package and the current Node is a *ast.File, Name returns
+// the filename for the current Node.
+func (c *Cursor) Name() string { return c.name }
+
+// Index reports the index >= 0 of the current Node in the slice of Nodes that
+// contains it, or a value < 0 if the current Node is not part of a slice.
+// The index of the current node changes if InsertBefore is called while
+// processing the current node.
+func (c *Cursor) Index() int {
+	if c.iter != nil {
+		return c.iter.index
+	}
+	return -1
+}
+
+// field returns the current node's parent field value.
+func (c *Cursor) field() reflect.Value {
+	return reflect.Indirect(reflect.ValueOf(c.parent)).FieldByName(c.name)
+}
+
+// Replace replaces the current Node with n.
+// The replacement node is not walked by Apply.
+func (c *Cursor) Replace(n ast.Node) {
+	if _, ok := c.node.(*ast.File); ok {
+		file, ok := n.(*ast.File)
+		if !ok {
+			panic("attempt to replace *ast.File with non-*ast.File")
+		}
+		c.parent.(*ast.Package).Files[c.name] = file
+		return
+	}
+
+	v := c.field()
+	if i := c.Index(); i >= 0 {
+		v = v.Index(i)
+	}
+	v.Set(reflect.ValueOf(n))
+}
+
+// Delete deletes the current Node from its containing slice.
+// If the current Node is not part of a slice, Delete panics.
+// As a special case, if the current node is a package file,
+// Delete removes it from the package's Files map.
+func (c *Cursor) Delete() {
+	if _, ok := c.node.(*ast.File); ok {
+		delete(c.parent.(*ast.Package).Files, c.name)
+		return
+	}
+
+	i := c.Index()
+	if i < 0 {
+		panic("Delete node not contained in slice")
+	}
+	v := c.field()
+	l := v.Len()
+	reflect.Copy(v.Slice(i, l), v.Slice(i+1, l))
+	v.Index(l - 1).Set(reflect.Zero(v.Type().Elem()))
+	v.SetLen(l - 1)
+	c.iter.step--
+}
+
+// InsertAfter inserts n after the current Node in its containing slice.
+// If the current Node is not part of a slice, InsertAfter panics.
+// Apply does not walk n.
+func (c *Cursor) InsertAfter(n ast.Node) {
+	i := c.Index()
+	if i < 0 {
+		panic("InsertAfter node not contained in slice")
+	}
+	v := c.field()
+	v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
+	l := v.Len()
+	reflect.Copy(v.Slice(i+2, l), v.Slice(i+1, l))
+	v.Index(i + 1).Set(reflect.ValueOf(n))
+	c.iter.step++
+}
+
+// InsertBefore inserts n before the current Node in its containing slice.
+// If the current Node is not part of a slice, InsertBefore panics.
+// Apply will not walk n.
+func (c *Cursor) InsertBefore(n ast.Node) {
+	i := c.Index()
+	if i < 0 {
+		panic("InsertBefore node not contained in slice")
+	}
+	v := c.field()
+	v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
+	l := v.Len()
+	reflect.Copy(v.Slice(i+1, l), v.Slice(i, l))
+	v.Index(i).Set(reflect.ValueOf(n))
+	c.iter.index++
+}
+
+// application carries all the shared data so we can pass it around cheaply.
+type application struct {
+	pre, post ApplyFunc
+	cursor    Cursor
+	iter      iterator
+}
+
+func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast.Node) {
+	// convert typed nil into untyped nil
+	if v := reflect.ValueOf(n); v.Kind() == reflect.Ptr && v.IsNil() {
+		n = nil
+	}
+
+	// avoid heap-allocating a new cursor for each apply call; reuse a.cursor instead
+	saved := a.cursor
+	a.cursor.parent = parent
+	a.cursor.name = name
+	a.cursor.iter = iter
+	a.cursor.node = n
+
+	if a.pre != nil && !a.pre(&a.cursor) {
+		a.cursor = saved
+		return
+	}
+
+	// walk children
+	// (the order of the cases matches the order of the corresponding node types in go/ast)
+	switch n := n.(type) {
+	case nil:
+		// nothing to do
+
+	// Comments and fields
+	case *ast.Comment:
+		// nothing to do
+
+	case *ast.CommentGroup:
+		if n != nil {
+			a.applyList(n, "List")
+		}
+
+	case *ast.Field:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.applyList(n, "Names")
+		a.apply(n, "Type", nil, n.Type)
+		a.apply(n, "Tag", nil, n.Tag)
+		a.apply(n, "Comment", nil, n.Comment)
+
+	case *ast.FieldList:
+		a.applyList(n, "List")
+
+	// Expressions
+	case *ast.BadExpr, *ast.Ident, *ast.BasicLit:
+		// nothing to do
+
+	case *ast.Ellipsis:
+		a.apply(n, "Elt", nil, n.Elt)
+
+	case *ast.FuncLit:
+		a.apply(n, "Type", nil, n.Type)
+		a.apply(n, "Body", nil, n.Body)
+
+	case *ast.CompositeLit:
+		a.apply(n, "Type", nil, n.Type)
+		a.applyList(n, "Elts")
+
+	case *ast.ParenExpr:
+		a.apply(n, "X", nil, n.X)
+
+	case *ast.SelectorExpr:
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Sel", nil, n.Sel)
+
+	case *ast.IndexExpr:
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Index", nil, n.Index)
+
+	case *ast.SliceExpr:
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Low", nil, n.Low)
+		a.apply(n, "High", nil, n.High)
+		a.apply(n, "Max", nil, n.Max)
+
+	case *ast.TypeAssertExpr:
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Type", nil, n.Type)
+
+	case *ast.CallExpr:
+		a.apply(n, "Fun", nil, n.Fun)
+		a.applyList(n, "Args")
+
+	case *ast.StarExpr:
+		a.apply(n, "X", nil, n.X)
+
+	case *ast.UnaryExpr:
+		a.apply(n, "X", nil, n.X)
+
+	case *ast.BinaryExpr:
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Y", nil, n.Y)
+
+	case *ast.KeyValueExpr:
+		a.apply(n, "Key", nil, n.Key)
+		a.apply(n, "Value", nil, n.Value)
+
+	// Types
+	case *ast.ArrayType:
+		a.apply(n, "Len", nil, n.Len)
+		a.apply(n, "Elt", nil, n.Elt)
+
+	case *ast.StructType:
+		a.apply(n, "Fields", nil, n.Fields)
+
+	case *ast.FuncType:
+		a.apply(n, "Params", nil, n.Params)
+		a.apply(n, "Results", nil, n.Results)
+
+	case *ast.InterfaceType:
+		a.apply(n, "Methods", nil, n.Methods)
+
+	case *ast.MapType:
+		a.apply(n, "Key", nil, n.Key)
+		a.apply(n, "Value", nil, n.Value)
+
+	case *ast.ChanType:
+		a.apply(n, "Value", nil, n.Value)
+
+	// Statements
+	case *ast.BadStmt:
+		// nothing to do
+
+	case *ast.DeclStmt:
+		a.apply(n, "Decl", nil, n.Decl)
+
+	case *ast.EmptyStmt:
+		// nothing to do
+
+	case *ast.LabeledStmt:
+		a.apply(n, "Label", nil, n.Label)
+		a.apply(n, "Stmt", nil, n.Stmt)
+
+	case *ast.ExprStmt:
+		a.apply(n, "X", nil, n.X)
+
+	case *ast.SendStmt:
+		a.apply(n, "Chan", nil, n.Chan)
+		a.apply(n, "Value", nil, n.Value)
+
+	case *ast.IncDecStmt:
+		a.apply(n, "X", nil, n.X)
+
+	case *ast.AssignStmt:
+		a.applyList(n, "Lhs")
+		a.applyList(n, "Rhs")
+
+	case *ast.GoStmt:
+		a.apply(n, "Call", nil, n.Call)
+
+	case *ast.DeferStmt:
+		a.apply(n, "Call", nil, n.Call)
+
+	case *ast.ReturnStmt:
+		a.applyList(n, "Results")
+
+	case *ast.BranchStmt:
+		a.apply(n, "Label", nil, n.Label)
+
+	case *ast.BlockStmt:
+		a.applyList(n, "List")
+
+	case *ast.IfStmt:
+		a.apply(n, "Init", nil, n.Init)
+		a.apply(n, "Cond", nil, n.Cond)
+		a.apply(n, "Body", nil, n.Body)
+		a.apply(n, "Else", nil, n.Else)
+
+	case *ast.CaseClause:
+		a.applyList(n, "List")
+		a.applyList(n, "Body")
+
+	case *ast.SwitchStmt:
+		a.apply(n, "Init", nil, n.Init)
+		a.apply(n, "Tag", nil, n.Tag)
+		a.apply(n, "Body", nil, n.Body)
+
+	case *ast.TypeSwitchStmt:
+		a.apply(n, "Init", nil, n.Init)
+		a.apply(n, "Assign", nil, n.Assign)
+		a.apply(n, "Body", nil, n.Body)
+
+	case *ast.CommClause:
+		a.apply(n, "Comm", nil, n.Comm)
+		a.applyList(n, "Body")
+
+	case *ast.SelectStmt:
+		a.apply(n, "Body", nil, n.Body)
+
+	case *ast.ForStmt:
+		a.apply(n, "Init", nil, n.Init)
+		a.apply(n, "Cond", nil, n.Cond)
+		a.apply(n, "Post", nil, n.Post)
+		a.apply(n, "Body", nil, n.Body)
+
+	case *ast.RangeStmt:
+		a.apply(n, "Key", nil, n.Key)
+		a.apply(n, "Value", nil, n.Value)
+		a.apply(n, "X", nil, n.X)
+		a.apply(n, "Body", nil, n.Body)
+
+	// Declarations
+	case *ast.ImportSpec:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.apply(n, "Name", nil, n.Name)
+		a.apply(n, "Path", nil, n.Path)
+		a.apply(n, "Comment", nil, n.Comment)
+
+	case *ast.ValueSpec:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.applyList(n, "Names")
+		a.apply(n, "Type", nil, n.Type)
+		a.applyList(n, "Values")
+		a.apply(n, "Comment", nil, n.Comment)
+
+	case *ast.TypeSpec:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.apply(n, "Name", nil, n.Name)
+		a.apply(n, "Type", nil, n.Type)
+		a.apply(n, "Comment", nil, n.Comment)
+
+	case *ast.BadDecl:
+		// nothing to do
+
+	case *ast.GenDecl:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.applyList(n, "Specs")
+
+	case *ast.FuncDecl:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.apply(n, "Recv", nil, n.Recv)
+		a.apply(n, "Name", nil, n.Name)
+		a.apply(n, "Type", nil, n.Type)
+		a.apply(n, "Body", nil, n.Body)
+
+	// Files and packages
+	case *ast.File:
+		a.apply(n, "Doc", nil, n.Doc)
+		a.apply(n, "Name", nil, n.Name)
+		a.applyList(n, "Decls")
+		// Don't walk n.Comments; they have either been walked already if
+		// they are Doc comments, or they can be easily walked explicitly.
+
+	case *ast.Package:
+		// collect and sort names for reproducible behavior
+		var names []string
+		for name := range n.Files {
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		for _, name := range names {
+			a.apply(n, name, nil, n.Files[name])
+		}
+
+	default:
+		panic(fmt.Sprintf("Apply: unexpected node type %T", n))
+	}
+
+	if a.post != nil && !a.post(&a.cursor) {
+		panic(abort)
+	}
+
+	a.cursor = saved
+}
+
+// An iterator controls iteration over a slice of nodes.
+type iterator struct {
+	index, step int
+}
+
+func (a *application) applyList(parent ast.Node, name string) {
+	// avoid heap-allocating a new iterator for each applyList call; reuse a.iter instead
+	saved := a.iter
+	a.iter.index = 0
+	for {
+		// must reload parent.name each time, since cursor modifications might change it
+		v := reflect.Indirect(reflect.ValueOf(parent)).FieldByName(name)
+		if a.iter.index >= v.Len() {
+			break
+		}
+
+		// element x may be nil in a bad AST - be cautious
+		var x ast.Node
+		if e := v.Index(a.iter.index); e.IsValid() {
+			x = e.Interface().(ast.Node)
+		}
+
+		a.iter.step = 1
+		a.apply(parent, name, &a.iter, x)
+		a.iter.index += a.iter.step
+	}
+	a.iter = saved
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/ast/astutil/util.go
new file mode 100644
index 00000000..76306298
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/allpackages.go b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/allpackages.go
new file mode 100644
index 00000000..c0cb03e7
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/allpackages.go
@@ -0,0 +1,198 @@
+// 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.
+
+// Package buildutil provides utilities related to the go/build
+// package in the standard library.
+//
+// All I/O is done via the build.Context file system interface, which must
+// be concurrency-safe.
+package buildutil // import "golang.org/x/tools/go/buildutil"
+
+import (
+	"go/build"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+)
+
+// AllPackages returns the package path of each Go package in any source
+// directory of the specified build context (e.g. $GOROOT or an element
+// of $GOPATH).  Errors are ignored.  The results are sorted.
+// All package paths are canonical, and thus may contain "/vendor/".
+//
+// The result may include import paths for directories that contain no
+// *.go files, such as "archive" (in $GOROOT/src).
+//
+// All I/O is done via the build.Context file system interface,
+// which must be concurrency-safe.
+//
+func AllPackages(ctxt *build.Context) []string {
+	var list []string
+	ForEachPackage(ctxt, func(pkg string, _ error) {
+		list = append(list, pkg)
+	})
+	sort.Strings(list)
+	return list
+}
+
+// ForEachPackage calls the found function with the package path of
+// each Go package it finds in any source directory of the specified
+// build context (e.g. $GOROOT or an element of $GOPATH).
+// All package paths are canonical, and thus may contain "/vendor/".
+//
+// If the package directory exists but could not be read, the second
+// argument to the found function provides the error.
+//
+// All I/O is done via the build.Context file system interface,
+// which must be concurrency-safe.
+//
+func ForEachPackage(ctxt *build.Context, found func(importPath string, err error)) {
+	ch := make(chan item)
+
+	var wg sync.WaitGroup
+	for _, root := range ctxt.SrcDirs() {
+		root := root
+		wg.Add(1)
+		go func() {
+			allPackages(ctxt, root, ch)
+			wg.Done()
+		}()
+	}
+	go func() {
+		wg.Wait()
+		close(ch)
+	}()
+
+	// All calls to found occur in the caller's goroutine.
+	for i := range ch {
+		found(i.importPath, i.err)
+	}
+}
+
+type item struct {
+	importPath string
+	err        error // (optional)
+}
+
+// We use a process-wide counting semaphore to limit
+// the number of parallel calls to ReadDir.
+var ioLimit = make(chan bool, 20)
+
+func allPackages(ctxt *build.Context, root string, ch chan<- item) {
+	root = filepath.Clean(root) + string(os.PathSeparator)
+
+	var wg sync.WaitGroup
+
+	var walkDir func(dir string)
+	walkDir = func(dir string) {
+		// Avoid .foo, _foo, and testdata directory trees.
+		base := filepath.Base(dir)
+		if base == "" || base[0] == '.' || base[0] == '_' || base == "testdata" {
+			return
+		}
+
+		pkg := filepath.ToSlash(strings.TrimPrefix(dir, root))
+
+		// Prune search if we encounter any of these import paths.
+		switch pkg {
+		case "builtin":
+			return
+		}
+
+		ioLimit <- true
+		files, err := ReadDir(ctxt, dir)
+		<-ioLimit
+		if pkg != "" || err != nil {
+			ch <- item{pkg, err}
+		}
+		for _, fi := range files {
+			fi := fi
+			if fi.IsDir() {
+				wg.Add(1)
+				go func() {
+					walkDir(filepath.Join(dir, fi.Name()))
+					wg.Done()
+				}()
+			}
+		}
+	}
+
+	walkDir(root)
+	wg.Wait()
+}
+
+// ExpandPatterns returns the set of packages matched by patterns,
+// which may have the following forms:
+//
+//		golang.org/x/tools/cmd/guru     # a single package
+//		golang.org/x/tools/...          # all packages beneath dir
+//		...                             # the entire workspace.
+//
+// Order is significant: a pattern preceded by '-' removes matching
+// packages from the set.  For example, these patterns match all encoding
+// packages except encoding/xml:
+//
+// 	encoding/... -encoding/xml
+//
+// A trailing slash in a pattern is ignored.  (Path components of Go
+// package names are separated by slash, not the platform's path separator.)
+//
+func ExpandPatterns(ctxt *build.Context, patterns []string) map[string]bool {
+	// TODO(adonovan): support other features of 'go list':
+	// - "std"/"cmd"/"all" meta-packages
+	// - "..." not at the end of a pattern
+	// - relative patterns using "./" or "../" prefix
+
+	pkgs := make(map[string]bool)
+	doPkg := func(pkg string, neg bool) {
+		if neg {
+			delete(pkgs, pkg)
+		} else {
+			pkgs[pkg] = true
+		}
+	}
+
+	// Scan entire workspace if wildcards are present.
+	// TODO(adonovan): opt: scan only the necessary subtrees of the workspace.
+	var all []string
+	for _, arg := range patterns {
+		if strings.HasSuffix(arg, "...") {
+			all = AllPackages(ctxt)
+			break
+		}
+	}
+
+	for _, arg := range patterns {
+		if arg == "" {
+			continue
+		}
+
+		neg := arg[0] == '-'
+		if neg {
+			arg = arg[1:]
+		}
+
+		if arg == "..." {
+			// ... matches all packages
+			for _, pkg := range all {
+				doPkg(pkg, neg)
+			}
+		} else if dir := strings.TrimSuffix(arg, "/..."); dir != arg {
+			// dir/... matches all packages beneath dir
+			for _, pkg := range all {
+				if strings.HasPrefix(pkg, dir) &&
+					(len(pkg) == len(dir) || pkg[len(dir)] == '/') {
+					doPkg(pkg, neg)
+				}
+			}
+		} else {
+			// single package
+			doPkg(strings.TrimSuffix(arg, "/"), neg)
+		}
+	}
+
+	return pkgs
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/fakecontext.go b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/fakecontext.go
new file mode 100644
index 00000000..24cbcbea
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/fakecontext.go
@@ -0,0 +1,108 @@
+package buildutil
+
+import (
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+// FakeContext returns a build.Context for the fake file tree specified
+// by pkgs, which maps package import paths to a mapping from file base
+// names to contents.
+//
+// The fake Context has a GOROOT of "/go" and no GOPATH, and overrides
+// the necessary file access methods to read from memory instead of the
+// real file system.
+//
+// Unlike a real file tree, the fake one has only two levels---packages
+// and files---so ReadDir("/go/src/") returns all packages under
+// /go/src/ including, for instance, "math" and "math/big".
+// ReadDir("/go/src/math/big") would return all the files in the
+// "math/big" package.
+//
+func FakeContext(pkgs map[string]map[string]string) *build.Context {
+	clean := func(filename string) string {
+		f := path.Clean(filepath.ToSlash(filename))
+		// Removing "/go/src" while respecting segment
+		// boundaries has this unfortunate corner case:
+		if f == "/go/src" {
+			return ""
+		}
+		return strings.TrimPrefix(f, "/go/src/")
+	}
+
+	ctxt := build.Default // copy
+	ctxt.GOROOT = "/go"
+	ctxt.GOPATH = ""
+	ctxt.IsDir = func(dir string) bool {
+		dir = clean(dir)
+		if dir == "" {
+			return true // needed by (*build.Context).SrcDirs
+		}
+		return pkgs[dir] != nil
+	}
+	ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
+		dir = clean(dir)
+		var fis []os.FileInfo
+		if dir == "" {
+			// enumerate packages
+			for importPath := range pkgs {
+				fis = append(fis, fakeDirInfo(importPath))
+			}
+		} else {
+			// enumerate files of package
+			for basename := range pkgs[dir] {
+				fis = append(fis, fakeFileInfo(basename))
+			}
+		}
+		sort.Sort(byName(fis))
+		return fis, nil
+	}
+	ctxt.OpenFile = func(filename string) (io.ReadCloser, error) {
+		filename = clean(filename)
+		dir, base := path.Split(filename)
+		content, ok := pkgs[path.Clean(dir)][base]
+		if !ok {
+			return nil, fmt.Errorf("file not found: %s", filename)
+		}
+		return ioutil.NopCloser(strings.NewReader(content)), nil
+	}
+	ctxt.IsAbsPath = func(path string) bool {
+		path = filepath.ToSlash(path)
+		// Don't rely on the default (filepath.Path) since on
+		// Windows, it reports virtual paths as non-absolute.
+		return strings.HasPrefix(path, "/")
+	}
+	return &ctxt
+}
+
+type byName []os.FileInfo
+
+func (s byName) Len() int           { return len(s) }
+func (s byName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byName) Less(i, j int) bool { return s[i].Name() < s[j].Name() }
+
+type fakeFileInfo string
+
+func (fi fakeFileInfo) Name() string    { return string(fi) }
+func (fakeFileInfo) Sys() interface{}   { return nil }
+func (fakeFileInfo) ModTime() time.Time { return time.Time{} }
+func (fakeFileInfo) IsDir() bool        { return false }
+func (fakeFileInfo) Size() int64        { return 0 }
+func (fakeFileInfo) Mode() os.FileMode  { return 0644 }
+
+type fakeDirInfo string
+
+func (fd fakeDirInfo) Name() string    { return string(fd) }
+func (fakeDirInfo) Sys() interface{}   { return nil }
+func (fakeDirInfo) ModTime() time.Time { return time.Time{} }
+func (fakeDirInfo) IsDir() bool        { return true }
+func (fakeDirInfo) Size() int64        { return 0 }
+func (fakeDirInfo) Mode() os.FileMode  { return 0755 }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/overlay.go b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/overlay.go
new file mode 100644
index 00000000..3f71c4fe
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/overlay.go
@@ -0,0 +1,103 @@
+// 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.
+
+package buildutil
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/build"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// OverlayContext overlays a build.Context with additional files from
+// a map. Files in the map take precedence over other files.
+//
+// In addition to plain string comparison, two file names are
+// considered equal if their base names match and their directory
+// components point at the same directory on the file system. That is,
+// symbolic links are followed for directories, but not files.
+//
+// A common use case for OverlayContext is to allow editors to pass in
+// a set of unsaved, modified files.
+//
+// Currently, only the Context.OpenFile function will respect the
+// overlay. This may change in the future.
+func OverlayContext(orig *build.Context, overlay map[string][]byte) *build.Context {
+	// TODO(dominikh): Implement IsDir, HasSubdir and ReadDir
+
+	rc := func(data []byte) (io.ReadCloser, error) {
+		return ioutil.NopCloser(bytes.NewBuffer(data)), nil
+	}
+
+	copy := *orig // make a copy
+	ctxt := &copy
+	ctxt.OpenFile = func(path string) (io.ReadCloser, error) {
+		// Fast path: names match exactly.
+		if content, ok := overlay[path]; ok {
+			return rc(content)
+		}
+
+		// Slow path: check for same file under a different
+		// alias, perhaps due to a symbolic link.
+		for filename, content := range overlay {
+			if sameFile(path, filename) {
+				return rc(content)
+			}
+		}
+
+		return OpenFile(orig, path)
+	}
+	return ctxt
+}
+
+// ParseOverlayArchive parses an archive containing Go files and their
+// contents. The result is intended to be used with OverlayContext.
+//
+//
+// Archive format
+//
+// The archive consists of a series of files. Each file consists of a
+// name, a decimal file size and the file contents, separated by
+// newlinews. No newline follows after the file contents.
+func ParseOverlayArchive(archive io.Reader) (map[string][]byte, error) {
+	overlay := make(map[string][]byte)
+	r := bufio.NewReader(archive)
+	for {
+		// Read file name.
+		filename, err := r.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break // OK
+			}
+			return nil, fmt.Errorf("reading archive file name: %v", err)
+		}
+		filename = filepath.Clean(strings.TrimSpace(filename))
+
+		// Read file size.
+		sz, err := r.ReadString('\n')
+		if err != nil {
+			return nil, fmt.Errorf("reading size of archive file %s: %v", filename, err)
+		}
+		sz = strings.TrimSpace(sz)
+		size, err := strconv.ParseUint(sz, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("parsing size of archive file %s: %v", filename, err)
+		}
+
+		// Read file content.
+		content := make([]byte, size)
+		if _, err := io.ReadFull(r, content); err != nil {
+			return nil, fmt.Errorf("reading archive file %s: %v", filename, err)
+		}
+		overlay[filename] = content
+	}
+
+	return overlay, nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/tags.go b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/tags.go
new file mode 100644
index 00000000..486606f3
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/tags.go
@@ -0,0 +1,75 @@
+package buildutil
+
+// This logic was copied from stringsFlag from $GOROOT/src/cmd/go/build.go.
+
+import "fmt"
+
+const TagsFlagDoc = "a list of `build tags` to consider satisfied during the build. " +
+	"For more information about build tags, see the description of " +
+	"build constraints in the documentation for the go/build package"
+
+// TagsFlag is an implementation of the flag.Value and flag.Getter interfaces that parses
+// a flag value in the same manner as go build's -tags flag and
+// populates a []string slice.
+//
+// See $GOROOT/src/go/build/doc.go for description of build tags.
+// See $GOROOT/src/cmd/go/doc.go for description of 'go build -tags' flag.
+//
+// Example:
+// 	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+type TagsFlag []string
+
+func (v *TagsFlag) Set(s string) error {
+	var err error
+	*v, err = splitQuotedFields(s)
+	if *v == nil {
+		*v = []string{}
+	}
+	return err
+}
+
+func (v *TagsFlag) Get() interface{} { return *v }
+
+func splitQuotedFields(s string) ([]string, error) {
+	// Split fields allowing '' or "" around elements.
+	// Quotes further inside the string do not count.
+	var f []string
+	for len(s) > 0 {
+		for len(s) > 0 && isSpaceByte(s[0]) {
+			s = s[1:]
+		}
+		if len(s) == 0 {
+			break
+		}
+		// Accepted quoted string. No unescaping inside.
+		if s[0] == '"' || s[0] == '\'' {
+			quote := s[0]
+			s = s[1:]
+			i := 0
+			for i < len(s) && s[i] != quote {
+				i++
+			}
+			if i >= len(s) {
+				return nil, fmt.Errorf("unterminated %c string", quote)
+			}
+			f = append(f, s[:i])
+			s = s[i+1:]
+			continue
+		}
+		i := 0
+		for i < len(s) && !isSpaceByte(s[i]) {
+			i++
+		}
+		f = append(f, s[:i])
+		s = s[i:]
+	}
+	return f, nil
+}
+
+func (v *TagsFlag) String() string {
+	return "<tagsFlag>"
+}
+
+func isSpaceByte(c byte) bool {
+	return c == ' ' || c == '\t' || c == '\n' || c == '\r'
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/util.go
new file mode 100644
index 00000000..fc923d7a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/buildutil/util.go
@@ -0,0 +1,212 @@
+// 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.
+
+package buildutil
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+// ParseFile behaves like parser.ParseFile,
+// but uses the build context's file system interface, if any.
+//
+// If file is not absolute (as defined by IsAbsPath), the (dir, file)
+// components are joined using JoinPath; dir must be absolute.
+//
+// The displayPath function, if provided, is used to transform the
+// filename that will be attached to the ASTs.
+//
+// TODO(adonovan): call this from go/loader.parseFiles when the tree thaws.
+//
+func ParseFile(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, file string, mode parser.Mode) (*ast.File, error) {
+	if !IsAbsPath(ctxt, file) {
+		file = JoinPath(ctxt, dir, file)
+	}
+	rd, err := OpenFile(ctxt, file)
+	if err != nil {
+		return nil, err
+	}
+	defer rd.Close() // ignore error
+	if displayPath != nil {
+		file = displayPath(file)
+	}
+	return parser.ParseFile(fset, file, rd, mode)
+}
+
+// ContainingPackage returns the package containing filename.
+//
+// If filename is not absolute, it is interpreted relative to working directory dir.
+// All I/O is via the build context's file system interface, if any.
+//
+// The '...Files []string' fields of the resulting build.Package are not
+// populated (build.FindOnly mode).
+//
+func ContainingPackage(ctxt *build.Context, dir, filename string) (*build.Package, error) {
+	if !IsAbsPath(ctxt, filename) {
+		filename = JoinPath(ctxt, dir, filename)
+	}
+
+	// We must not assume the file tree uses
+	// "/" always,
+	// `\` always,
+	// or os.PathSeparator (which varies by platform),
+	// but to make any progress, we are forced to assume that
+	// paths will not use `\` unless the PathSeparator
+	// is also `\`, thus we can rely on filepath.ToSlash for some sanity.
+
+	dirSlash := path.Dir(filepath.ToSlash(filename)) + "/"
+
+	// We assume that no source root (GOPATH[i] or GOROOT) contains any other.
+	for _, srcdir := range ctxt.SrcDirs() {
+		srcdirSlash := filepath.ToSlash(srcdir) + "/"
+		if importPath, ok := HasSubdir(ctxt, srcdirSlash, dirSlash); ok {
+			return ctxt.Import(importPath, dir, build.FindOnly)
+		}
+	}
+
+	return nil, fmt.Errorf("can't find package containing %s", filename)
+}
+
+// -- Effective methods of file system interface -------------------------
+
+// (go/build.Context defines these as methods, but does not export them.)
+
+// hasSubdir calls ctxt.HasSubdir (if not nil) or else uses
+// the local file system to answer the question.
+func HasSubdir(ctxt *build.Context, root, dir string) (rel string, ok bool) {
+	if f := ctxt.HasSubdir; f != nil {
+		return f(root, dir)
+	}
+
+	// Try using paths we received.
+	if rel, ok = hasSubdir(root, dir); ok {
+		return
+	}
+
+	// Try expanding symlinks and comparing
+	// expanded against unexpanded and
+	// expanded against expanded.
+	rootSym, _ := filepath.EvalSymlinks(root)
+	dirSym, _ := filepath.EvalSymlinks(dir)
+
+	if rel, ok = hasSubdir(rootSym, dir); ok {
+		return
+	}
+	if rel, ok = hasSubdir(root, dirSym); ok {
+		return
+	}
+	return hasSubdir(rootSym, dirSym)
+}
+
+func hasSubdir(root, dir string) (rel string, ok bool) {
+	const sep = string(filepath.Separator)
+	root = filepath.Clean(root)
+	if !strings.HasSuffix(root, sep) {
+		root += sep
+	}
+
+	dir = filepath.Clean(dir)
+	if !strings.HasPrefix(dir, root) {
+		return "", false
+	}
+
+	return filepath.ToSlash(dir[len(root):]), true
+}
+
+// FileExists returns true if the specified file exists,
+// using the build context's file system interface.
+func FileExists(ctxt *build.Context, path string) bool {
+	if ctxt.OpenFile != nil {
+		r, err := ctxt.OpenFile(path)
+		if err != nil {
+			return false
+		}
+		r.Close() // ignore error
+		return true
+	}
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// OpenFile behaves like os.Open,
+// but uses the build context's file system interface, if any.
+func OpenFile(ctxt *build.Context, path string) (io.ReadCloser, error) {
+	if ctxt.OpenFile != nil {
+		return ctxt.OpenFile(path)
+	}
+	return os.Open(path)
+}
+
+// IsAbsPath behaves like filepath.IsAbs,
+// but uses the build context's file system interface, if any.
+func IsAbsPath(ctxt *build.Context, path string) bool {
+	if ctxt.IsAbsPath != nil {
+		return ctxt.IsAbsPath(path)
+	}
+	return filepath.IsAbs(path)
+}
+
+// JoinPath behaves like filepath.Join,
+// but uses the build context's file system interface, if any.
+func JoinPath(ctxt *build.Context, path ...string) string {
+	if ctxt.JoinPath != nil {
+		return ctxt.JoinPath(path...)
+	}
+	return filepath.Join(path...)
+}
+
+// IsDir behaves like os.Stat plus IsDir,
+// but uses the build context's file system interface, if any.
+func IsDir(ctxt *build.Context, path string) bool {
+	if ctxt.IsDir != nil {
+		return ctxt.IsDir(path)
+	}
+	fi, err := os.Stat(path)
+	return err == nil && fi.IsDir()
+}
+
+// ReadDir behaves like ioutil.ReadDir,
+// but uses the build context's file system interface, if any.
+func ReadDir(ctxt *build.Context, path string) ([]os.FileInfo, error) {
+	if ctxt.ReadDir != nil {
+		return ctxt.ReadDir(path)
+	}
+	return ioutil.ReadDir(path)
+}
+
+// SplitPathList behaves like filepath.SplitList,
+// but uses the build context's file system interface, if any.
+func SplitPathList(ctxt *build.Context, s string) []string {
+	if ctxt.SplitPathList != nil {
+		return ctxt.SplitPathList(s)
+	}
+	return filepath.SplitList(s)
+}
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+//
+func sameFile(x, y string) bool {
+	if path.Clean(x) == path.Clean(y) {
+		return true
+	}
+	if filepath.Base(x) == filepath.Base(y) { // (optimisation)
+		if xi, err := os.Stat(x); err == nil {
+			if yi, err := os.Stat(y); err == nil {
+				return os.SameFile(xi, yi)
+			}
+		}
+	}
+	return false
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/callgraph.go b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/callgraph.go
new file mode 100644
index 00000000..707a3193
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/callgraph.go
@@ -0,0 +1,129 @@
+// 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 callgraph defines the call graph and various algorithms
+and utilities to operate on it.
+
+A call graph is a labelled directed graph whose nodes represent
+functions and whose edge labels represent syntactic function call
+sites.  The presence of a labelled edge (caller, site, callee)
+indicates that caller may call callee at the specified call site.
+
+A call graph is a multigraph: it may contain multiple edges (caller,
+*, callee) connecting the same pair of nodes, so long as the edges
+differ by label; this occurs when one function calls another function
+from multiple call sites.  Also, it may contain multiple edges
+(caller, site, *) that differ only by callee; this indicates a
+polymorphic call.
+
+A SOUND call graph is one that overapproximates the dynamic calling
+behaviors of the program in all possible executions.  One call graph
+is more PRECISE than another if it is a smaller overapproximation of
+the dynamic behavior.
+
+All call graphs have a synthetic root node which is responsible for
+calling main() and init().
+
+Calls to built-in functions (e.g. panic, println) are not represented
+in the call graph; they are treated like built-in operators of the
+language.
+
+*/
+package callgraph // import "golang.org/x/tools/go/callgraph"
+
+// TODO(adonovan): add a function to eliminate wrappers from the
+// callgraph, preserving topology.
+// More generally, we could eliminate "uninteresting" nodes such as
+// nodes from packages we don't care about.
+
+import (
+	"fmt"
+	"go/token"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+// A Graph represents a call graph.
+//
+// A graph may contain nodes that are not reachable from the root.
+// If the call graph is sound, such nodes indicate unreachable
+// functions.
+//
+type Graph struct {
+	Root  *Node                   // the distinguished root node
+	Nodes map[*ssa.Function]*Node // all nodes by function
+}
+
+// New returns a new Graph with the specified root node.
+func New(root *ssa.Function) *Graph {
+	g := &Graph{Nodes: make(map[*ssa.Function]*Node)}
+	g.Root = g.CreateNode(root)
+	return g
+}
+
+// CreateNode returns the Node for fn, creating it if not present.
+func (g *Graph) CreateNode(fn *ssa.Function) *Node {
+	n, ok := g.Nodes[fn]
+	if !ok {
+		n = &Node{Func: fn, ID: len(g.Nodes)}
+		g.Nodes[fn] = n
+	}
+	return n
+}
+
+// A Node represents a node in a call graph.
+type Node struct {
+	Func *ssa.Function // the function this node represents
+	ID   int           // 0-based sequence number
+	In   []*Edge       // unordered set of incoming call edges (n.In[*].Callee == n)
+	Out  []*Edge       // unordered set of outgoing call edges (n.Out[*].Caller == n)
+}
+
+func (n *Node) String() string {
+	return fmt.Sprintf("n%d:%s", n.ID, n.Func)
+}
+
+// A Edge represents an edge in the call graph.
+//
+// Site is nil for edges originating in synthetic or intrinsic
+// functions, e.g. reflect.Call or the root of the call graph.
+type Edge struct {
+	Caller *Node
+	Site   ssa.CallInstruction
+	Callee *Node
+}
+
+func (e Edge) String() string {
+	return fmt.Sprintf("%s --> %s", e.Caller, e.Callee)
+}
+
+func (e Edge) Description() string {
+	var prefix string
+	switch e.Site.(type) {
+	case nil:
+		return "synthetic call"
+	case *ssa.Go:
+		prefix = "concurrent "
+	case *ssa.Defer:
+		prefix = "deferred "
+	}
+	return prefix + e.Site.Common().Description()
+}
+
+func (e Edge) Pos() token.Pos {
+	if e.Site == nil {
+		return token.NoPos
+	}
+	return e.Site.Pos()
+}
+
+// AddEdge adds the edge (caller, site, callee) to the call graph.
+// Elimination of duplicate edges is the caller's responsibility.
+func AddEdge(caller *Node, site ssa.CallInstruction, callee *Node) {
+	e := &Edge{caller, site, callee}
+	callee.In = append(callee.In, e)
+	caller.Out = append(caller.Out, e)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/static/static.go b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/static/static.go
new file mode 100644
index 00000000..709bb7b6
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/static/static.go
@@ -0,0 +1,35 @@
+// Package static computes the call graph of a Go program containing
+// only static call edges.
+package static // import "golang.org/x/tools/go/callgraph/static"
+
+import (
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+// CallGraph computes the call graph of the specified program
+// considering only static calls.
+//
+func CallGraph(prog *ssa.Program) *callgraph.Graph {
+	cg := callgraph.New(nil) // TODO(adonovan) eliminate concept of rooted callgraph
+
+	// TODO(adonovan): opt: use only a single pass over the ssa.Program.
+	// TODO(adonovan): opt: this is slower than RTA (perhaps because
+	// the lower precision means so many edges are allocated)!
+	for f := range ssautil.AllFunctions(prog) {
+		fnode := cg.CreateNode(f)
+		for _, b := range f.Blocks {
+			for _, instr := range b.Instrs {
+				if site, ok := instr.(ssa.CallInstruction); ok {
+					if g := site.Common().StaticCallee(); g != nil {
+						gnode := cg.CreateNode(g)
+						callgraph.AddEdge(fnode, site, gnode)
+					}
+				}
+			}
+		}
+	}
+
+	return cg
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/util.go
new file mode 100644
index 00000000..a8f89031
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/callgraph/util.go
@@ -0,0 +1,181 @@
+// 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 callgraph
+
+import "golang.org/x/tools/go/ssa"
+
+// This file provides various utilities over call graphs, such as
+// visitation and path search.
+
+// CalleesOf returns a new set containing all direct callees of the
+// caller node.
+//
+func CalleesOf(caller *Node) map[*Node]bool {
+	callees := make(map[*Node]bool)
+	for _, e := range caller.Out {
+		callees[e.Callee] = true
+	}
+	return callees
+}
+
+// GraphVisitEdges visits all the edges in graph g in depth-first order.
+// The edge function is called for each edge in postorder.  If it
+// returns non-nil, visitation stops and GraphVisitEdges returns that
+// value.
+//
+func GraphVisitEdges(g *Graph, edge func(*Edge) error) error {
+	seen := make(map[*Node]bool)
+	var visit func(n *Node) error
+	visit = func(n *Node) error {
+		if !seen[n] {
+			seen[n] = true
+			for _, e := range n.Out {
+				if err := visit(e.Callee); err != nil {
+					return err
+				}
+				if err := edge(e); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	for _, n := range g.Nodes {
+		if err := visit(n); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// PathSearch finds an arbitrary path starting at node start and
+// ending at some node for which isEnd() returns true.  On success,
+// PathSearch returns the path as an ordered list of edges; on
+// failure, it returns nil.
+//
+func PathSearch(start *Node, isEnd func(*Node) bool) []*Edge {
+	stack := make([]*Edge, 0, 32)
+	seen := make(map[*Node]bool)
+	var search func(n *Node) []*Edge
+	search = func(n *Node) []*Edge {
+		if !seen[n] {
+			seen[n] = true
+			if isEnd(n) {
+				return stack
+			}
+			for _, e := range n.Out {
+				stack = append(stack, e) // push
+				if found := search(e.Callee); found != nil {
+					return found
+				}
+				stack = stack[:len(stack)-1] // pop
+			}
+		}
+		return nil
+	}
+	return search(start)
+}
+
+// DeleteSyntheticNodes removes from call graph g all nodes for
+// synthetic functions (except g.Root and package initializers),
+// preserving the topology.  In effect, calls to synthetic wrappers
+// are "inlined".
+//
+func (g *Graph) DeleteSyntheticNodes() {
+	// Measurements on the standard library and go.tools show that
+	// resulting graph has ~15% fewer nodes and 4-8% fewer edges
+	// than the input.
+	//
+	// Inlining a wrapper of in-degree m, out-degree n adds m*n
+	// and removes m+n edges.  Since most wrappers are monomorphic
+	// (n=1) this results in a slight reduction.  Polymorphic
+	// wrappers (n>1), e.g. from embedding an interface value
+	// inside a struct to satisfy some interface, cause an
+	// increase in the graph, but they seem to be uncommon.
+
+	// Hash all existing edges to avoid creating duplicates.
+	edges := make(map[Edge]bool)
+	for _, cgn := range g.Nodes {
+		for _, e := range cgn.Out {
+			edges[*e] = true
+		}
+	}
+	for fn, cgn := range g.Nodes {
+		if cgn == g.Root || fn.Synthetic == "" || isInit(cgn.Func) {
+			continue // keep
+		}
+		for _, eIn := range cgn.In {
+			for _, eOut := range cgn.Out {
+				newEdge := Edge{eIn.Caller, eIn.Site, eOut.Callee}
+				if edges[newEdge] {
+					continue // don't add duplicate
+				}
+				AddEdge(eIn.Caller, eIn.Site, eOut.Callee)
+				edges[newEdge] = true
+			}
+		}
+		g.DeleteNode(cgn)
+	}
+}
+
+func isInit(fn *ssa.Function) bool {
+	return fn.Pkg != nil && fn.Pkg.Func("init") == fn
+}
+
+// DeleteNode removes node n and its edges from the graph g.
+// (NB: not efficient for batch deletion.)
+func (g *Graph) DeleteNode(n *Node) {
+	n.deleteIns()
+	n.deleteOuts()
+	delete(g.Nodes, n.Func)
+}
+
+// deleteIns deletes all incoming edges to n.
+func (n *Node) deleteIns() {
+	for _, e := range n.In {
+		removeOutEdge(e)
+	}
+	n.In = nil
+}
+
+// deleteOuts deletes all outgoing edges from n.
+func (n *Node) deleteOuts() {
+	for _, e := range n.Out {
+		removeInEdge(e)
+	}
+	n.Out = nil
+}
+
+// removeOutEdge removes edge.Caller's outgoing edge 'edge'.
+func removeOutEdge(edge *Edge) {
+	caller := edge.Caller
+	n := len(caller.Out)
+	for i, e := range caller.Out {
+		if e == edge {
+			// Replace it with the final element and shrink the slice.
+			caller.Out[i] = caller.Out[n-1]
+			caller.Out[n-1] = nil // aid GC
+			caller.Out = caller.Out[:n-1]
+			return
+		}
+	}
+	panic("edge not found: " + edge.String())
+}
+
+// removeInEdge removes edge.Callee's incoming edge 'edge'.
+func removeInEdge(edge *Edge) {
+	caller := edge.Callee
+	n := len(caller.In)
+	for i, e := range caller.In {
+		if e == edge {
+			// Replace it with the final element and shrink the slice.
+			caller.In[i] = caller.In[n-1]
+			caller.In[n-1] = nil // aid GC
+			caller.In = caller.In[:n-1]
+			return
+		}
+	}
+	panic("edge not found: " + edge.String())
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo.go b/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo.go
new file mode 100644
index 00000000..72c6f502
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo.go
@@ -0,0 +1,207 @@
+// 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 loader
+
+// This file handles cgo preprocessing of files containing `import "C"`.
+//
+// DESIGN
+//
+// The approach taken is to run the cgo processor on the package's
+// CgoFiles and parse the output, faking the filenames of the
+// resulting ASTs so that the synthetic file containing the C types is
+// called "C" (e.g. "~/go/src/net/C") and the preprocessed files
+// have their original names (e.g. "~/go/src/net/cgo_unix.go"),
+// not the names of the actual temporary files.
+//
+// The advantage of this approach is its fidelity to 'go build'.  The
+// downside is that the token.Position.Offset for each AST node is
+// incorrect, being an offset within the temporary file.  Line numbers
+// should still be correct because of the //line comments.
+//
+// The logic of this file is mostly plundered from the 'go build'
+// tool, which also invokes the cgo preprocessor.
+//
+//
+// REJECTED ALTERNATIVE
+//
+// An alternative approach that we explored is to extend go/types'
+// Importer mechanism to provide the identity of the importing package
+// so that each time `import "C"` appears it resolves to a different
+// synthetic package containing just the objects needed in that case.
+// The loader would invoke cgo but parse only the cgo_types.go file
+// defining the package-level objects, discarding the other files
+// resulting from preprocessing.
+//
+// The benefit of this approach would have been that source-level
+// syntax information would correspond exactly to the original cgo
+// file, with no preprocessing involved, making source tools like
+// godoc, guru, and eg happy.  However, the approach was rejected
+// due to the additional complexity it would impose on go/types.  (It
+// made for a beautiful demo, though.)
+//
+// cgo files, despite their *.go extension, are not legal Go source
+// files per the specification since they may refer to unexported
+// members of package "C" such as C.int.  Also, a function such as
+// C.getpwent has in effect two types, one matching its C type and one
+// which additionally returns (errno C.int).  The cgo preprocessor
+// uses name mangling to distinguish these two functions in the
+// processed code, but go/types would need to duplicate this logic in
+// its handling of function calls, analogous to the treatment of map
+// lookups in which y=m[k] and y,ok=m[k] are both legal.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// processCgoFiles invokes the cgo preprocessor on bp.CgoFiles, parses
+// the output and returns the resulting ASTs.
+//
+func processCgoFiles(bp *build.Package, fset *token.FileSet, DisplayPath func(path string) string, mode parser.Mode) ([]*ast.File, error) {
+	tmpdir, err := ioutil.TempDir("", strings.Replace(bp.ImportPath, "/", "_", -1)+"_C")
+	if err != nil {
+		return nil, err
+	}
+	defer os.RemoveAll(tmpdir)
+
+	pkgdir := bp.Dir
+	if DisplayPath != nil {
+		pkgdir = DisplayPath(pkgdir)
+	}
+
+	cgoFiles, cgoDisplayFiles, err := runCgo(bp, pkgdir, tmpdir)
+	if err != nil {
+		return nil, err
+	}
+	var files []*ast.File
+	for i := range cgoFiles {
+		rd, err := os.Open(cgoFiles[i])
+		if err != nil {
+			return nil, err
+		}
+		display := filepath.Join(bp.Dir, cgoDisplayFiles[i])
+		f, err := parser.ParseFile(fset, display, rd, mode)
+		rd.Close()
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, f)
+	}
+	return files, nil
+}
+
+var cgoRe = regexp.MustCompile(`[/\\:]`)
+
+// runCgo invokes the cgo preprocessor on bp.CgoFiles and returns two
+// lists of files: the resulting processed files (in temporary
+// directory tmpdir) and the corresponding names of the unprocessed files.
+//
+// runCgo is adapted from (*builder).cgo in
+// $GOROOT/src/cmd/go/build.go, but these features are unsupported:
+// Objective C, CGOPKGPATH, CGO_FLAGS.
+//
+func runCgo(bp *build.Package, pkgdir, tmpdir string) (files, displayFiles []string, err error) {
+	cgoCPPFLAGS, _, _, _ := cflags(bp, true)
+	_, cgoexeCFLAGS, _, _ := cflags(bp, false)
+
+	if len(bp.CgoPkgConfig) > 0 {
+		pcCFLAGS, err := pkgConfigFlags(bp)
+		if err != nil {
+			return nil, nil, err
+		}
+		cgoCPPFLAGS = append(cgoCPPFLAGS, pcCFLAGS...)
+	}
+
+	// Allows including _cgo_export.h from .[ch] files in the package.
+	cgoCPPFLAGS = append(cgoCPPFLAGS, "-I", tmpdir)
+
+	// _cgo_gotypes.go (displayed "C") contains the type definitions.
+	files = append(files, filepath.Join(tmpdir, "_cgo_gotypes.go"))
+	displayFiles = append(displayFiles, "C")
+	for _, fn := range bp.CgoFiles {
+		// "foo.cgo1.go" (displayed "foo.go") is the processed Go source.
+		f := cgoRe.ReplaceAllString(fn[:len(fn)-len("go")], "_")
+		files = append(files, filepath.Join(tmpdir, f+"cgo1.go"))
+		displayFiles = append(displayFiles, fn)
+	}
+
+	var cgoflags []string
+	if bp.Goroot && bp.ImportPath == "runtime/cgo" {
+		cgoflags = append(cgoflags, "-import_runtime_cgo=false")
+	}
+	if bp.Goroot && bp.ImportPath == "runtime/race" || bp.ImportPath == "runtime/cgo" {
+		cgoflags = append(cgoflags, "-import_syscall=false")
+	}
+
+	args := stringList(
+		"go", "tool", "cgo", "-objdir", tmpdir, cgoflags, "--",
+		cgoCPPFLAGS, cgoexeCFLAGS, bp.CgoFiles,
+	)
+	if false {
+		log.Printf("Running cgo for package %q: %s (dir=%s)", bp.ImportPath, args, pkgdir)
+	}
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Dir = pkgdir
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return nil, nil, fmt.Errorf("cgo failed: %s: %s", args, err)
+	}
+
+	return files, displayFiles, nil
+}
+
+// -- unmodified from 'go build' ---------------------------------------
+
+// Return the flags to use when invoking the C or C++ compilers, or cgo.
+func cflags(p *build.Package, def bool) (cppflags, cflags, cxxflags, ldflags []string) {
+	var defaults string
+	if def {
+		defaults = "-g -O2"
+	}
+
+	cppflags = stringList(envList("CGO_CPPFLAGS", ""), p.CgoCPPFLAGS)
+	cflags = stringList(envList("CGO_CFLAGS", defaults), p.CgoCFLAGS)
+	cxxflags = stringList(envList("CGO_CXXFLAGS", defaults), p.CgoCXXFLAGS)
+	ldflags = stringList(envList("CGO_LDFLAGS", defaults), p.CgoLDFLAGS)
+	return
+}
+
+// envList returns the value of the given environment variable broken
+// into fields, using the default value when the variable is empty.
+func envList(key, def string) []string {
+	v := os.Getenv(key)
+	if v == "" {
+		v = def
+	}
+	return strings.Fields(v)
+}
+
+// stringList's arguments should be a sequence of string or []string values.
+// stringList flattens them into a single []string.
+func stringList(args ...interface{}) []string {
+	var x []string
+	for _, arg := range args {
+		switch arg := arg.(type) {
+		case []string:
+			x = append(x, arg...)
+		case string:
+			x = append(x, arg)
+		default:
+			panic("stringList: invalid argument")
+		}
+	}
+	return x
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo_pkgconfig.go b/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo_pkgconfig.go
new file mode 100644
index 00000000..de57422d
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/loader/cgo_pkgconfig.go
@@ -0,0 +1,39 @@
+// 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 loader
+
+import (
+	"errors"
+	"fmt"
+	"go/build"
+	"os/exec"
+	"strings"
+)
+
+// pkgConfig runs pkg-config with the specified arguments and returns the flags it prints.
+func pkgConfig(mode string, pkgs []string) (flags []string, err error) {
+	cmd := exec.Command("pkg-config", append([]string{mode}, pkgs...)...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		s := fmt.Sprintf("%s failed: %v", strings.Join(cmd.Args, " "), err)
+		if len(out) > 0 {
+			s = fmt.Sprintf("%s: %s", s, out)
+		}
+		return nil, errors.New(s)
+	}
+	if len(out) > 0 {
+		flags = strings.Fields(string(out))
+	}
+	return
+}
+
+// pkgConfigFlags calls pkg-config if needed and returns the cflags
+// needed to build the package.
+func pkgConfigFlags(p *build.Package) (cflags []string, err error) {
+	if len(p.CgoPkgConfig) == 0 {
+		return nil, nil
+	}
+	return pkgConfig("--cflags", p.CgoPkgConfig)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/loader/doc.go b/src/margo.sh/vendor/golang.org/x/tools/go/loader/doc.go
new file mode 100644
index 00000000..9b51c9ec
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/loader/doc.go
@@ -0,0 +1,205 @@
+// 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.
+
+// Package loader loads a complete Go program from source code, parsing
+// and type-checking the initial packages plus their transitive closure
+// of dependencies.  The ASTs and the derived facts are retained for
+// later use.
+//
+// THIS INTERFACE IS EXPERIMENTAL AND IS LIKELY TO CHANGE.
+//
+// The package defines two primary types: Config, which specifies a
+// set of initial packages to load and various other options; and
+// Program, which is the result of successfully loading the packages
+// specified by a configuration.
+//
+// The configuration can be set directly, but *Config provides various
+// convenience methods to simplify the common cases, each of which can
+// be called any number of times.  Finally, these are followed by a
+// call to Load() to actually load and type-check the program.
+//
+//      var conf loader.Config
+//
+//      // Use the command-line arguments to specify
+//      // a set of initial packages to load from source.
+//      // See FromArgsUsage for help.
+//      rest, err := conf.FromArgs(os.Args[1:], wantTests)
+//
+//      // Parse the specified files and create an ad hoc package with path "foo".
+//      // All files must have the same 'package' declaration.
+//      conf.CreateFromFilenames("foo", "foo.go", "bar.go")
+//
+//      // Create an ad hoc package with path "foo" from
+//      // the specified already-parsed files.
+//      // All ASTs must have the same 'package' declaration.
+//      conf.CreateFromFiles("foo", parsedFiles)
+//
+//      // Add "runtime" to the set of packages to be loaded.
+//      conf.Import("runtime")
+//
+//      // Adds "fmt" and "fmt_test" to the set of packages
+//      // to be loaded.  "fmt" will include *_test.go files.
+//      conf.ImportWithTests("fmt")
+//
+//      // Finally, load all the packages specified by the configuration.
+//      prog, err := conf.Load()
+//
+// See examples_test.go for examples of API usage.
+//
+//
+// CONCEPTS AND TERMINOLOGY
+//
+// The WORKSPACE is the set of packages accessible to the loader.  The
+// workspace is defined by Config.Build, a *build.Context.  The
+// default context treats subdirectories of $GOROOT and $GOPATH as
+// packages, but this behavior may be overridden.
+//
+// An AD HOC package is one specified as a set of source files on the
+// command line.  In the simplest case, it may consist of a single file
+// such as $GOROOT/src/net/http/triv.go.
+//
+// EXTERNAL TEST packages are those comprised of a set of *_test.go
+// files all with the same 'package foo_test' declaration, all in the
+// same directory.  (go/build.Package calls these files XTestFiles.)
+//
+// An IMPORTABLE package is one that can be referred to by some import
+// spec.  Every importable package is uniquely identified by its
+// PACKAGE PATH or just PATH, a string such as "fmt", "encoding/json",
+// or "cmd/vendor/golang.org/x/arch/x86/x86asm".  A package path
+// typically denotes a subdirectory of the workspace.
+//
+// An import declaration uses an IMPORT PATH to refer to a package.
+// Most import declarations use the package path as the import path.
+//
+// Due to VENDORING (https://golang.org/s/go15vendor), the
+// interpretation of an import path may depend on the directory in which
+// it appears.  To resolve an import path to a package path, go/build
+// must search the enclosing directories for a subdirectory named
+// "vendor".
+//
+// ad hoc packages and external test packages are NON-IMPORTABLE.  The
+// path of an ad hoc package is inferred from the package
+// declarations of its files and is therefore not a unique package key.
+// For example, Config.CreatePkgs may specify two initial ad hoc
+// packages, both with path "main".
+//
+// An AUGMENTED package is an importable package P plus all the
+// *_test.go files with same 'package foo' declaration as P.
+// (go/build.Package calls these files TestFiles.)
+//
+// The INITIAL packages are those specified in the configuration.  A
+// DEPENDENCY is a package loaded to satisfy an import in an initial
+// package or another dependency.
+//
+package loader
+
+// IMPLEMENTATION NOTES
+//
+// 'go test', in-package test files, and import cycles
+// ---------------------------------------------------
+//
+// An external test package may depend upon members of the augmented
+// package that are not in the unaugmented package, such as functions
+// that expose internals.  (See bufio/export_test.go for an example.)
+// So, the loader must ensure that for each external test package
+// it loads, it also augments the corresponding non-test package.
+//
+// The import graph over n unaugmented packages must be acyclic; the
+// import graph over n-1 unaugmented packages plus one augmented
+// package must also be acyclic.  ('go test' relies on this.)  But the
+// import graph over n augmented packages may contain cycles.
+//
+// First, all the (unaugmented) non-test packages and their
+// dependencies are imported in the usual way; the loader reports an
+// error if it detects an import cycle.
+//
+// Then, each package P for which testing is desired is augmented by
+// the list P' of its in-package test files, by calling
+// (*types.Checker).Files.  This arrangement ensures that P' may
+// reference definitions within P, but P may not reference definitions
+// within P'.  Furthermore, P' may import any other package, including
+// ones that depend upon P, without an import cycle error.
+//
+// Consider two packages A and B, both of which have lists of
+// in-package test files we'll call A' and B', and which have the
+// following import graph edges:
+//    B  imports A
+//    B' imports A
+//    A' imports B
+// This last edge would be expected to create an error were it not
+// for the special type-checking discipline above.
+// Cycles of size greater than two are possible.  For example:
+//   compress/bzip2/bzip2_test.go (package bzip2)  imports "io/ioutil"
+//   io/ioutil/tempfile_test.go   (package ioutil) imports "regexp"
+//   regexp/exec_test.go          (package regexp) imports "compress/bzip2"
+//
+//
+// Concurrency
+// -----------
+//
+// Let us define the import dependency graph as follows.  Each node is a
+// list of files passed to (Checker).Files at once.  Many of these lists
+// are the production code of an importable Go package, so those nodes
+// are labelled by the package's path.  The remaining nodes are
+// ad hoc packages and lists of in-package *_test.go files that augment
+// an importable package; those nodes have no label.
+//
+// The edges of the graph represent import statements appearing within a
+// file.  An edge connects a node (a list of files) to the node it
+// imports, which is importable and thus always labelled.
+//
+// Loading is controlled by this dependency graph.
+//
+// To reduce I/O latency, we start loading a package's dependencies
+// asynchronously as soon as we've parsed its files and enumerated its
+// imports (scanImports).  This performs a preorder traversal of the
+// import dependency graph.
+//
+// To exploit hardware parallelism, we type-check unrelated packages in
+// parallel, where "unrelated" means not ordered by the partial order of
+// the import dependency graph.
+//
+// We use a concurrency-safe non-blocking cache (importer.imported) to
+// record the results of type-checking, whether success or failure.  An
+// entry is created in this cache by startLoad the first time the
+// package is imported.  The first goroutine to request an entry becomes
+// responsible for completing the task and broadcasting completion to
+// subsequent requestors, which block until then.
+//
+// Type checking occurs in (parallel) postorder: we cannot type-check a
+// set of files until we have loaded and type-checked all of their
+// immediate dependencies (and thus all of their transitive
+// dependencies). If the input were guaranteed free of import cycles,
+// this would be trivial: we could simply wait for completion of the
+// dependencies and then invoke the typechecker.
+//
+// But as we saw in the 'go test' section above, some cycles in the
+// import graph over packages are actually legal, so long as the
+// cycle-forming edge originates in the in-package test files that
+// augment the package.  This explains why the nodes of the import
+// dependency graph are not packages, but lists of files: the unlabelled
+// nodes avoid the cycles.  Consider packages A and B where B imports A
+// and A's in-package tests AT import B.  The naively constructed import
+// graph over packages would contain a cycle (A+AT) --> B --> (A+AT) but
+// the graph over lists of files is AT --> B --> A, where AT is an
+// unlabelled node.
+//
+// Awaiting completion of the dependencies in a cyclic graph would
+// deadlock, so we must materialize the import dependency graph (as
+// importer.graph) and check whether each import edge forms a cycle.  If
+// x imports y, and the graph already contains a path from y to x, then
+// there is an import cycle, in which case the processing of x must not
+// wait for the completion of processing of y.
+//
+// When the type-checker makes a callback (doImport) to the loader for a
+// given import edge, there are two possible cases.  In the normal case,
+// the dependency has already been completely type-checked; doImport
+// does a cache lookup and returns it.  In the cyclic case, the entry in
+// the cache is still necessarily incomplete, indicating a cycle.  We
+// perform the cycle check again to obtain the error message, and return
+// the error.
+//
+// The result of using concurrency is about a 2.5x speedup for stdlib_test.
+
+// TODO(adonovan): overhaul the package documentation.
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/loader/loader.go b/src/margo.sh/vendor/golang.org/x/tools/go/loader/loader.go
new file mode 100644
index 00000000..de756f7f
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/loader/loader.go
@@ -0,0 +1,1077 @@
+// 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 loader
+
+// See doc.go for package documentation and implementation notes.
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+var ignoreVendor build.ImportMode
+
+const trace = false // show timing info for type-checking
+
+// Config specifies the configuration for loading a whole program from
+// Go source code.
+// The zero value for Config is a ready-to-use default configuration.
+type Config struct {
+	// Fset is the file set for the parser to use when loading the
+	// program.  If nil, it may be lazily initialized by any
+	// method of Config.
+	Fset *token.FileSet
+
+	// ParserMode specifies the mode to be used by the parser when
+	// loading source packages.
+	ParserMode parser.Mode
+
+	// TypeChecker contains options relating to the type checker.
+	//
+	// The supplied IgnoreFuncBodies is not used; the effective
+	// value comes from the TypeCheckFuncBodies func below.
+	// The supplied Import function is not used either.
+	TypeChecker types.Config
+
+	// TypeCheckFuncBodies is a predicate over package paths.
+	// A package for which the predicate is false will
+	// have its package-level declarations type checked, but not
+	// its function bodies; this can be used to quickly load
+	// dependencies from source.  If nil, all func bodies are type
+	// checked.
+	TypeCheckFuncBodies func(path string) bool
+
+	// If Build is non-nil, it is used to locate source packages.
+	// Otherwise &build.Default is used.
+	//
+	// By default, cgo is invoked to preprocess Go files that
+	// import the fake package "C".  This behaviour can be
+	// disabled by setting CGO_ENABLED=0 in the environment prior
+	// to startup, or by setting Build.CgoEnabled=false.
+	Build *build.Context
+
+	// The current directory, used for resolving relative package
+	// references such as "./go/loader".  If empty, os.Getwd will be
+	// used instead.
+	Cwd string
+
+	// If DisplayPath is non-nil, it is used to transform each
+	// file name obtained from Build.Import().  This can be used
+	// to prevent a virtualized build.Config's file names from
+	// leaking into the user interface.
+	DisplayPath func(path string) string
+
+	// If AllowErrors is true, Load will return a Program even
+	// if some of the its packages contained I/O, parser or type
+	// errors; such errors are accessible via PackageInfo.Errors.  If
+	// false, Load will fail if any package had an error.
+	AllowErrors bool
+
+	// CreatePkgs specifies a list of non-importable initial
+	// packages to create.  The resulting packages will appear in
+	// the corresponding elements of the Program.Created slice.
+	CreatePkgs []PkgSpec
+
+	// ImportPkgs specifies a set of initial packages to load.
+	// The map keys are package paths.
+	//
+	// The map value indicates whether to load tests.  If true, Load
+	// will add and type-check two lists of files to the package:
+	// non-test files followed by in-package *_test.go files.  In
+	// addition, it will append the external test package (if any)
+	// to Program.Created.
+	ImportPkgs map[string]bool
+
+	// FindPackage is called during Load to create the build.Package
+	// for a given import path from a given directory.
+	// If FindPackage is nil, (*build.Context).Import is used.
+	// A client may use this hook to adapt to a proprietary build
+	// system that does not follow the "go build" layout
+	// conventions, for example.
+	//
+	// It must be safe to call concurrently from multiple goroutines.
+	FindPackage func(ctxt *build.Context, importPath, fromDir string, mode build.ImportMode) (*build.Package, error)
+
+	// AfterTypeCheck is called immediately after a list of files
+	// has been type-checked and appended to info.Files.
+	//
+	// This optional hook function is the earliest opportunity for
+	// the client to observe the output of the type checker,
+	// which may be useful to reduce analysis latency when loading
+	// a large program.
+	//
+	// The function is permitted to modify info.Info, for instance
+	// to clear data structures that are no longer needed, which can
+	// dramatically reduce peak memory consumption.
+	//
+	// The function may be called twice for the same PackageInfo:
+	// once for the files of the package and again for the
+	// in-package test files.
+	//
+	// It must be safe to call concurrently from multiple goroutines.
+	AfterTypeCheck func(info *PackageInfo, files []*ast.File)
+}
+
+// A PkgSpec specifies a non-importable package to be created by Load.
+// Files are processed first, but typically only one of Files and
+// Filenames is provided.  The path needn't be globally unique.
+//
+// For vendoring purposes, the package's directory is the one that
+// contains the first file.
+type PkgSpec struct {
+	Path      string      // package path ("" => use package declaration)
+	Files     []*ast.File // ASTs of already-parsed files
+	Filenames []string    // names of files to be parsed
+}
+
+// A Program is a Go program loaded from source as specified by a Config.
+type Program struct {
+	Fset *token.FileSet // the file set for this program
+
+	// Created[i] contains the initial package whose ASTs or
+	// filenames were supplied by Config.CreatePkgs[i], followed by
+	// the external test package, if any, of each package in
+	// Config.ImportPkgs ordered by ImportPath.
+	//
+	// NOTE: these files must not import "C".  Cgo preprocessing is
+	// only performed on imported packages, not ad hoc packages.
+	//
+	// TODO(adonovan): we need to copy and adapt the logic of
+	// goFilesPackage (from $GOROOT/src/cmd/go/build.go) and make
+	// Config.Import and Config.Create methods return the same kind
+	// of entity, essentially a build.Package.
+	// Perhaps we can even reuse that type directly.
+	Created []*PackageInfo
+
+	// Imported contains the initially imported packages,
+	// as specified by Config.ImportPkgs.
+	Imported map[string]*PackageInfo
+
+	// AllPackages contains the PackageInfo of every package
+	// encountered by Load: all initial packages and all
+	// dependencies, including incomplete ones.
+	AllPackages map[*types.Package]*PackageInfo
+
+	// importMap is the canonical mapping of package paths to
+	// packages.  It contains all Imported initial packages, but not
+	// Created ones, and all imported dependencies.
+	importMap map[string]*types.Package
+}
+
+// PackageInfo holds the ASTs and facts derived by the type-checker
+// for a single package.
+//
+// Not mutated once exposed via the API.
+//
+type PackageInfo struct {
+	Pkg                   *types.Package
+	Importable            bool        // true if 'import "Pkg.Path()"' would resolve to this
+	TransitivelyErrorFree bool        // true if Pkg and all its dependencies are free of errors
+	Files                 []*ast.File // syntax trees for the package's files
+	Errors                []error     // non-nil if the package had errors
+	types.Info                        // type-checker deductions.
+	dir                   string      // package directory
+
+	checker   *types.Checker // transient type-checker state
+	errorFunc func(error)
+}
+
+func (info *PackageInfo) String() string { return info.Pkg.Path() }
+
+func (info *PackageInfo) appendError(err error) {
+	if info.errorFunc != nil {
+		info.errorFunc(err)
+	} else {
+		fmt.Fprintln(os.Stderr, err)
+	}
+	info.Errors = append(info.Errors, err)
+}
+
+func (conf *Config) fset() *token.FileSet {
+	if conf.Fset == nil {
+		conf.Fset = token.NewFileSet()
+	}
+	return conf.Fset
+}
+
+// ParseFile is a convenience function (intended for testing) that invokes
+// the parser using the Config's FileSet, which is initialized if nil.
+//
+// src specifies the parser input as a string, []byte, or io.Reader, and
+// filename is its apparent name.  If src is nil, the contents of
+// filename are read from the file system.
+//
+func (conf *Config) ParseFile(filename string, src interface{}) (*ast.File, error) {
+	// TODO(adonovan): use conf.build() etc like parseFiles does.
+	return parser.ParseFile(conf.fset(), filename, src, conf.ParserMode)
+}
+
+// FromArgsUsage is a partial usage message that applications calling
+// FromArgs may wish to include in their -help output.
+const FromArgsUsage = `
+<args> is a list of arguments denoting a set of initial packages.
+It may take one of two forms:
+
+1. A list of *.go source files.
+
+   All of the specified files are loaded, parsed and type-checked
+   as a single package.  All the files must belong to the same directory.
+
+2. A list of import paths, each denoting a package.
+
+   The package's directory is found relative to the $GOROOT and
+   $GOPATH using similar logic to 'go build', and the *.go files in
+   that directory are loaded, parsed and type-checked as a single
+   package.
+
+   In addition, all *_test.go files in the directory are then loaded
+   and parsed.  Those files whose package declaration equals that of
+   the non-*_test.go files are included in the primary package.  Test
+   files whose package declaration ends with "_test" are type-checked
+   as another package, the 'external' test package, so that a single
+   import path may denote two packages.  (Whether this behaviour is
+   enabled is tool-specific, and may depend on additional flags.)
+
+A '--' argument terminates the list of packages.
+`
+
+// FromArgs interprets args as a set of initial packages to load from
+// source and updates the configuration.  It returns the list of
+// unconsumed arguments.
+//
+// It is intended for use in command-line interfaces that require a
+// set of initial packages to be specified; see FromArgsUsage message
+// for details.
+//
+// Only superficial errors are reported at this stage; errors dependent
+// on I/O are detected during Load.
+//
+func (conf *Config) FromArgs(args []string, xtest bool) ([]string, error) {
+	var rest []string
+	for i, arg := range args {
+		if arg == "--" {
+			rest = args[i+1:]
+			args = args[:i]
+			break // consume "--" and return the remaining args
+		}
+	}
+
+	if len(args) > 0 && strings.HasSuffix(args[0], ".go") {
+		// Assume args is a list of a *.go files
+		// denoting a single ad hoc package.
+		for _, arg := range args {
+			if !strings.HasSuffix(arg, ".go") {
+				return nil, fmt.Errorf("named files must be .go files: %s", arg)
+			}
+		}
+		conf.CreateFromFilenames("", args...)
+	} else {
+		// Assume args are directories each denoting a
+		// package and (perhaps) an external test, iff xtest.
+		for _, arg := range args {
+			if xtest {
+				conf.ImportWithTests(arg)
+			} else {
+				conf.Import(arg)
+			}
+		}
+	}
+
+	return rest, nil
+}
+
+// CreateFromFilenames is a convenience function that adds
+// a conf.CreatePkgs entry to create a package of the specified *.go
+// files.
+//
+func (conf *Config) CreateFromFilenames(path string, filenames ...string) {
+	conf.CreatePkgs = append(conf.CreatePkgs, PkgSpec{Path: path, Filenames: filenames})
+}
+
+// CreateFromFiles is a convenience function that adds a conf.CreatePkgs
+// entry to create package of the specified path and parsed files.
+//
+func (conf *Config) CreateFromFiles(path string, files ...*ast.File) {
+	conf.CreatePkgs = append(conf.CreatePkgs, PkgSpec{Path: path, Files: files})
+}
+
+// ImportWithTests is a convenience function that adds path to
+// ImportPkgs, the set of initial source packages located relative to
+// $GOPATH.  The package will be augmented by any *_test.go files in
+// its directory that contain a "package x" (not "package x_test")
+// declaration.
+//
+// In addition, if any *_test.go files contain a "package x_test"
+// declaration, an additional package comprising just those files will
+// be added to CreatePkgs.
+//
+func (conf *Config) ImportWithTests(path string) { conf.addImport(path, true) }
+
+// Import is a convenience function that adds path to ImportPkgs, the
+// set of initial packages that will be imported from source.
+//
+func (conf *Config) Import(path string) { conf.addImport(path, false) }
+
+func (conf *Config) addImport(path string, tests bool) {
+	if path == "C" {
+		return // ignore; not a real package
+	}
+	if conf.ImportPkgs == nil {
+		conf.ImportPkgs = make(map[string]bool)
+	}
+	conf.ImportPkgs[path] = conf.ImportPkgs[path] || tests
+}
+
+// PathEnclosingInterval returns the PackageInfo and ast.Node that
+// contain source interval [start, end), and all the node's ancestors
+// up to the AST root.  It searches all ast.Files of all packages in prog.
+// exact is defined as for astutil.PathEnclosingInterval.
+//
+// The zero value is returned if not found.
+//
+func (prog *Program) PathEnclosingInterval(start, end token.Pos) (pkg *PackageInfo, path []ast.Node, exact bool) {
+	for _, info := range prog.AllPackages {
+		for _, f := range info.Files {
+			if f.Pos() == token.NoPos {
+				// This can happen if the parser saw
+				// too many errors and bailed out.
+				// (Use parser.AllErrors to prevent that.)
+				continue
+			}
+			if !tokenFileContainsPos(prog.Fset.File(f.Pos()), start) {
+				continue
+			}
+			if path, exact := astutil.PathEnclosingInterval(f, start, end); path != nil {
+				return info, path, exact
+			}
+		}
+	}
+	return nil, nil, false
+}
+
+// InitialPackages returns a new slice containing the set of initial
+// packages (Created + Imported) in unspecified order.
+//
+func (prog *Program) InitialPackages() []*PackageInfo {
+	infos := make([]*PackageInfo, 0, len(prog.Created)+len(prog.Imported))
+	infos = append(infos, prog.Created...)
+	for _, info := range prog.Imported {
+		infos = append(infos, info)
+	}
+	return infos
+}
+
+// Package returns the ASTs and results of type checking for the
+// specified package.
+func (prog *Program) Package(path string) *PackageInfo {
+	if info, ok := prog.AllPackages[prog.importMap[path]]; ok {
+		return info
+	}
+	for _, info := range prog.Created {
+		if path == info.Pkg.Path() {
+			return info
+		}
+	}
+	return nil
+}
+
+// ---------- Implementation ----------
+
+// importer holds the working state of the algorithm.
+type importer struct {
+	conf  *Config   // the client configuration
+	start time.Time // for logging
+
+	progMu sync.Mutex // guards prog
+	prog   *Program   // the resulting program
+
+	// findpkg is a memoization of FindPackage.
+	findpkgMu sync.Mutex // guards findpkg
+	findpkg   map[findpkgKey]*findpkgValue
+
+	importedMu sync.Mutex             // guards imported
+	imported   map[string]*importInfo // all imported packages (incl. failures) by import path
+
+	// import dependency graph: graph[x][y] => x imports y
+	//
+	// Since non-importable packages cannot be cyclic, we ignore
+	// their imports, thus we only need the subgraph over importable
+	// packages.  Nodes are identified by their import paths.
+	graphMu sync.Mutex
+	graph   map[string]map[string]bool
+}
+
+type findpkgKey struct {
+	importPath string
+	fromDir    string
+	mode       build.ImportMode
+}
+
+type findpkgValue struct {
+	ready chan struct{} // closed to broadcast readiness
+	bp    *build.Package
+	err   error
+}
+
+// importInfo tracks the success or failure of a single import.
+//
+// Upon completion, exactly one of info and err is non-nil:
+// info on successful creation of a package, err otherwise.
+// A successful package may still contain type errors.
+//
+type importInfo struct {
+	path     string        // import path
+	info     *PackageInfo  // results of typechecking (including errors)
+	complete chan struct{} // closed to broadcast that info is set.
+}
+
+// awaitCompletion blocks until ii is complete,
+// i.e. the info field is safe to inspect.
+func (ii *importInfo) awaitCompletion() {
+	<-ii.complete // wait for close
+}
+
+// Complete marks ii as complete.
+// Its info and err fields will not be subsequently updated.
+func (ii *importInfo) Complete(info *PackageInfo) {
+	if info == nil {
+		panic("info == nil")
+	}
+	ii.info = info
+	close(ii.complete)
+}
+
+type importError struct {
+	path string // import path
+	err  error  // reason for failure to create a package
+}
+
+// Load creates the initial packages specified by conf.{Create,Import}Pkgs,
+// loading their dependencies packages as needed.
+//
+// On success, Load returns a Program containing a PackageInfo for
+// each package.  On failure, it returns an error.
+//
+// If AllowErrors is true, Load will return a Program even if some
+// packages contained I/O, parser or type errors, or if dependencies
+// were missing.  (Such errors are accessible via PackageInfo.Errors.  If
+// false, Load will fail if any package had an error.
+//
+// It is an error if no packages were loaded.
+//
+func (conf *Config) Load() (*Program, error) {
+	// Create a simple default error handler for parse/type errors.
+	if conf.TypeChecker.Error == nil {
+		conf.TypeChecker.Error = func(e error) { fmt.Fprintln(os.Stderr, e) }
+	}
+
+	// Set default working directory for relative package references.
+	if conf.Cwd == "" {
+		var err error
+		conf.Cwd, err = os.Getwd()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Install default FindPackage hook using go/build logic.
+	if conf.FindPackage == nil {
+		conf.FindPackage = (*build.Context).Import
+	}
+
+	prog := &Program{
+		Fset:        conf.fset(),
+		Imported:    make(map[string]*PackageInfo),
+		importMap:   make(map[string]*types.Package),
+		AllPackages: make(map[*types.Package]*PackageInfo),
+	}
+
+	imp := importer{
+		conf:     conf,
+		prog:     prog,
+		findpkg:  make(map[findpkgKey]*findpkgValue),
+		imported: make(map[string]*importInfo),
+		start:    time.Now(),
+		graph:    make(map[string]map[string]bool),
+	}
+
+	// -- loading proper (concurrent phase) --------------------------------
+
+	var errpkgs []string // packages that contained errors
+
+	// Load the initially imported packages and their dependencies,
+	// in parallel.
+	// No vendor check on packages imported from the command line.
+	infos, importErrors := imp.importAll("", conf.Cwd, conf.ImportPkgs, ignoreVendor)
+	for _, ie := range importErrors {
+		conf.TypeChecker.Error(ie.err) // failed to create package
+		errpkgs = append(errpkgs, ie.path)
+	}
+	for _, info := range infos {
+		prog.Imported[info.Pkg.Path()] = info
+	}
+
+	// Augment the designated initial packages by their tests.
+	// Dependencies are loaded in parallel.
+	var xtestPkgs []*build.Package
+	for importPath, augment := range conf.ImportPkgs {
+		if !augment {
+			continue
+		}
+
+		// No vendor check on packages imported from command line.
+		bp, err := imp.findPackage(importPath, conf.Cwd, ignoreVendor)
+		if err != nil {
+			// Package not found, or can't even parse package declaration.
+			// Already reported by previous loop; ignore it.
+			continue
+		}
+
+		// Needs external test package?
+		if len(bp.XTestGoFiles) > 0 {
+			xtestPkgs = append(xtestPkgs, bp)
+		}
+
+		// Consult the cache using the canonical package path.
+		path := bp.ImportPath
+		imp.importedMu.Lock() // (unnecessary, we're sequential here)
+		ii, ok := imp.imported[path]
+		// Paranoid checks added due to issue #11012.
+		if !ok {
+			// Unreachable.
+			// The previous loop called importAll and thus
+			// startLoad for each path in ImportPkgs, which
+			// populates imp.imported[path] with a non-zero value.
+			panic(fmt.Sprintf("imported[%q] not found", path))
+		}
+		if ii == nil {
+			// Unreachable.
+			// The ii values in this loop are the same as in
+			// the previous loop, which enforced the invariant
+			// that at least one of ii.err and ii.info is non-nil.
+			panic(fmt.Sprintf("imported[%q] == nil", path))
+		}
+		if ii.info == nil {
+			// Unreachable.
+			// awaitCompletion has the postcondition
+			// ii.info != nil.
+			panic(fmt.Sprintf("imported[%q].info = nil", path))
+		}
+		info := ii.info
+		imp.importedMu.Unlock()
+
+		// Parse the in-package test files.
+		files, errs := imp.conf.parsePackageFiles(bp, 't')
+		for _, err := range errs {
+			info.appendError(err)
+		}
+
+		// The test files augmenting package P cannot be imported,
+		// but may import packages that import P,
+		// so we must disable the cycle check.
+		imp.addFiles(info, files, false)
+	}
+
+	createPkg := func(path, dir string, files []*ast.File, errs []error) {
+		info := imp.newPackageInfo(path, dir)
+		for _, err := range errs {
+			info.appendError(err)
+		}
+
+		// Ad hoc packages are non-importable,
+		// so no cycle check is needed.
+		// addFiles loads dependencies in parallel.
+		imp.addFiles(info, files, false)
+		prog.Created = append(prog.Created, info)
+	}
+
+	// Create packages specified by conf.CreatePkgs.
+	for _, cp := range conf.CreatePkgs {
+		files, errs := parseFiles(conf.fset(), conf.build(), nil, conf.Cwd, cp.Filenames, conf.ParserMode)
+		files = append(files, cp.Files...)
+
+		path := cp.Path
+		if path == "" {
+			if len(files) > 0 {
+				path = files[0].Name.Name
+			} else {
+				path = "(unnamed)"
+			}
+		}
+
+		dir := conf.Cwd
+		if len(files) > 0 && files[0].Pos().IsValid() {
+			dir = filepath.Dir(conf.fset().File(files[0].Pos()).Name())
+		}
+		createPkg(path, dir, files, errs)
+	}
+
+	// Create external test packages.
+	sort.Sort(byImportPath(xtestPkgs))
+	for _, bp := range xtestPkgs {
+		files, errs := imp.conf.parsePackageFiles(bp, 'x')
+		createPkg(bp.ImportPath+"_test", bp.Dir, files, errs)
+	}
+
+	// -- finishing up (sequential) ----------------------------------------
+
+	if len(prog.Imported)+len(prog.Created) == 0 {
+		return nil, errors.New("no initial packages were loaded")
+	}
+
+	// Create infos for indirectly imported packages.
+	// e.g. incomplete packages without syntax, loaded from export data.
+	for _, obj := range prog.importMap {
+		info := prog.AllPackages[obj]
+		if info == nil {
+			prog.AllPackages[obj] = &PackageInfo{Pkg: obj, Importable: true}
+		} else {
+			// finished
+			info.checker = nil
+			info.errorFunc = nil
+		}
+	}
+
+	if !conf.AllowErrors {
+		// Report errors in indirectly imported packages.
+		for _, info := range prog.AllPackages {
+			if len(info.Errors) > 0 {
+				errpkgs = append(errpkgs, info.Pkg.Path())
+			}
+		}
+		if errpkgs != nil {
+			var more string
+			if len(errpkgs) > 3 {
+				more = fmt.Sprintf(" and %d more", len(errpkgs)-3)
+				errpkgs = errpkgs[:3]
+			}
+			return nil, fmt.Errorf("couldn't load packages due to errors: %s%s",
+				strings.Join(errpkgs, ", "), more)
+		}
+	}
+
+	markErrorFreePackages(prog.AllPackages)
+
+	return prog, nil
+}
+
+type byImportPath []*build.Package
+
+func (b byImportPath) Len() int           { return len(b) }
+func (b byImportPath) Less(i, j int) bool { return b[i].ImportPath < b[j].ImportPath }
+func (b byImportPath) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+
+// markErrorFreePackages sets the TransitivelyErrorFree flag on all
+// applicable packages.
+func markErrorFreePackages(allPackages map[*types.Package]*PackageInfo) {
+	// Build the transpose of the import graph.
+	importedBy := make(map[*types.Package]map[*types.Package]bool)
+	for P := range allPackages {
+		for _, Q := range P.Imports() {
+			clients, ok := importedBy[Q]
+			if !ok {
+				clients = make(map[*types.Package]bool)
+				importedBy[Q] = clients
+			}
+			clients[P] = true
+		}
+	}
+
+	// Find all packages reachable from some error package.
+	reachable := make(map[*types.Package]bool)
+	var visit func(*types.Package)
+	visit = func(p *types.Package) {
+		if !reachable[p] {
+			reachable[p] = true
+			for q := range importedBy[p] {
+				visit(q)
+			}
+		}
+	}
+	for _, info := range allPackages {
+		if len(info.Errors) > 0 {
+			visit(info.Pkg)
+		}
+	}
+
+	// Mark the others as "transitively error-free".
+	for _, info := range allPackages {
+		if !reachable[info.Pkg] {
+			info.TransitivelyErrorFree = true
+		}
+	}
+}
+
+// build returns the effective build context.
+func (conf *Config) build() *build.Context {
+	if conf.Build != nil {
+		return conf.Build
+	}
+	return &build.Default
+}
+
+// parsePackageFiles enumerates the files belonging to package path,
+// then loads, parses and returns them, plus a list of I/O or parse
+// errors that were encountered.
+//
+// 'which' indicates which files to include:
+//    'g': include non-test *.go source files (GoFiles + processed CgoFiles)
+//    't': include in-package *_test.go source files (TestGoFiles)
+//    'x': include external *_test.go source files. (XTestGoFiles)
+//
+func (conf *Config) parsePackageFiles(bp *build.Package, which rune) ([]*ast.File, []error) {
+	if bp.ImportPath == "unsafe" {
+		return nil, nil
+	}
+	var filenames []string
+	switch which {
+	case 'g':
+		filenames = bp.GoFiles
+	case 't':
+		filenames = bp.TestGoFiles
+	case 'x':
+		filenames = bp.XTestGoFiles
+	default:
+		panic(which)
+	}
+
+	files, errs := parseFiles(conf.fset(), conf.build(), conf.DisplayPath, bp.Dir, filenames, conf.ParserMode)
+
+	// Preprocess CgoFiles and parse the outputs (sequentially).
+	if which == 'g' && bp.CgoFiles != nil {
+		cgofiles, err := processCgoFiles(bp, conf.fset(), conf.DisplayPath, conf.ParserMode)
+		if err != nil {
+			errs = append(errs, err)
+		} else {
+			files = append(files, cgofiles...)
+		}
+	}
+
+	return files, errs
+}
+
+// doImport imports the package denoted by path.
+// It implements the types.Importer signature.
+//
+// It returns an error if a package could not be created
+// (e.g. go/build or parse error), but type errors are reported via
+// the types.Config.Error callback (the first of which is also saved
+// in the package's PackageInfo).
+//
+// Idempotent.
+//
+func (imp *importer) doImport(from *PackageInfo, to string) (*types.Package, error) {
+	if to == "C" {
+		// This should be unreachable, but ad hoc packages are
+		// not currently subject to cgo preprocessing.
+		// See https://github.com/golang/go/issues/11627.
+		return nil, fmt.Errorf(`the loader doesn't cgo-process ad hoc packages like %q; see Go issue 11627`,
+			from.Pkg.Path())
+	}
+
+	bp, err := imp.findPackage(to, from.dir, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	// The standard unsafe package is handled specially,
+	// and has no PackageInfo.
+	if bp.ImportPath == "unsafe" {
+		return types.Unsafe, nil
+	}
+
+	// Look for the package in the cache using its canonical path.
+	path := bp.ImportPath
+	imp.importedMu.Lock()
+	ii := imp.imported[path]
+	imp.importedMu.Unlock()
+	if ii == nil {
+		panic("internal error: unexpected import: " + path)
+	}
+	if ii.info != nil {
+		return ii.info.Pkg, nil
+	}
+
+	// Import of incomplete package: this indicates a cycle.
+	fromPath := from.Pkg.Path()
+	if cycle := imp.findPath(path, fromPath); cycle != nil {
+		cycle = append([]string{fromPath}, cycle...)
+		return nil, fmt.Errorf("import cycle: %s", strings.Join(cycle, " -> "))
+	}
+
+	panic("internal error: import of incomplete (yet acyclic) package: " + fromPath)
+}
+
+// findPackage locates the package denoted by the importPath in the
+// specified directory.
+func (imp *importer) findPackage(importPath, fromDir string, mode build.ImportMode) (*build.Package, error) {
+	// We use a non-blocking duplicate-suppressing cache (gopl.io §9.7)
+	// to avoid holding the lock around FindPackage.
+	key := findpkgKey{importPath, fromDir, mode}
+	imp.findpkgMu.Lock()
+	v, ok := imp.findpkg[key]
+	if ok {
+		// cache hit
+		imp.findpkgMu.Unlock()
+
+		<-v.ready // wait for entry to become ready
+	} else {
+		// Cache miss: this goroutine becomes responsible for
+		// populating the map entry and broadcasting its readiness.
+		v = &findpkgValue{ready: make(chan struct{})}
+		imp.findpkg[key] = v
+		imp.findpkgMu.Unlock()
+
+		ioLimit <- true
+		v.bp, v.err = imp.conf.FindPackage(imp.conf.build(), importPath, fromDir, mode)
+		<-ioLimit
+
+		if _, ok := v.err.(*build.NoGoError); ok {
+			v.err = nil // empty directory is not an error
+		}
+
+		close(v.ready) // broadcast ready condition
+	}
+	return v.bp, v.err
+}
+
+// importAll loads, parses, and type-checks the specified packages in
+// parallel and returns their completed importInfos in unspecified order.
+//
+// fromPath is the package path of the importing package, if it is
+// importable, "" otherwise.  It is used for cycle detection.
+//
+// fromDir is the directory containing the import declaration that
+// caused these imports.
+//
+func (imp *importer) importAll(fromPath, fromDir string, imports map[string]bool, mode build.ImportMode) (infos []*PackageInfo, errors []importError) {
+	// TODO(adonovan): opt: do the loop in parallel once
+	// findPackage is non-blocking.
+	var pending []*importInfo
+	for importPath := range imports {
+		bp, err := imp.findPackage(importPath, fromDir, mode)
+		if err != nil {
+			errors = append(errors, importError{
+				path: importPath,
+				err:  err,
+			})
+			continue
+		}
+		pending = append(pending, imp.startLoad(bp))
+	}
+
+	if fromPath != "" {
+		// We're loading a set of imports.
+		//
+		// We must record graph edges from the importing package
+		// to its dependencies, and check for cycles.
+		imp.graphMu.Lock()
+		deps, ok := imp.graph[fromPath]
+		if !ok {
+			deps = make(map[string]bool)
+			imp.graph[fromPath] = deps
+		}
+		for _, ii := range pending {
+			deps[ii.path] = true
+		}
+		imp.graphMu.Unlock()
+	}
+
+	for _, ii := range pending {
+		if fromPath != "" {
+			if cycle := imp.findPath(ii.path, fromPath); cycle != nil {
+				// Cycle-forming import: we must not await its
+				// completion since it would deadlock.
+				//
+				// We don't record the error in ii since
+				// the error is really associated with the
+				// cycle-forming edge, not the package itself.
+				// (Also it would complicate the
+				// invariants of importPath completion.)
+				if trace {
+					fmt.Fprintf(os.Stderr, "import cycle: %q\n", cycle)
+				}
+				continue
+			}
+		}
+		ii.awaitCompletion()
+		infos = append(infos, ii.info)
+	}
+
+	return infos, errors
+}
+
+// findPath returns an arbitrary path from 'from' to 'to' in the import
+// graph, or nil if there was none.
+func (imp *importer) findPath(from, to string) []string {
+	imp.graphMu.Lock()
+	defer imp.graphMu.Unlock()
+
+	seen := make(map[string]bool)
+	var search func(stack []string, importPath string) []string
+	search = func(stack []string, importPath string) []string {
+		if !seen[importPath] {
+			seen[importPath] = true
+			stack = append(stack, importPath)
+			if importPath == to {
+				return stack
+			}
+			for x := range imp.graph[importPath] {
+				if p := search(stack, x); p != nil {
+					return p
+				}
+			}
+		}
+		return nil
+	}
+	return search(make([]string, 0, 20), from)
+}
+
+// startLoad initiates the loading, parsing and type-checking of the
+// specified package and its dependencies, if it has not already begun.
+//
+// It returns an importInfo, not necessarily in a completed state.  The
+// caller must call awaitCompletion() before accessing its info field.
+//
+// startLoad is concurrency-safe and idempotent.
+//
+func (imp *importer) startLoad(bp *build.Package) *importInfo {
+	path := bp.ImportPath
+	imp.importedMu.Lock()
+	ii, ok := imp.imported[path]
+	if !ok {
+		ii = &importInfo{path: path, complete: make(chan struct{})}
+		imp.imported[path] = ii
+		go func() {
+			info := imp.load(bp)
+			ii.Complete(info)
+		}()
+	}
+	imp.importedMu.Unlock()
+
+	return ii
+}
+
+// load implements package loading by parsing Go source files
+// located by go/build.
+func (imp *importer) load(bp *build.Package) *PackageInfo {
+	info := imp.newPackageInfo(bp.ImportPath, bp.Dir)
+	info.Importable = true
+	files, errs := imp.conf.parsePackageFiles(bp, 'g')
+	for _, err := range errs {
+		info.appendError(err)
+	}
+
+	imp.addFiles(info, files, true)
+
+	imp.progMu.Lock()
+	imp.prog.importMap[bp.ImportPath] = info.Pkg
+	imp.progMu.Unlock()
+
+	return info
+}
+
+// addFiles adds and type-checks the specified files to info, loading
+// their dependencies if needed.  The order of files determines the
+// package initialization order.  It may be called multiple times on the
+// same package.  Errors are appended to the info.Errors field.
+//
+// cycleCheck determines whether the imports within files create
+// dependency edges that should be checked for potential cycles.
+//
+func (imp *importer) addFiles(info *PackageInfo, files []*ast.File, cycleCheck bool) {
+	// Ensure the dependencies are loaded, in parallel.
+	var fromPath string
+	if cycleCheck {
+		fromPath = info.Pkg.Path()
+	}
+	// TODO(adonovan): opt: make the caller do scanImports.
+	// Callers with a build.Package can skip it.
+	imp.importAll(fromPath, info.dir, scanImports(files), 0)
+
+	if trace {
+		fmt.Fprintf(os.Stderr, "%s: start %q (%d)\n",
+			time.Since(imp.start), info.Pkg.Path(), len(files))
+	}
+
+	// Don't call checker.Files on Unsafe, even with zero files,
+	// because it would mutate the package, which is a global.
+	if info.Pkg == types.Unsafe {
+		if len(files) > 0 {
+			panic(`"unsafe" package contains unexpected files`)
+		}
+	} else {
+		// Ignore the returned (first) error since we
+		// already collect them all in the PackageInfo.
+		info.checker.Files(files)
+		info.Files = append(info.Files, files...)
+	}
+
+	if imp.conf.AfterTypeCheck != nil {
+		imp.conf.AfterTypeCheck(info, files)
+	}
+
+	if trace {
+		fmt.Fprintf(os.Stderr, "%s: stop %q\n",
+			time.Since(imp.start), info.Pkg.Path())
+	}
+}
+
+func (imp *importer) newPackageInfo(path, dir string) *PackageInfo {
+	var pkg *types.Package
+	if path == "unsafe" {
+		pkg = types.Unsafe
+	} else {
+		pkg = types.NewPackage(path, "")
+	}
+	info := &PackageInfo{
+		Pkg: pkg,
+		Info: types.Info{
+			Types:      make(map[ast.Expr]types.TypeAndValue),
+			Defs:       make(map[*ast.Ident]types.Object),
+			Uses:       make(map[*ast.Ident]types.Object),
+			Implicits:  make(map[ast.Node]types.Object),
+			Scopes:     make(map[ast.Node]*types.Scope),
+			Selections: make(map[*ast.SelectorExpr]*types.Selection),
+		},
+		errorFunc: imp.conf.TypeChecker.Error,
+		dir:       dir,
+	}
+
+	// Copy the types.Config so we can vary it across PackageInfos.
+	tc := imp.conf.TypeChecker
+	tc.IgnoreFuncBodies = false
+	if f := imp.conf.TypeCheckFuncBodies; f != nil {
+		tc.IgnoreFuncBodies = !f(path)
+	}
+	tc.Importer = closure{imp, info}
+	tc.Error = info.appendError // appendError wraps the user's Error function
+
+	info.checker = types.NewChecker(&tc, imp.conf.fset(), pkg, &info.Info)
+	imp.progMu.Lock()
+	imp.prog.AllPackages[pkg] = info
+	imp.progMu.Unlock()
+	return info
+}
+
+type closure struct {
+	imp  *importer
+	info *PackageInfo
+}
+
+func (c closure) Import(to string) (*types.Package, error) { return c.imp.doImport(c.info, to) }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/loader/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/loader/util.go
new file mode 100644
index 00000000..7f38dd74
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/loader/util.go
@@ -0,0 +1,124 @@
+// 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 loader
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"strconv"
+	"sync"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+// We use a counting semaphore to limit
+// the number of parallel I/O calls per process.
+var ioLimit = make(chan bool, 10)
+
+// parseFiles parses the Go source files within directory dir and
+// returns the ASTs of the ones that could be at least partially parsed,
+// along with a list of I/O and parse errors encountered.
+//
+// I/O is done via ctxt, which may specify a virtual file system.
+// displayPath is used to transform the filenames attached to the ASTs.
+//
+func parseFiles(fset *token.FileSet, ctxt *build.Context, displayPath func(string) string, dir string, files []string, mode parser.Mode) ([]*ast.File, []error) {
+	if displayPath == nil {
+		displayPath = func(path string) string { return path }
+	}
+	var wg sync.WaitGroup
+	n := len(files)
+	parsed := make([]*ast.File, n)
+	errors := make([]error, n)
+	for i, file := range files {
+		if !buildutil.IsAbsPath(ctxt, file) {
+			file = buildutil.JoinPath(ctxt, dir, file)
+		}
+		wg.Add(1)
+		go func(i int, file string) {
+			ioLimit <- true // wait
+			defer func() {
+				wg.Done()
+				<-ioLimit // signal
+			}()
+			var rd io.ReadCloser
+			var err error
+			if ctxt.OpenFile != nil {
+				rd, err = ctxt.OpenFile(file)
+			} else {
+				rd, err = os.Open(file)
+			}
+			if err != nil {
+				errors[i] = err // open failed
+				return
+			}
+
+			// ParseFile may return both an AST and an error.
+			parsed[i], errors[i] = parser.ParseFile(fset, displayPath(file), rd, mode)
+			rd.Close()
+		}(i, file)
+	}
+	wg.Wait()
+
+	// Eliminate nils, preserving order.
+	var o int
+	for _, f := range parsed {
+		if f != nil {
+			parsed[o] = f
+			o++
+		}
+	}
+	parsed = parsed[:o]
+
+	o = 0
+	for _, err := range errors {
+		if err != nil {
+			errors[o] = err
+			o++
+		}
+	}
+	errors = errors[:o]
+
+	return parsed, errors
+}
+
+// scanImports returns the set of all import paths from all
+// import specs in the specified files.
+func scanImports(files []*ast.File) map[string]bool {
+	imports := make(map[string]bool)
+	for _, f := range files {
+		for _, decl := range f.Decls {
+			if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT {
+				for _, spec := range decl.Specs {
+					spec := spec.(*ast.ImportSpec)
+
+					// NB: do not assume the program is well-formed!
+					path, err := strconv.Unquote(spec.Path.Value)
+					if err != nil {
+						continue // quietly ignore the error
+					}
+					if path == "C" {
+						continue // skip pseudopackage
+					}
+					imports[path] = true
+				}
+			}
+		}
+	}
+	return imports
+}
+
+// ---------- Internal helpers ----------
+
+// TODO(adonovan): make this a method: func (*token.File) Contains(token.Pos)
+func tokenFileContainsPos(f *token.File, pos token.Pos) bool {
+	p := int(pos)
+	base := f.Base()
+	return base <= p && p < base+f.Size()
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/TODO b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/TODO
new file mode 100644
index 00000000..f95e7062
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/TODO
@@ -0,0 +1,33 @@
+-*- text -*-
+
+Pointer analysis to-do list
+===========================
+
+CONSTRAINT GENERATION:
+- support reflection:
+  - a couple of operators are missing
+  - reflect.Values may contain lvalues (CanAddr)
+- implement native intrinsics.  These vary by platform.
+- add to pts(a.panic) a label representing all runtime panics, e.g.
+  runtime.{TypeAssertionError,errorString,errorCString}.
+
+OPTIMISATIONS
+- pre-solver: 
+  pointer equivalence: extend HVN to HRU
+  location equivalence
+- solver: HCD, LCD.
+- experiment with map+slice worklist in lieu of bitset.
+  It may have faster insert.
+
+MISC:
+- Test on all platforms.  
+  Currently we assume these go/build tags: linux, amd64, !cgo.
+
+MAINTAINABILITY
+- Think about ways to make debugging this code easier.  PTA logs
+  routinely exceed a million lines and require training to read.
+
+BUGS: 
+- There's a crash bug in stdlib_test + reflection, rVCallConstraint.
+
+
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/analysis.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/analysis.go
new file mode 100644
index 00000000..0abb04dd
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/analysis.go
@@ -0,0 +1,452 @@
+// 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 pointer
+
+// This file defines the main datatypes and Analyze function of the pointer analysis.
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"reflect"
+	"runtime"
+	"runtime/debug"
+	"sort"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+const (
+	// optimization options; enable all when committing
+	optRenumber = true // enable renumbering optimization (makes logs hard to read)
+	optHVN      = true // enable pointer equivalence via Hash-Value Numbering
+
+	// debugging options; disable all when committing
+	debugHVN           = false // enable assertions in HVN
+	debugHVNVerbose    = false // enable extra HVN logging
+	debugHVNCrossCheck = false // run solver with/without HVN and compare (caveats below)
+	debugTimers        = false // show running time of each phase
+)
+
+// object.flags bitmask values.
+const (
+	otTagged   = 1 << iota // type-tagged object
+	otIndirect             // type-tagged object with indirect payload
+	otFunction             // function object
+)
+
+// An object represents a contiguous block of memory to which some
+// (generalized) pointer may point.
+//
+// (Note: most variables called 'obj' are not *objects but nodeids
+// such that a.nodes[obj].obj != nil.)
+//
+type object struct {
+	// flags is a bitset of the node type (ot*) flags defined above.
+	flags uint32
+
+	// Number of following nodes belonging to the same "object"
+	// allocation.  Zero for all other nodes.
+	size uint32
+
+	// data describes this object; it has one of these types:
+	//
+	// ssa.Value	for an object allocated by an SSA operation.
+	// types.Type	for an rtype instance object or *rtype-tagged object.
+	// string	for an instrinsic object, e.g. the array behind os.Args.
+	// nil		for an object allocated by an instrinsic.
+	//		(cgn provides the identity of the intrinsic.)
+	data interface{}
+
+	// The call-graph node (=context) in which this object was allocated.
+	// May be nil for global objects: Global, Const, some Functions.
+	cgn *cgnode
+}
+
+// nodeid denotes a node.
+// It is an index within analysis.nodes.
+// We use small integers, not *node pointers, for many reasons:
+// - they are smaller on 64-bit systems.
+// - sets of them can be represented compactly in bitvectors or BDDs.
+// - order matters; a field offset can be computed by simple addition.
+type nodeid uint32
+
+// A node is an equivalence class of memory locations.
+// Nodes may be pointers, pointed-to locations, neither, or both.
+//
+// Nodes that are pointed-to locations ("labels") have an enclosing
+// object (see analysis.enclosingObject).
+//
+type node struct {
+	// If non-nil, this node is the start of an object
+	// (addressable memory location).
+	// The following obj.size nodes implicitly belong to the object;
+	// they locate their object by scanning back.
+	obj *object
+
+	// The type of the field denoted by this node.  Non-aggregate,
+	// unless this is an tagged.T node (i.e. the thing
+	// pointed to by an interface) in which case typ is that type.
+	typ types.Type
+
+	// subelement indicates which directly embedded subelement of
+	// an object of aggregate type (struct, tuple, array) this is.
+	subelement *fieldInfo // e.g. ".a.b[*].c"
+
+	// Solver state for the canonical node of this pointer-
+	// equivalence class.  Each node is created with its own state
+	// but they become shared after HVN.
+	solve *solverState
+}
+
+// An analysis instance holds the state of a single pointer analysis problem.
+type analysis struct {
+	config      *Config                     // the client's control/observer interface
+	prog        *ssa.Program                // the program being analyzed
+	log         io.Writer                   // log stream; nil to disable
+	panicNode   nodeid                      // sink for panic, source for recover
+	nodes       []*node                     // indexed by nodeid
+	flattenMemo map[types.Type][]*fieldInfo // memoization of flatten()
+	trackTypes  map[types.Type]bool         // memoization of shouldTrack()
+	constraints []constraint                // set of constraints
+	cgnodes     []*cgnode                   // all cgnodes
+	genq        []*cgnode                   // queue of functions to generate constraints for
+	intrinsics  map[*ssa.Function]intrinsic // non-nil values are summaries for intrinsic fns
+	globalval   map[ssa.Value]nodeid        // node for each global ssa.Value
+	globalobj   map[ssa.Value]nodeid        // maps v to sole member of pts(v), if singleton
+	localval    map[ssa.Value]nodeid        // node for each local ssa.Value
+	localobj    map[ssa.Value]nodeid        // maps v to sole member of pts(v), if singleton
+	atFuncs     map[*ssa.Function]bool      // address-taken functions (for presolver)
+	mapValues   []nodeid                    // values of makemap objects (indirect in HVN)
+	work        nodeset                     // solver's worklist
+	result      *Result                     // results of the analysis
+	track       track                       // pointerlike types whose aliasing we track
+	deltaSpace  []int                       // working space for iterating over PTS deltas
+
+	// Reflection & intrinsics:
+	hasher              typeutil.Hasher // cache of type hashes
+	reflectValueObj     types.Object    // type symbol for reflect.Value (if present)
+	reflectValueCall    *ssa.Function   // (reflect.Value).Call
+	reflectRtypeObj     types.Object    // *types.TypeName for reflect.rtype (if present)
+	reflectRtypePtr     *types.Pointer  // *reflect.rtype
+	reflectType         *types.Named    // reflect.Type
+	rtypes              typeutil.Map    // nodeid of canonical *rtype-tagged object for type T
+	reflectZeros        typeutil.Map    // nodeid of canonical T-tagged object for zero value
+	runtimeSetFinalizer *ssa.Function   // runtime.SetFinalizer
+}
+
+// enclosingObj returns the first node of the addressable memory
+// object that encloses node id.  Panic ensues if that node does not
+// belong to any object.
+func (a *analysis) enclosingObj(id nodeid) nodeid {
+	// Find previous node with obj != nil.
+	for i := id; i >= 0; i-- {
+		n := a.nodes[i]
+		if obj := n.obj; obj != nil {
+			if i+nodeid(obj.size) <= id {
+				break // out of bounds
+			}
+			return i
+		}
+	}
+	panic("node has no enclosing object")
+}
+
+// labelFor returns the Label for node id.
+// Panic ensues if that node is not addressable.
+func (a *analysis) labelFor(id nodeid) *Label {
+	return &Label{
+		obj:        a.nodes[a.enclosingObj(id)].obj,
+		subelement: a.nodes[id].subelement,
+	}
+}
+
+func (a *analysis) warnf(pos token.Pos, format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	if a.log != nil {
+		fmt.Fprintf(a.log, "%s: warning: %s\n", a.prog.Fset.Position(pos), msg)
+	}
+	a.result.Warnings = append(a.result.Warnings, Warning{pos, msg})
+}
+
+// computeTrackBits sets a.track to the necessary 'track' bits for the pointer queries.
+func (a *analysis) computeTrackBits() {
+	if len(a.config.extendedQueries) != 0 {
+		// TODO(dh): only track the types necessary for the query.
+		a.track = trackAll
+		return
+	}
+	var queryTypes []types.Type
+	for v := range a.config.Queries {
+		queryTypes = append(queryTypes, v.Type())
+	}
+	for v := range a.config.IndirectQueries {
+		queryTypes = append(queryTypes, mustDeref(v.Type()))
+	}
+	for _, t := range queryTypes {
+		switch t.Underlying().(type) {
+		case *types.Chan:
+			a.track |= trackChan
+		case *types.Map:
+			a.track |= trackMap
+		case *types.Pointer:
+			a.track |= trackPtr
+		case *types.Slice:
+			a.track |= trackSlice
+		case *types.Interface:
+			a.track = trackAll
+			return
+		}
+		if rVObj := a.reflectValueObj; rVObj != nil && types.Identical(t, rVObj.Type()) {
+			a.track = trackAll
+			return
+		}
+	}
+}
+
+// Analyze runs the pointer analysis with the scope and options
+// specified by config, and returns the (synthetic) root of the callgraph.
+//
+// Pointer analysis of a transitively closed well-typed program should
+// always succeed.  An error can occur only due to an internal bug.
+//
+func Analyze(config *Config) (result *Result, err error) {
+	if config.Mains == nil {
+		return nil, fmt.Errorf("no main/test packages to analyze (check $GOROOT/$GOPATH)")
+	}
+	defer func() {
+		if p := recover(); p != nil {
+			err = fmt.Errorf("internal error in pointer analysis: %v (please report this bug)", p)
+			fmt.Fprintln(os.Stderr, "Internal panic in pointer analysis:")
+			debug.PrintStack()
+		}
+	}()
+
+	a := &analysis{
+		config:      config,
+		log:         config.Log,
+		prog:        config.prog(),
+		globalval:   make(map[ssa.Value]nodeid),
+		globalobj:   make(map[ssa.Value]nodeid),
+		flattenMemo: make(map[types.Type][]*fieldInfo),
+		trackTypes:  make(map[types.Type]bool),
+		atFuncs:     make(map[*ssa.Function]bool),
+		hasher:      typeutil.MakeHasher(),
+		intrinsics:  make(map[*ssa.Function]intrinsic),
+		result: &Result{
+			Queries:         make(map[ssa.Value]Pointer),
+			IndirectQueries: make(map[ssa.Value]Pointer),
+		},
+		deltaSpace: make([]int, 0, 100),
+	}
+
+	if false {
+		a.log = os.Stderr // for debugging crashes; extremely verbose
+	}
+
+	if a.log != nil {
+		fmt.Fprintln(a.log, "==== Starting analysis")
+	}
+
+	// Pointer analysis requires a complete program for soundness.
+	// Check to prevent accidental misconfiguration.
+	for _, pkg := range a.prog.AllPackages() {
+		// (This only checks that the package scope is complete,
+		// not that func bodies exist, but it's a good signal.)
+		if !pkg.Pkg.Complete() {
+			return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete`, pkg.Pkg.Path())
+		}
+	}
+
+	if reflect := a.prog.ImportedPackage("reflect"); reflect != nil {
+		rV := reflect.Pkg.Scope().Lookup("Value")
+		a.reflectValueObj = rV
+		a.reflectValueCall = a.prog.LookupMethod(rV.Type(), nil, "Call")
+		a.reflectType = reflect.Pkg.Scope().Lookup("Type").Type().(*types.Named)
+		a.reflectRtypeObj = reflect.Pkg.Scope().Lookup("rtype")
+		a.reflectRtypePtr = types.NewPointer(a.reflectRtypeObj.Type())
+
+		// Override flattening of reflect.Value, treating it like a basic type.
+		tReflectValue := a.reflectValueObj.Type()
+		a.flattenMemo[tReflectValue] = []*fieldInfo{{typ: tReflectValue}}
+
+		// Override shouldTrack of reflect.Value and *reflect.rtype.
+		// Always track pointers of these types.
+		a.trackTypes[tReflectValue] = true
+		a.trackTypes[a.reflectRtypePtr] = true
+
+		a.rtypes.SetHasher(a.hasher)
+		a.reflectZeros.SetHasher(a.hasher)
+	}
+	if runtime := a.prog.ImportedPackage("runtime"); runtime != nil {
+		a.runtimeSetFinalizer = runtime.Func("SetFinalizer")
+	}
+	a.computeTrackBits()
+
+	a.generate()
+	a.showCounts()
+
+	if optRenumber {
+		a.renumber()
+	}
+
+	N := len(a.nodes) // excludes solver-created nodes
+
+	if optHVN {
+		if debugHVNCrossCheck {
+			// Cross-check: run the solver once without
+			// optimization, once with, and compare the
+			// solutions.
+			savedConstraints := a.constraints
+
+			a.solve()
+			a.dumpSolution("A.pts", N)
+
+			// Restore.
+			a.constraints = savedConstraints
+			for _, n := range a.nodes {
+				n.solve = new(solverState)
+			}
+			a.nodes = a.nodes[:N]
+
+			// rtypes is effectively part of the solver state.
+			a.rtypes = typeutil.Map{}
+			a.rtypes.SetHasher(a.hasher)
+		}
+
+		a.hvn()
+	}
+
+	if debugHVNCrossCheck {
+		runtime.GC()
+		runtime.GC()
+	}
+
+	a.solve()
+
+	// Compare solutions.
+	if optHVN && debugHVNCrossCheck {
+		a.dumpSolution("B.pts", N)
+
+		if !diff("A.pts", "B.pts") {
+			return nil, fmt.Errorf("internal error: optimization changed solution")
+		}
+	}
+
+	// Create callgraph.Nodes in deterministic order.
+	if cg := a.result.CallGraph; cg != nil {
+		for _, caller := range a.cgnodes {
+			cg.CreateNode(caller.fn)
+		}
+	}
+
+	// Add dynamic edges to call graph.
+	var space [100]int
+	for _, caller := range a.cgnodes {
+		for _, site := range caller.sites {
+			for _, callee := range a.nodes[site.targets].solve.pts.AppendTo(space[:0]) {
+				a.callEdge(caller, site, nodeid(callee))
+			}
+		}
+	}
+
+	return a.result, nil
+}
+
+// callEdge is called for each edge in the callgraph.
+// calleeid is the callee's object node (has otFunction flag).
+//
+func (a *analysis) callEdge(caller *cgnode, site *callsite, calleeid nodeid) {
+	obj := a.nodes[calleeid].obj
+	if obj.flags&otFunction == 0 {
+		panic(fmt.Sprintf("callEdge %s -> n%d: not a function object", site, calleeid))
+	}
+	callee := obj.cgn
+
+	if cg := a.result.CallGraph; cg != nil {
+		// TODO(adonovan): opt: I would expect duplicate edges
+		// (to wrappers) to arise due to the elimination of
+		// context information, but I haven't observed any.
+		// Understand this better.
+		callgraph.AddEdge(cg.CreateNode(caller.fn), site.instr, cg.CreateNode(callee.fn))
+	}
+
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\tcall edge %s -> %s\n", site, callee)
+	}
+
+	// Warn about calls to non-intrinsic external functions.
+	// TODO(adonovan): de-dup these messages.
+	if fn := callee.fn; fn.Blocks == nil && a.findIntrinsic(fn) == nil {
+		a.warnf(site.pos(), "unsound call to unknown intrinsic: %s", fn)
+		a.warnf(fn.Pos(), " (declared here)")
+	}
+}
+
+// dumpSolution writes the PTS solution to the specified file.
+//
+// It only dumps the nodes that existed before solving.  The order in
+// which solver-created nodes are created depends on pre-solver
+// optimization, so we can't include them in the cross-check.
+//
+func (a *analysis) dumpSolution(filename string, N int) {
+	f, err := os.Create(filename)
+	if err != nil {
+		panic(err)
+	}
+	for id, n := range a.nodes[:N] {
+		if _, err := fmt.Fprintf(f, "pts(n%d) = {", id); err != nil {
+			panic(err)
+		}
+		var sep string
+		for _, l := range n.solve.pts.AppendTo(a.deltaSpace) {
+			if l >= N {
+				break
+			}
+			fmt.Fprintf(f, "%s%d", sep, l)
+			sep = " "
+		}
+		fmt.Fprintf(f, "} : %s\n", n.typ)
+	}
+	if err := f.Close(); err != nil {
+		panic(err)
+	}
+}
+
+// showCounts logs the size of the constraint system.  A typical
+// optimized distribution is 65% copy, 13% load, 11% addr, 5%
+// offsetAddr, 4% store, 2% others.
+//
+func (a *analysis) showCounts() {
+	if a.log != nil {
+		counts := make(map[reflect.Type]int)
+		for _, c := range a.constraints {
+			counts[reflect.TypeOf(c)]++
+		}
+		fmt.Fprintf(a.log, "# constraints:\t%d\n", len(a.constraints))
+		var lines []string
+		for t, n := range counts {
+			line := fmt.Sprintf("%7d  (%2d%%)\t%s", n, 100*n/len(a.constraints), t)
+			lines = append(lines, line)
+		}
+		sort.Sort(sort.Reverse(sort.StringSlice(lines)))
+		for _, line := range lines {
+			fmt.Fprintf(a.log, "\t%s\n", line)
+		}
+
+		fmt.Fprintf(a.log, "# nodes:\t%d\n", len(a.nodes))
+
+		// Show number of pointer equivalence classes.
+		m := make(map[*solverState]bool)
+		for _, n := range a.nodes {
+			m[n.solve] = true
+		}
+		fmt.Fprintf(a.log, "# ptsets:\t%d\n", len(m))
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/api.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/api.go
new file mode 100644
index 00000000..2b7e79e6
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/api.go
@@ -0,0 +1,285 @@
+// 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 pointer
+
+import (
+	"bytes"
+	"fmt"
+	"go/token"
+	"io"
+
+	"golang.org/x/tools/container/intsets"
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// A Config formulates a pointer analysis problem for Analyze. It is
+// only usable for a single invocation of Analyze and must not be
+// reused.
+type Config struct {
+	// Mains contains the set of 'main' packages to analyze
+	// Clients must provide the analysis with at least one
+	// package defining a main() function.
+	//
+	// Non-main packages in the ssa.Program that are not
+	// dependencies of any main package may still affect the
+	// analysis result, because they contribute runtime types and
+	// thus methods.
+	// TODO(adonovan): investigate whether this is desirable.
+	Mains []*ssa.Package
+
+	// Reflection determines whether to handle reflection
+	// operators soundly, which is currently rather slow since it
+	// causes constraint to be generated during solving
+	// proportional to the number of constraint variables, which
+	// has not yet been reduced by presolver optimisation.
+	Reflection bool
+
+	// BuildCallGraph determines whether to construct a callgraph.
+	// If enabled, the graph will be available in Result.CallGraph.
+	BuildCallGraph bool
+
+	// The client populates Queries[v] or IndirectQueries[v]
+	// for each ssa.Value v of interest, to request that the
+	// points-to sets pts(v) or pts(*v) be computed.  If the
+	// client needs both points-to sets, v may appear in both
+	// maps.
+	//
+	// (IndirectQueries is typically used for Values corresponding
+	// to source-level lvalues, e.g. an *ssa.Global.)
+	//
+	// The analysis populates the corresponding
+	// Result.{Indirect,}Queries map when it creates the pointer
+	// variable for v or *v.  Upon completion the client can
+	// inspect that map for the results.
+	//
+	// TODO(adonovan): this API doesn't scale well for batch tools
+	// that want to dump the entire solution.  Perhaps optionally
+	// populate a map[*ssa.DebugRef]Pointer in the Result, one
+	// entry per source expression.
+	//
+	Queries         map[ssa.Value]struct{}
+	IndirectQueries map[ssa.Value]struct{}
+	extendedQueries map[ssa.Value][]*extendedQuery
+
+	// If Log is non-nil, log messages are written to it.
+	// Logging is extremely verbose.
+	Log io.Writer
+}
+
+type track uint32
+
+const (
+	trackChan  track = 1 << iota // track 'chan' references
+	trackMap                     // track 'map' references
+	trackPtr                     // track regular pointers
+	trackSlice                   // track slice references
+
+	trackAll = ^track(0)
+)
+
+// AddQuery adds v to Config.Queries.
+// Precondition: CanPoint(v.Type()).
+func (c *Config) AddQuery(v ssa.Value) {
+	if !CanPoint(v.Type()) {
+		panic(fmt.Sprintf("%s is not a pointer-like value: %s", v, v.Type()))
+	}
+	if c.Queries == nil {
+		c.Queries = make(map[ssa.Value]struct{})
+	}
+	c.Queries[v] = struct{}{}
+}
+
+// AddQuery adds v to Config.IndirectQueries.
+// Precondition: CanPoint(v.Type().Underlying().(*types.Pointer).Elem()).
+func (c *Config) AddIndirectQuery(v ssa.Value) {
+	if c.IndirectQueries == nil {
+		c.IndirectQueries = make(map[ssa.Value]struct{})
+	}
+	if !CanPoint(mustDeref(v.Type())) {
+		panic(fmt.Sprintf("%s is not the address of a pointer-like value: %s", v, v.Type()))
+	}
+	c.IndirectQueries[v] = struct{}{}
+}
+
+// AddExtendedQuery adds an extended, AST-based query on v to the
+// analysis. The query, which must be a single Go expression, allows
+// destructuring the value.
+//
+// The query must operate on a variable named 'x', which represents
+// the value, and result in a pointer-like object. Only a subset of
+// Go expressions are permitted in queries, namely channel receives,
+// pointer dereferences, field selectors, array/slice/map/tuple
+// indexing and grouping with parentheses. The specific indices when
+// indexing arrays, slices and maps have no significance. Indices used
+// on tuples must be numeric and within bounds.
+//
+// All field selectors must be explicit, even ones usually elided
+// due to promotion of embedded fields.
+//
+// The query 'x' is identical to using AddQuery. The query '*x' is
+// identical to using AddIndirectQuery.
+//
+// On success, AddExtendedQuery returns a Pointer to the queried
+// value. This Pointer will be initialized during analysis. Using it
+// before analysis has finished has undefined behavior.
+//
+// Example:
+// 	// given v, which represents a function call to 'fn() (int, []*T)', and
+// 	// 'type T struct { F *int }', the following query will access the field F.
+// 	c.AddExtendedQuery(v, "x[1][0].F")
+func (c *Config) AddExtendedQuery(v ssa.Value, query string) (*Pointer, error) {
+	ops, _, err := parseExtendedQuery(v.Type().Underlying(), query)
+	if err != nil {
+		return nil, fmt.Errorf("invalid query %q: %s", query, err)
+	}
+	if c.extendedQueries == nil {
+		c.extendedQueries = make(map[ssa.Value][]*extendedQuery)
+	}
+
+	ptr := &Pointer{}
+	c.extendedQueries[v] = append(c.extendedQueries[v], &extendedQuery{ops: ops, ptr: ptr})
+	return ptr, nil
+}
+
+func (c *Config) prog() *ssa.Program {
+	for _, main := range c.Mains {
+		return main.Prog
+	}
+	panic("empty scope")
+}
+
+type Warning struct {
+	Pos     token.Pos
+	Message string
+}
+
+// A Result contains the results of a pointer analysis.
+//
+// See Config for how to request the various Result components.
+//
+type Result struct {
+	CallGraph       *callgraph.Graph      // discovered call graph
+	Queries         map[ssa.Value]Pointer // pts(v) for each v in Config.Queries.
+	IndirectQueries map[ssa.Value]Pointer // pts(*v) for each v in Config.IndirectQueries.
+	Warnings        []Warning             // warnings of unsoundness
+}
+
+// A Pointer is an equivalence class of pointer-like values.
+//
+// A Pointer doesn't have a unique type because pointers of distinct
+// types may alias the same object.
+//
+type Pointer struct {
+	a *analysis
+	n nodeid
+}
+
+// A PointsToSet is a set of labels (locations or allocations).
+type PointsToSet struct {
+	a   *analysis // may be nil if pts is nil
+	pts *nodeset
+}
+
+func (s PointsToSet) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	if s.pts != nil {
+		var space [50]int
+		for i, l := range s.pts.AppendTo(space[:0]) {
+			if i > 0 {
+				buf.WriteString(", ")
+			}
+			buf.WriteString(s.a.labelFor(nodeid(l)).String())
+		}
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
+// PointsTo returns the set of labels that this points-to set
+// contains.
+func (s PointsToSet) Labels() []*Label {
+	var labels []*Label
+	if s.pts != nil {
+		var space [50]int
+		for _, l := range s.pts.AppendTo(space[:0]) {
+			labels = append(labels, s.a.labelFor(nodeid(l)))
+		}
+	}
+	return labels
+}
+
+// If this PointsToSet came from a Pointer of interface kind
+// or a reflect.Value, DynamicTypes returns the set of dynamic
+// types that it may contain.  (For an interface, they will
+// always be concrete types.)
+//
+// The result is a mapping whose keys are the dynamic types to which
+// it may point.  For each pointer-like key type, the corresponding
+// map value is the PointsToSet for pointers of that type.
+//
+// The result is empty unless CanHaveDynamicTypes(T).
+//
+func (s PointsToSet) DynamicTypes() *typeutil.Map {
+	var tmap typeutil.Map
+	tmap.SetHasher(s.a.hasher)
+	if s.pts != nil {
+		var space [50]int
+		for _, x := range s.pts.AppendTo(space[:0]) {
+			ifaceObjId := nodeid(x)
+			if !s.a.isTaggedObject(ifaceObjId) {
+				continue // !CanHaveDynamicTypes(tDyn)
+			}
+			tDyn, v, indirect := s.a.taggedValue(ifaceObjId)
+			if indirect {
+				panic("indirect tagged object") // implement later
+			}
+			pts, ok := tmap.At(tDyn).(PointsToSet)
+			if !ok {
+				pts = PointsToSet{s.a, new(nodeset)}
+				tmap.Set(tDyn, pts)
+			}
+			pts.pts.addAll(&s.a.nodes[v].solve.pts)
+		}
+	}
+	return &tmap
+}
+
+// Intersects reports whether this points-to set and the
+// argument points-to set contain common members.
+func (x PointsToSet) Intersects(y PointsToSet) bool {
+	if x.pts == nil || y.pts == nil {
+		return false
+	}
+	// This takes Θ(|x|+|y|) time.
+	var z intsets.Sparse
+	z.Intersection(&x.pts.Sparse, &y.pts.Sparse)
+	return !z.IsEmpty()
+}
+
+func (p Pointer) String() string {
+	return fmt.Sprintf("n%d", p.n)
+}
+
+// PointsTo returns the points-to set of this pointer.
+func (p Pointer) PointsTo() PointsToSet {
+	if p.n == 0 {
+		return PointsToSet{}
+	}
+	return PointsToSet{p.a, &p.a.nodes[p.n].solve.pts}
+}
+
+// MayAlias reports whether the receiver pointer may alias
+// the argument pointer.
+func (p Pointer) MayAlias(q Pointer) bool {
+	return p.PointsTo().Intersects(q.PointsTo())
+}
+
+// DynamicTypes returns p.PointsTo().DynamicTypes().
+func (p Pointer) DynamicTypes() *typeutil.Map {
+	return p.PointsTo().DynamicTypes()
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/callgraph.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/callgraph.go
new file mode 100644
index 00000000..48e152e4
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/callgraph.go
@@ -0,0 +1,61 @@
+// 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 pointer
+
+// This file defines the internal (context-sensitive) call graph.
+
+import (
+	"fmt"
+	"go/token"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+type cgnode struct {
+	fn         *ssa.Function
+	obj        nodeid      // start of this contour's object block
+	sites      []*callsite // ordered list of callsites within this function
+	callersite *callsite   // where called from, if known; nil for shared contours
+}
+
+// contour returns a description of this node's contour.
+func (n *cgnode) contour() string {
+	if n.callersite == nil {
+		return "shared contour"
+	}
+	if n.callersite.instr != nil {
+		return fmt.Sprintf("as called from %s", n.callersite.instr.Parent())
+	}
+	return fmt.Sprintf("as called from intrinsic (targets=n%d)", n.callersite.targets)
+}
+
+func (n *cgnode) String() string {
+	return fmt.Sprintf("cg%d:%s", n.obj, n.fn)
+}
+
+// A callsite represents a single call site within a cgnode;
+// it is implicitly context-sensitive.
+// callsites never represent calls to built-ins;
+// they are handled as intrinsics.
+//
+type callsite struct {
+	targets nodeid              // pts(·) contains objects for dynamically called functions
+	instr   ssa.CallInstruction // the call instruction; nil for synthetic/intrinsic
+}
+
+func (c *callsite) String() string {
+	if c.instr != nil {
+		return c.instr.Common().Description()
+	}
+	return "synthetic function call"
+}
+
+// pos returns the source position of this callsite, or token.NoPos if implicit.
+func (c *callsite) pos() token.Pos {
+	if c.instr != nil {
+		return c.instr.Pos()
+	}
+	return token.NoPos
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/constraint.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/constraint.go
new file mode 100644
index 00000000..54b54288
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/constraint.go
@@ -0,0 +1,149 @@
+// 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 pointer
+
+import "go/types"
+
+type constraint interface {
+	// For a complex constraint, returns the nodeid of the pointer
+	// to which it is attached.   For addr and copy, returns dst.
+	ptr() nodeid
+
+	// renumber replaces each nodeid n in the constraint by mapping[n].
+	renumber(mapping []nodeid)
+
+	// presolve is a hook for constraint-specific behaviour during
+	// pre-solver optimization.  Typical implementations mark as
+	// indirect the set of nodes to which the solver will add copy
+	// edges or PTS labels.
+	presolve(h *hvn)
+
+	// solve is called for complex constraints when the pts for
+	// the node to which they are attached has changed.
+	solve(a *analysis, delta *nodeset)
+
+	String() string
+}
+
+// dst = &src
+// pts(dst) ⊇ {src}
+// A base constraint used to initialize the solver's pt sets
+type addrConstraint struct {
+	dst nodeid // (ptr)
+	src nodeid
+}
+
+func (c *addrConstraint) ptr() nodeid { return c.dst }
+func (c *addrConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst = src
+// A simple constraint represented directly as a copyTo graph edge.
+type copyConstraint struct {
+	dst nodeid // (ptr)
+	src nodeid
+}
+
+func (c *copyConstraint) ptr() nodeid { return c.dst }
+func (c *copyConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst = src[offset]
+// A complex constraint attached to src (the pointer)
+type loadConstraint struct {
+	offset uint32
+	dst    nodeid
+	src    nodeid // (ptr)
+}
+
+func (c *loadConstraint) ptr() nodeid { return c.src }
+func (c *loadConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst[offset] = src
+// A complex constraint attached to dst (the pointer)
+type storeConstraint struct {
+	offset uint32
+	dst    nodeid // (ptr)
+	src    nodeid
+}
+
+func (c *storeConstraint) ptr() nodeid { return c.dst }
+func (c *storeConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst = &src.f  or  dst = &src[0]
+// A complex constraint attached to dst (the pointer)
+type offsetAddrConstraint struct {
+	offset uint32
+	dst    nodeid
+	src    nodeid // (ptr)
+}
+
+func (c *offsetAddrConstraint) ptr() nodeid { return c.src }
+func (c *offsetAddrConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst = src.(typ)  where typ is an interface
+// A complex constraint attached to src (the interface).
+// No representation change: pts(dst) and pts(src) contains tagged objects.
+type typeFilterConstraint struct {
+	typ types.Type // an interface type
+	dst nodeid
+	src nodeid // (ptr)
+}
+
+func (c *typeFilterConstraint) ptr() nodeid { return c.src }
+func (c *typeFilterConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// dst = src.(typ)  where typ is a concrete type
+// A complex constraint attached to src (the interface).
+//
+// If exact, only tagged objects identical to typ are untagged.
+// If !exact, tagged objects assignable to typ are untagged too.
+// The latter is needed for various reflect operators, e.g. Send.
+//
+// This entails a representation change:
+// pts(src) contains tagged objects,
+// pts(dst) contains their payloads.
+type untagConstraint struct {
+	typ   types.Type // a concrete type
+	dst   nodeid
+	src   nodeid // (ptr)
+	exact bool
+}
+
+func (c *untagConstraint) ptr() nodeid { return c.src }
+func (c *untagConstraint) renumber(mapping []nodeid) {
+	c.dst = mapping[c.dst]
+	c.src = mapping[c.src]
+}
+
+// src.method(params...)
+// A complex constraint attached to iface.
+type invokeConstraint struct {
+	method *types.Func // the abstract method
+	iface  nodeid      // (ptr) the interface
+	params nodeid      // the start of the identity/params/results block
+}
+
+func (c *invokeConstraint) ptr() nodeid { return c.iface }
+func (c *invokeConstraint) renumber(mapping []nodeid) {
+	c.iface = mapping[c.iface]
+	c.params = mapping[c.params]
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/doc.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/doc.go
new file mode 100644
index 00000000..e317cf5c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/doc.go
@@ -0,0 +1,610 @@
+// 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 pointer implements Andersen's analysis, an inclusion-based
+pointer analysis algorithm first described in (Andersen, 1994).
+
+A pointer analysis relates every pointer expression in a whole program
+to the set of memory locations to which it might point.  This
+information can be used to construct a call graph of the program that
+precisely represents the destinations of dynamic function and method
+calls.  It can also be used to determine, for example, which pairs of
+channel operations operate on the same channel.
+
+The package allows the client to request a set of expressions of
+interest for which the points-to information will be returned once the
+analysis is complete.  In addition, the client may request that a
+callgraph is constructed.  The example program in example_test.go
+demonstrates both of these features.  Clients should not request more
+information than they need since it may increase the cost of the
+analysis significantly.
+
+
+CLASSIFICATION
+
+Our algorithm is INCLUSION-BASED: the points-to sets for x and y will
+be related by pts(y) ⊇ pts(x) if the program contains the statement
+y = x.
+
+It is FLOW-INSENSITIVE: it ignores all control flow constructs and the
+order of statements in a program.  It is therefore a "MAY ALIAS"
+analysis: its facts are of the form "P may/may not point to L",
+not "P must point to L".
+
+It is FIELD-SENSITIVE: it builds separate points-to sets for distinct
+fields, such as x and y in struct { x, y *int }.
+
+It is mostly CONTEXT-INSENSITIVE: most functions are analyzed once,
+so values can flow in at one call to the function and return out at
+another.  Only some smaller functions are analyzed with consideration
+of their calling context.
+
+It has a CONTEXT-SENSITIVE HEAP: objects are named by both allocation
+site and context, so the objects returned by two distinct calls to f:
+   func f() *T { return new(T) }
+are distinguished up to the limits of the calling context.
+
+It is a WHOLE PROGRAM analysis: it requires SSA-form IR for the
+complete Go program and summaries for native code.
+
+See the (Hind, PASTE'01) survey paper for an explanation of these terms.
+
+
+SOUNDNESS
+
+The analysis is fully sound when invoked on pure Go programs that do not
+use reflection or unsafe.Pointer conversions.  In other words, if there
+is any possible execution of the program in which pointer P may point to
+object O, the analysis will report that fact.
+
+
+REFLECTION
+
+By default, the "reflect" library is ignored by the analysis, as if all
+its functions were no-ops, but if the client enables the Reflection flag,
+the analysis will make a reasonable attempt to model the effects of
+calls into this library.  However, this comes at a significant
+performance cost, and not all features of that library are yet
+implemented.  In addition, some simplifying approximations must be made
+to ensure that the analysis terminates; for example, reflection can be
+used to construct an infinite set of types and values of those types,
+but the analysis arbitrarily bounds the depth of such types.
+
+Most but not all reflection operations are supported.
+In particular, addressable reflect.Values are not yet implemented, so
+operations such as (reflect.Value).Set have no analytic effect.
+
+
+UNSAFE POINTER CONVERSIONS
+
+The pointer analysis makes no attempt to understand aliasing between the
+operand x and result y of an unsafe.Pointer conversion:
+   y = (*T)(unsafe.Pointer(x))
+It is as if the conversion allocated an entirely new object:
+   y = new(T)
+
+
+NATIVE CODE
+
+The analysis cannot model the aliasing effects of functions written in
+languages other than Go, such as runtime intrinsics in C or assembly, or
+code accessed via cgo.  The result is as if such functions are no-ops.
+However, various important intrinsics are understood by the analysis,
+along with built-ins such as append.
+
+The analysis currently provides no way for users to specify the aliasing
+effects of native code.
+
+------------------------------------------------------------------------
+
+IMPLEMENTATION
+
+The remaining documentation is intended for package maintainers and
+pointer analysis specialists.  Maintainers should have a solid
+understanding of the referenced papers (especially those by H&L and PKH)
+before making making significant changes.
+
+The implementation is similar to that described in (Pearce et al,
+PASTE'04).  Unlike many algorithms which interleave constraint
+generation and solving, constructing the callgraph as they go, this
+implementation for the most part observes a phase ordering (generation
+before solving), with only simple (copy) constraints being generated
+during solving.  (The exception is reflection, which creates various
+constraints during solving as new types flow to reflect.Value
+operations.)  This improves the traction of presolver optimisations,
+but imposes certain restrictions, e.g. potential context sensitivity
+is limited since all variants must be created a priori.
+
+
+TERMINOLOGY
+
+A type is said to be "pointer-like" if it is a reference to an object.
+Pointer-like types include pointers and also interfaces, maps, channels,
+functions and slices.
+
+We occasionally use C's x->f notation to distinguish the case where x
+is a struct pointer from x.f where is a struct value.
+
+Pointer analysis literature (and our comments) often uses the notation
+dst=*src+offset to mean something different than what it means in Go.
+It means: for each node index p in pts(src), the node index p+offset is
+in pts(dst).  Similarly *dst+offset=src is used for store constraints
+and dst=src+offset for offset-address constraints.
+
+
+NODES
+
+Nodes are the key datastructure of the analysis, and have a dual role:
+they represent both constraint variables (equivalence classes of
+pointers) and members of points-to sets (things that can be pointed
+at, i.e. "labels").
+
+Nodes are naturally numbered.  The numbering enables compact
+representations of sets of nodes such as bitvectors (or BDDs); and the
+ordering enables a very cheap way to group related nodes together.  For
+example, passing n parameters consists of generating n parallel
+constraints from caller+i to callee+i for 0<=i<n.
+
+The zero nodeid means "not a pointer".  For simplicity, we generate flow
+constraints even for non-pointer types such as int.  The pointer
+equivalence (PE) presolver optimization detects which variables cannot
+point to anything; this includes not only all variables of non-pointer
+types (such as int) but also variables of pointer-like types if they are
+always nil, or are parameters to a function that is never called.
+
+Each node represents a scalar part of a value or object.
+Aggregate types (structs, tuples, arrays) are recursively flattened
+out into a sequential list of scalar component types, and all the
+elements of an array are represented by a single node.  (The
+flattening of a basic type is a list containing a single node.)
+
+Nodes are connected into a graph with various kinds of labelled edges:
+simple edges (or copy constraints) represent value flow.  Complex
+edges (load, store, etc) trigger the creation of new simple edges
+during the solving phase.
+
+
+OBJECTS
+
+Conceptually, an "object" is a contiguous sequence of nodes denoting
+an addressable location: something that a pointer can point to.  The
+first node of an object has a non-nil obj field containing information
+about the allocation: its size, context, and ssa.Value.
+
+Objects include:
+   - functions and globals;
+   - variable allocations in the stack frame or heap;
+   - maps, channels and slices created by calls to make();
+   - allocations to construct an interface;
+   - allocations caused by conversions, e.g. []byte(str).
+   - arrays allocated by calls to append();
+
+Many objects have no Go types.  For example, the func, map and chan type
+kinds in Go are all varieties of pointers, but their respective objects
+are actual functions (executable code), maps (hash tables), and channels
+(synchronized queues).  Given the way we model interfaces, they too are
+pointers to "tagged" objects with no Go type.  And an *ssa.Global denotes
+the address of a global variable, but the object for a Global is the
+actual data.  So, the types of an ssa.Value that creates an object is
+"off by one indirection": a pointer to the object.
+
+The individual nodes of an object are sometimes referred to as "labels".
+
+For uniformity, all objects have a non-zero number of fields, even those
+of the empty type struct{}.  (All arrays are treated as if of length 1,
+so there are no empty arrays.  The empty tuple is never address-taken,
+so is never an object.)
+
+
+TAGGED OBJECTS
+
+An tagged object has the following layout:
+
+    T          -- obj.flags ⊇ {otTagged}
+    v
+    ...
+
+The T node's typ field is the dynamic type of the "payload": the value
+v which follows, flattened out.  The T node's obj has the otTagged
+flag.
+
+Tagged objects are needed when generalizing across types: interfaces,
+reflect.Values, reflect.Types.  Each of these three types is modelled
+as a pointer that exclusively points to tagged objects.
+
+Tagged objects may be indirect (obj.flags ⊇ {otIndirect}) meaning that
+the value v is not of type T but *T; this is used only for
+reflect.Values that represent lvalues.  (These are not implemented yet.)
+
+
+ANALYSIS ABSTRACTION OF EACH TYPE
+
+Variables of the following "scalar" types may be represented by a
+single node: basic types, pointers, channels, maps, slices, 'func'
+pointers, interfaces.
+
+Pointers
+  Nothing to say here, oddly.
+
+Basic types (bool, string, numbers, unsafe.Pointer)
+  Currently all fields in the flattening of a type, including
+  non-pointer basic types such as int, are represented in objects and
+  values.  Though non-pointer nodes within values are uninteresting,
+  non-pointer nodes in objects may be useful (if address-taken)
+  because they permit the analysis to deduce, in this example,
+
+     var s struct{ ...; x int; ... }
+     p := &s.x
+
+  that p points to s.x.  If we ignored such object fields, we could only
+  say that p points somewhere within s.
+
+  All other basic types are ignored.  Expressions of these types have
+  zero nodeid, and fields of these types within aggregate other types
+  are omitted.
+
+  unsafe.Pointers are not modelled as pointers, so a conversion of an
+  unsafe.Pointer to *T is (unsoundly) treated equivalent to new(T).
+
+Channels
+  An expression of type 'chan T' is a kind of pointer that points
+  exclusively to channel objects, i.e. objects created by MakeChan (or
+  reflection).
+
+  'chan T' is treated like *T.
+  *ssa.MakeChan is treated as equivalent to new(T).
+  *ssa.Send and receive (*ssa.UnOp(ARROW)) and are equivalent to store
+   and load.
+
+Maps
+  An expression of type 'map[K]V' is a kind of pointer that points
+  exclusively to map objects, i.e. objects created by MakeMap (or
+  reflection).
+
+  map K[V] is treated like *M where M = struct{k K; v V}.
+  *ssa.MakeMap is equivalent to new(M).
+  *ssa.MapUpdate is equivalent to *y=x where *y and x have type M.
+  *ssa.Lookup is equivalent to y=x.v where x has type *M.
+
+Slices
+  A slice []T, which dynamically resembles a struct{array *T, len, cap int},
+  is treated as if it were just a *T pointer; the len and cap fields are
+  ignored.
+
+  *ssa.MakeSlice is treated like new([1]T): an allocation of a
+   singleton array.
+  *ssa.Index on a slice is equivalent to a load.
+  *ssa.IndexAddr on a slice returns the address of the sole element of the
+  slice, i.e. the same address.
+  *ssa.Slice is treated as a simple copy.
+
+Functions
+  An expression of type 'func...' is a kind of pointer that points
+  exclusively to function objects.
+
+  A function object has the following layout:
+
+     identity         -- typ:*types.Signature; obj.flags ⊇ {otFunction}
+     params_0         -- (the receiver, if a method)
+     ...
+     params_n-1
+     results_0
+     ...
+     results_m-1
+
+  There may be multiple function objects for the same *ssa.Function
+  due to context-sensitive treatment of some functions.
+
+  The first node is the function's identity node.
+  Associated with every callsite is a special "targets" variable,
+  whose pts() contains the identity node of each function to which
+  the call may dispatch.  Identity words are not otherwise used during
+  the analysis, but we construct the call graph from the pts()
+  solution for such nodes.
+
+  The following block of contiguous nodes represents the flattened-out
+  types of the parameters ("P-block") and results ("R-block") of the
+  function object.
+
+  The treatment of free variables of closures (*ssa.FreeVar) is like
+  that of global variables; it is not context-sensitive.
+  *ssa.MakeClosure instructions create copy edges to Captures.
+
+  A Go value of type 'func' (i.e. a pointer to one or more functions)
+  is a pointer whose pts() contains function objects.  The valueNode()
+  for an *ssa.Function returns a singleton for that function.
+
+Interfaces
+  An expression of type 'interface{...}' is a kind of pointer that
+  points exclusively to tagged objects.  All tagged objects pointed to
+  by an interface are direct (the otIndirect flag is clear) and
+  concrete (the tag type T is not itself an interface type).  The
+  associated ssa.Value for an interface's tagged objects may be an
+  *ssa.MakeInterface instruction, or nil if the tagged object was
+  created by an instrinsic (e.g. reflection).
+
+  Constructing an interface value causes generation of constraints for
+  all of the concrete type's methods; we can't tell a priori which
+  ones may be called.
+
+  TypeAssert y = x.(T) is implemented by a dynamic constraint
+  triggered by each tagged object O added to pts(x): a typeFilter
+  constraint if T is an interface type, or an untag constraint if T is
+  a concrete type.  A typeFilter tests whether O.typ implements T; if
+  so, O is added to pts(y).  An untagFilter tests whether O.typ is
+  assignable to T,and if so, a copy edge O.v -> y is added.
+
+  ChangeInterface is a simple copy because the representation of
+  tagged objects is independent of the interface type (in contrast
+  to the "method tables" approach used by the gc runtime).
+
+  y := Invoke x.m(...) is implemented by allocating contiguous P/R
+  blocks for the callsite and adding a dynamic rule triggered by each
+  tagged object added to pts(x).  The rule adds param/results copy
+  edges to/from each discovered concrete method.
+
+  (Q. Why do we model an interface as a pointer to a pair of type and
+  value, rather than as a pair of a pointer to type and a pointer to
+  value?
+  A. Control-flow joins would merge interfaces ({T1}, {V1}) and ({T2},
+  {V2}) to make ({T1,T2}, {V1,V2}), leading to the infeasible and
+  type-unsafe combination (T1,V2).  Treating the value and its concrete
+  type as inseparable makes the analysis type-safe.)
+
+reflect.Value
+  A reflect.Value is modelled very similar to an interface{}, i.e. as
+  a pointer exclusively to tagged objects, but with two generalizations.
+
+  1) a reflect.Value that represents an lvalue points to an indirect
+     (obj.flags ⊇ {otIndirect}) tagged object, which has a similar
+     layout to an tagged object except that the value is a pointer to
+     the dynamic type.  Indirect tagged objects preserve the correct
+     aliasing so that mutations made by (reflect.Value).Set can be
+     observed.
+
+     Indirect objects only arise when an lvalue is derived from an
+     rvalue by indirection, e.g. the following code:
+
+        type S struct { X T }
+        var s S
+        var i interface{} = &s    // i points to a *S-tagged object (from MakeInterface)
+        v1 := reflect.ValueOf(i)  // v1 points to same *S-tagged object as i
+        v2 := v1.Elem()           // v2 points to an indirect S-tagged object, pointing to s
+        v3 := v2.FieldByName("X") // v3 points to an indirect int-tagged object, pointing to s.X
+        v3.Set(y)                 // pts(s.X) ⊇ pts(y)
+
+     Whether indirect or not, the concrete type of the tagged object
+     corresponds to the user-visible dynamic type, and the existence
+     of a pointer is an implementation detail.
+
+     (NB: indirect tagged objects are not yet implemented)
+
+  2) The dynamic type tag of a tagged object pointed to by a
+     reflect.Value may be an interface type; it need not be concrete.
+
+     This arises in code such as this:
+        tEface := reflect.TypeOf(new(interface{}).Elem() // interface{}
+        eface := reflect.Zero(tEface)
+     pts(eface) is a singleton containing an interface{}-tagged
+     object.  That tagged object's payload is an interface{} value,
+     i.e. the pts of the payload contains only concrete-tagged
+     objects, although in this example it's the zero interface{} value,
+     so its pts is empty.
+
+reflect.Type
+  Just as in the real "reflect" library, we represent a reflect.Type
+  as an interface whose sole implementation is the concrete type,
+  *reflect.rtype.  (This choice is forced on us by go/types: clients
+  cannot fabricate types with arbitrary method sets.)
+
+  rtype instances are canonical: there is at most one per dynamic
+  type.  (rtypes are in fact large structs but since identity is all
+  that matters, we represent them by a single node.)
+
+  The payload of each *rtype-tagged object is an *rtype pointer that
+  points to exactly one such canonical rtype object.  We exploit this
+  by setting the node.typ of the payload to the dynamic type, not
+  '*rtype'.  This saves us an indirection in each resolution rule.  As
+  an optimisation, *rtype-tagged objects are canonicalized too.
+
+
+Aggregate types:
+
+Aggregate types are treated as if all directly contained
+aggregates are recursively flattened out.
+
+Structs
+  *ssa.Field y = x.f creates a simple edge to y from x's node at f's offset.
+
+  *ssa.FieldAddr y = &x->f requires a dynamic closure rule to create
+   simple edges for each struct discovered in pts(x).
+
+  The nodes of a struct consist of a special 'identity' node (whose
+  type is that of the struct itself), followed by the nodes for all
+  the struct's fields, recursively flattened out.  A pointer to the
+  struct is a pointer to its identity node.  That node allows us to
+  distinguish a pointer to a struct from a pointer to its first field.
+
+  Field offsets are logical field offsets (plus one for the identity
+  node), so the sizes of the fields can be ignored by the analysis.
+
+  (The identity node is non-traditional but enables the distinction
+  described above, which is valuable for code comprehension tools.
+  Typical pointer analyses for C, whose purpose is compiler
+  optimization, must soundly model unsafe.Pointer (void*) conversions,
+  and this requires fidelity to the actual memory layout using physical
+  field offsets.)
+
+  *ssa.Field y = x.f creates a simple edge to y from x's node at f's offset.
+
+  *ssa.FieldAddr y = &x->f requires a dynamic closure rule to create
+   simple edges for each struct discovered in pts(x).
+
+Arrays
+  We model an array by an identity node (whose type is that of the
+  array itself) followed by a node representing all the elements of
+  the array; the analysis does not distinguish elements with different
+  indices.  Effectively, an array is treated like struct{elem T}, a
+  load y=x[i] like y=x.elem, and a store x[i]=y like x.elem=y; the
+  index i is ignored.
+
+  A pointer to an array is pointer to its identity node.  (A slice is
+  also a pointer to an array's identity node.)  The identity node
+  allows us to distinguish a pointer to an array from a pointer to one
+  of its elements, but it is rather costly because it introduces more
+  offset constraints into the system.  Furthermore, sound treatment of
+  unsafe.Pointer would require us to dispense with this node.
+
+  Arrays may be allocated by Alloc, by make([]T), by calls to append,
+  and via reflection.
+
+Tuples (T, ...)
+  Tuples are treated like structs with naturally numbered fields.
+  *ssa.Extract is analogous to *ssa.Field.
+
+  However, tuples have no identity field since by construction, they
+  cannot be address-taken.
+
+
+FUNCTION CALLS
+
+  There are three kinds of function call:
+  (1) static "call"-mode calls of functions.
+  (2) dynamic "call"-mode calls of functions.
+  (3) dynamic "invoke"-mode calls of interface methods.
+  Cases 1 and 2 apply equally to methods and standalone functions.
+
+  Static calls.
+    A static call consists three steps:
+    - finding the function object of the callee;
+    - creating copy edges from the actual parameter value nodes to the
+      P-block in the function object (this includes the receiver if
+      the callee is a method);
+    - creating copy edges from the R-block in the function object to
+      the value nodes for the result of the call.
+
+    A static function call is little more than two struct value copies
+    between the P/R blocks of caller and callee:
+
+       callee.P = caller.P
+       caller.R = callee.R
+
+    Context sensitivity
+
+      Static calls (alone) may be treated context sensitively,
+      i.e. each callsite may cause a distinct re-analysis of the
+      callee, improving precision.  Our current context-sensitivity
+      policy treats all intrinsics and getter/setter methods in this
+      manner since such functions are small and seem like an obvious
+      source of spurious confluences, though this has not yet been
+      evaluated.
+
+  Dynamic function calls
+
+    Dynamic calls work in a similar manner except that the creation of
+    copy edges occurs dynamically, in a similar fashion to a pair of
+    struct copies in which the callee is indirect:
+
+       callee->P = caller.P
+       caller.R = callee->R
+
+    (Recall that the function object's P- and R-blocks are contiguous.)
+
+  Interface method invocation
+
+    For invoke-mode calls, we create a params/results block for the
+    callsite and attach a dynamic closure rule to the interface.  For
+    each new tagged object that flows to the interface, we look up
+    the concrete method, find its function object, and connect its P/R
+    blocks to the callsite's P/R blocks, adding copy edges to the graph
+    during solving.
+
+  Recording call targets
+
+    The analysis notifies its clients of each callsite it encounters,
+    passing a CallSite interface.  Among other things, the CallSite
+    contains a synthetic constraint variable ("targets") whose
+    points-to solution includes the set of all function objects to
+    which the call may dispatch.
+
+    It is via this mechanism that the callgraph is made available.
+    Clients may also elect to be notified of callgraph edges directly;
+    internally this just iterates all "targets" variables' pts(·)s.
+
+
+PRESOLVER
+
+We implement Hash-Value Numbering (HVN), a pre-solver constraint
+optimization described in Hardekopf & Lin, SAS'07.  This is documented
+in more detail in hvn.go.  We intend to add its cousins HR and HU in
+future.
+
+
+SOLVER
+
+The solver is currently a naive Andersen-style implementation; it does
+not perform online cycle detection, though we plan to add solver
+optimisations such as Hybrid- and Lazy- Cycle Detection from (Hardekopf
+& Lin, PLDI'07).
+
+It uses difference propagation (Pearce et al, SQC'04) to avoid
+redundant re-triggering of closure rules for values already seen.
+
+Points-to sets are represented using sparse bit vectors (similar to
+those used in LLVM and gcc), which are more space- and time-efficient
+than sets based on Go's built-in map type or dense bit vectors.
+
+Nodes are permuted prior to solving so that object nodes (which may
+appear in points-to sets) are lower numbered than non-object (var)
+nodes.  This improves the density of the set over which the PTSs
+range, and thus the efficiency of the representation.
+
+Partly thanks to avoiding map iteration, the execution of the solver is
+100% deterministic, a great help during debugging.
+
+
+FURTHER READING
+
+Andersen, L. O. 1994. Program analysis and specialization for the C
+programming language. Ph.D. dissertation. DIKU, University of
+Copenhagen.
+
+David J. Pearce, Paul H. J. Kelly, and Chris Hankin. 2004.  Efficient
+field-sensitive pointer analysis for C. In Proceedings of the 5th ACM
+SIGPLAN-SIGSOFT workshop on Program analysis for software tools and
+engineering (PASTE '04). ACM, New York, NY, USA, 37-42.
+http://doi.acm.org/10.1145/996821.996835
+
+David J. Pearce, Paul H. J. Kelly, and Chris Hankin. 2004. Online
+Cycle Detection and Difference Propagation: Applications to Pointer
+Analysis. Software Quality Control 12, 4 (December 2004), 311-337.
+http://dx.doi.org/10.1023/B:SQJO.0000039791.93071.a2
+
+David Grove and Craig Chambers. 2001. A framework for call graph
+construction algorithms. ACM Trans. Program. Lang. Syst. 23, 6
+(November 2001), 685-746.
+http://doi.acm.org/10.1145/506315.506316
+
+Ben Hardekopf and Calvin Lin. 2007. The ant and the grasshopper: fast
+and accurate pointer analysis for millions of lines of code. In
+Proceedings of the 2007 ACM SIGPLAN conference on Programming language
+design and implementation (PLDI '07). ACM, New York, NY, USA, 290-299.
+http://doi.acm.org/10.1145/1250734.1250767
+
+Ben Hardekopf and Calvin Lin. 2007. Exploiting pointer and location
+equivalence to optimize pointer analysis. In Proceedings of the 14th
+international conference on Static Analysis (SAS'07), Hanne Riis
+Nielson and Gilberto Filé (Eds.). Springer-Verlag, Berlin, Heidelberg,
+265-280.
+
+Atanas Rountev and Satish Chandra. 2000. Off-line variable substitution
+for scaling points-to analysis. In Proceedings of the ACM SIGPLAN 2000
+conference on Programming language design and implementation (PLDI '00).
+ACM, New York, NY, USA, 47-56. DOI=10.1145/349299.349310
+http://doi.acm.org/10.1145/349299.349310
+
+*/
+package pointer // import "golang.org/x/tools/go/pointer"
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/gen.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/gen.go
new file mode 100644
index 00000000..a111175c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/gen.go
@@ -0,0 +1,1325 @@
+// 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 pointer
+
+// This file defines the constraint generation phase.
+
+// TODO(adonovan): move the constraint definitions and the store() etc
+// functions which add them (and are also used by the solver) into a
+// new file, constraints.go.
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/ssa"
+)
+
+var (
+	tEface     = types.NewInterface(nil, nil).Complete()
+	tInvalid   = types.Typ[types.Invalid]
+	tUnsafePtr = types.Typ[types.UnsafePointer]
+)
+
+// ---------- Node creation ----------
+
+// nextNode returns the index of the next unused node.
+func (a *analysis) nextNode() nodeid {
+	return nodeid(len(a.nodes))
+}
+
+// addNodes creates nodes for all scalar elements in type typ, and
+// returns the id of the first one, or zero if the type was
+// analytically uninteresting.
+//
+// comment explains the origin of the nodes, as a debugging aid.
+//
+func (a *analysis) addNodes(typ types.Type, comment string) nodeid {
+	id := a.nextNode()
+	for _, fi := range a.flatten(typ) {
+		a.addOneNode(fi.typ, comment, fi)
+	}
+	if id == a.nextNode() {
+		return 0 // type contained no pointers
+	}
+	return id
+}
+
+// addOneNode creates a single node with type typ, and returns its id.
+//
+// typ should generally be scalar (except for tagged.T nodes
+// and struct/array identity nodes).  Use addNodes for non-scalar types.
+//
+// comment explains the origin of the nodes, as a debugging aid.
+// subelement indicates the subelement, e.g. ".a.b[*].c".
+//
+func (a *analysis) addOneNode(typ types.Type, comment string, subelement *fieldInfo) nodeid {
+	id := a.nextNode()
+	a.nodes = append(a.nodes, &node{typ: typ, subelement: subelement, solve: new(solverState)})
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\tcreate n%d %s for %s%s\n",
+			id, typ, comment, subelement.path())
+	}
+	return id
+}
+
+// setValueNode associates node id with the value v.
+// cgn identifies the context iff v is a local variable.
+//
+func (a *analysis) setValueNode(v ssa.Value, id nodeid, cgn *cgnode) {
+	if cgn != nil {
+		a.localval[v] = id
+	} else {
+		a.globalval[v] = id
+	}
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\tval[%s] = n%d  (%T)\n", v.Name(), id, v)
+	}
+
+	// Due to context-sensitivity, we may encounter the same Value
+	// in many contexts. We merge them to a canonical node, since
+	// that's what all clients want.
+
+	// Record the (v, id) relation if the client has queried pts(v).
+	if _, ok := a.config.Queries[v]; ok {
+		t := v.Type()
+		ptr, ok := a.result.Queries[v]
+		if !ok {
+			// First time?  Create the canonical query node.
+			ptr = Pointer{a, a.addNodes(t, "query")}
+			a.result.Queries[v] = ptr
+		}
+		a.result.Queries[v] = ptr
+		a.copy(ptr.n, id, a.sizeof(t))
+	}
+
+	// Record the (*v, id) relation if the client has queried pts(*v).
+	if _, ok := a.config.IndirectQueries[v]; ok {
+		t := v.Type()
+		ptr, ok := a.result.IndirectQueries[v]
+		if !ok {
+			// First time? Create the canonical indirect query node.
+			ptr = Pointer{a, a.addNodes(v.Type(), "query.indirect")}
+			a.result.IndirectQueries[v] = ptr
+		}
+		a.genLoad(cgn, ptr.n, v, 0, a.sizeof(t))
+	}
+
+	for _, query := range a.config.extendedQueries[v] {
+		t, nid := a.evalExtendedQuery(v.Type().Underlying(), id, query.ops)
+
+		if query.ptr.a == nil {
+			query.ptr.a = a
+			query.ptr.n = a.addNodes(t, "query.extended")
+		}
+		a.copy(query.ptr.n, nid, a.sizeof(t))
+	}
+}
+
+// endObject marks the end of a sequence of calls to addNodes denoting
+// a single object allocation.
+//
+// obj is the start node of the object, from a prior call to nextNode.
+// Its size, flags and optional data will be updated.
+//
+func (a *analysis) endObject(obj nodeid, cgn *cgnode, data interface{}) *object {
+	// Ensure object is non-empty by padding;
+	// the pad will be the object node.
+	size := uint32(a.nextNode() - obj)
+	if size == 0 {
+		a.addOneNode(tInvalid, "padding", nil)
+	}
+	objNode := a.nodes[obj]
+	o := &object{
+		size: size, // excludes padding
+		cgn:  cgn,
+		data: data,
+	}
+	objNode.obj = o
+
+	return o
+}
+
+// makeFunctionObject creates and returns a new function object
+// (contour) for fn, and returns the id of its first node.  It also
+// enqueues fn for subsequent constraint generation.
+//
+// For a context-sensitive contour, callersite identifies the sole
+// callsite; for shared contours, caller is nil.
+//
+func (a *analysis) makeFunctionObject(fn *ssa.Function, callersite *callsite) nodeid {
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\t---- makeFunctionObject %s\n", fn)
+	}
+
+	// obj is the function object (identity, params, results).
+	obj := a.nextNode()
+	cgn := a.makeCGNode(fn, obj, callersite)
+	sig := fn.Signature
+	a.addOneNode(sig, "func.cgnode", nil) // (scalar with Signature type)
+	if recv := sig.Recv(); recv != nil {
+		a.addNodes(recv.Type(), "func.recv")
+	}
+	a.addNodes(sig.Params(), "func.params")
+	a.addNodes(sig.Results(), "func.results")
+	a.endObject(obj, cgn, fn).flags |= otFunction
+
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\t----\n")
+	}
+
+	// Queue it up for constraint processing.
+	a.genq = append(a.genq, cgn)
+
+	return obj
+}
+
+// makeTagged creates a tagged object of type typ.
+func (a *analysis) makeTagged(typ types.Type, cgn *cgnode, data interface{}) nodeid {
+	obj := a.addOneNode(typ, "tagged.T", nil) // NB: type may be non-scalar!
+	a.addNodes(typ, "tagged.v")
+	a.endObject(obj, cgn, data).flags |= otTagged
+	return obj
+}
+
+// makeRtype returns the canonical tagged object of type *rtype whose
+// payload points to the sole rtype object for T.
+//
+// TODO(adonovan): move to reflect.go; it's part of the solver really.
+//
+func (a *analysis) makeRtype(T types.Type) nodeid {
+	if v := a.rtypes.At(T); v != nil {
+		return v.(nodeid)
+	}
+
+	// Create the object for the reflect.rtype itself, which is
+	// ordinarily a large struct but here a single node will do.
+	obj := a.nextNode()
+	a.addOneNode(T, "reflect.rtype", nil)
+	a.endObject(obj, nil, T)
+
+	id := a.makeTagged(a.reflectRtypePtr, nil, T)
+	a.nodes[id+1].typ = T // trick (each *rtype tagged object is a singleton)
+	a.addressOf(a.reflectRtypePtr, id+1, obj)
+
+	a.rtypes.Set(T, id)
+	return id
+}
+
+// rtypeValue returns the type of the *reflect.rtype-tagged object obj.
+func (a *analysis) rtypeTaggedValue(obj nodeid) types.Type {
+	tDyn, t, _ := a.taggedValue(obj)
+	if tDyn != a.reflectRtypePtr {
+		panic(fmt.Sprintf("not a *reflect.rtype-tagged object: obj=n%d tag=%v payload=n%d", obj, tDyn, t))
+	}
+	return a.nodes[t].typ
+}
+
+// valueNode returns the id of the value node for v, creating it (and
+// the association) as needed.  It may return zero for uninteresting
+// values containing no pointers.
+//
+func (a *analysis) valueNode(v ssa.Value) nodeid {
+	// Value nodes for locals are created en masse by genFunc.
+	if id, ok := a.localval[v]; ok {
+		return id
+	}
+
+	// Value nodes for globals are created on demand.
+	id, ok := a.globalval[v]
+	if !ok {
+		var comment string
+		if a.log != nil {
+			comment = v.String()
+		}
+		id = a.addNodes(v.Type(), comment)
+		if obj := a.objectNode(nil, v); obj != 0 {
+			a.addressOf(v.Type(), id, obj)
+		}
+		a.setValueNode(v, id, nil)
+	}
+	return id
+}
+
+// valueOffsetNode ascertains the node for tuple/struct value v,
+// then returns the node for its subfield #index.
+//
+func (a *analysis) valueOffsetNode(v ssa.Value, index int) nodeid {
+	id := a.valueNode(v)
+	if id == 0 {
+		panic(fmt.Sprintf("cannot offset within n0: %s = %s", v.Name(), v))
+	}
+	return id + nodeid(a.offsetOf(v.Type(), index))
+}
+
+// isTaggedObject reports whether object obj is a tagged object.
+func (a *analysis) isTaggedObject(obj nodeid) bool {
+	return a.nodes[obj].obj.flags&otTagged != 0
+}
+
+// taggedValue returns the dynamic type tag, the (first node of the)
+// payload, and the indirect flag of the tagged object starting at id.
+// Panic ensues if !isTaggedObject(id).
+//
+func (a *analysis) taggedValue(obj nodeid) (tDyn types.Type, v nodeid, indirect bool) {
+	n := a.nodes[obj]
+	flags := n.obj.flags
+	if flags&otTagged == 0 {
+		panic(fmt.Sprintf("not a tagged object: n%d", obj))
+	}
+	return n.typ, obj + 1, flags&otIndirect != 0
+}
+
+// funcParams returns the first node of the params (P) block of the
+// function whose object node (obj.flags&otFunction) is id.
+//
+func (a *analysis) funcParams(id nodeid) nodeid {
+	n := a.nodes[id]
+	if n.obj == nil || n.obj.flags&otFunction == 0 {
+		panic(fmt.Sprintf("funcParams(n%d): not a function object block", id))
+	}
+	return id + 1
+}
+
+// funcResults returns the first node of the results (R) block of the
+// function whose object node (obj.flags&otFunction) is id.
+//
+func (a *analysis) funcResults(id nodeid) nodeid {
+	n := a.nodes[id]
+	if n.obj == nil || n.obj.flags&otFunction == 0 {
+		panic(fmt.Sprintf("funcResults(n%d): not a function object block", id))
+	}
+	sig := n.typ.(*types.Signature)
+	id += 1 + nodeid(a.sizeof(sig.Params()))
+	if sig.Recv() != nil {
+		id += nodeid(a.sizeof(sig.Recv().Type()))
+	}
+	return id
+}
+
+// ---------- Constraint creation ----------
+
+// copy creates a constraint of the form dst = src.
+// sizeof is the width (in logical fields) of the copied type.
+//
+func (a *analysis) copy(dst, src nodeid, sizeof uint32) {
+	if src == dst || sizeof == 0 {
+		return // trivial
+	}
+	if src == 0 || dst == 0 {
+		panic(fmt.Sprintf("ill-typed copy dst=n%d src=n%d", dst, src))
+	}
+	for i := uint32(0); i < sizeof; i++ {
+		a.addConstraint(&copyConstraint{dst, src})
+		src++
+		dst++
+	}
+}
+
+// addressOf creates a constraint of the form id = &obj.
+// T is the type of the address.
+func (a *analysis) addressOf(T types.Type, id, obj nodeid) {
+	if id == 0 {
+		panic("addressOf: zero id")
+	}
+	if obj == 0 {
+		panic("addressOf: zero obj")
+	}
+	if a.shouldTrack(T) {
+		a.addConstraint(&addrConstraint{id, obj})
+	}
+}
+
+// load creates a load constraint of the form dst = src[offset].
+// offset is the pointer offset in logical fields.
+// sizeof is the width (in logical fields) of the loaded type.
+//
+func (a *analysis) load(dst, src nodeid, offset, sizeof uint32) {
+	if dst == 0 {
+		return // load of non-pointerlike value
+	}
+	if src == 0 && dst == 0 {
+		return // non-pointerlike operation
+	}
+	if src == 0 || dst == 0 {
+		panic(fmt.Sprintf("ill-typed load dst=n%d src=n%d", dst, src))
+	}
+	for i := uint32(0); i < sizeof; i++ {
+		a.addConstraint(&loadConstraint{offset, dst, src})
+		offset++
+		dst++
+	}
+}
+
+// store creates a store constraint of the form dst[offset] = src.
+// offset is the pointer offset in logical fields.
+// sizeof is the width (in logical fields) of the stored type.
+//
+func (a *analysis) store(dst, src nodeid, offset uint32, sizeof uint32) {
+	if src == 0 {
+		return // store of non-pointerlike value
+	}
+	if src == 0 && dst == 0 {
+		return // non-pointerlike operation
+	}
+	if src == 0 || dst == 0 {
+		panic(fmt.Sprintf("ill-typed store dst=n%d src=n%d", dst, src))
+	}
+	for i := uint32(0); i < sizeof; i++ {
+		a.addConstraint(&storeConstraint{offset, dst, src})
+		offset++
+		src++
+	}
+}
+
+// offsetAddr creates an offsetAddr constraint of the form dst = &src.#offset.
+// offset is the field offset in logical fields.
+// T is the type of the address.
+//
+func (a *analysis) offsetAddr(T types.Type, dst, src nodeid, offset uint32) {
+	if !a.shouldTrack(T) {
+		return
+	}
+	if offset == 0 {
+		// Simplify  dst = &src->f0
+		//       to  dst = src
+		// (NB: this optimisation is defeated by the identity
+		// field prepended to struct and array objects.)
+		a.copy(dst, src, 1)
+	} else {
+		a.addConstraint(&offsetAddrConstraint{offset, dst, src})
+	}
+}
+
+// typeAssert creates a typeFilter or untag constraint of the form dst = src.(T):
+// typeFilter for an interface, untag for a concrete type.
+// The exact flag is specified as for untagConstraint.
+//
+func (a *analysis) typeAssert(T types.Type, dst, src nodeid, exact bool) {
+	if isInterface(T) {
+		a.addConstraint(&typeFilterConstraint{T, dst, src})
+	} else {
+		a.addConstraint(&untagConstraint{T, dst, src, exact})
+	}
+}
+
+// addConstraint adds c to the constraint set.
+func (a *analysis) addConstraint(c constraint) {
+	a.constraints = append(a.constraints, c)
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\t%s\n", c)
+	}
+}
+
+// copyElems generates load/store constraints for *dst = *src,
+// where src and dst are slices or *arrays.
+//
+func (a *analysis) copyElems(cgn *cgnode, typ types.Type, dst, src ssa.Value) {
+	tmp := a.addNodes(typ, "copy")
+	sz := a.sizeof(typ)
+	a.genLoad(cgn, tmp, src, 1, sz)
+	a.genStore(cgn, dst, tmp, 1, sz)
+}
+
+// ---------- Constraint generation ----------
+
+// genConv generates constraints for the conversion operation conv.
+func (a *analysis) genConv(conv *ssa.Convert, cgn *cgnode) {
+	res := a.valueNode(conv)
+	if res == 0 {
+		return // result is non-pointerlike
+	}
+
+	tSrc := conv.X.Type()
+	tDst := conv.Type()
+
+	switch utSrc := tSrc.Underlying().(type) {
+	case *types.Slice:
+		// []byte/[]rune -> string?
+		return
+
+	case *types.Pointer:
+		// *T -> unsafe.Pointer?
+		if tDst.Underlying() == tUnsafePtr {
+			return // we don't model unsafe aliasing (unsound)
+		}
+
+	case *types.Basic:
+		switch tDst.Underlying().(type) {
+		case *types.Pointer:
+			// Treat unsafe.Pointer->*T conversions like
+			// new(T) and create an unaliased object.
+			if utSrc == tUnsafePtr {
+				obj := a.addNodes(mustDeref(tDst), "unsafe.Pointer conversion")
+				a.endObject(obj, cgn, conv)
+				a.addressOf(tDst, res, obj)
+				return
+			}
+
+		case *types.Slice:
+			// string -> []byte/[]rune (or named aliases)?
+			if utSrc.Info()&types.IsString != 0 {
+				obj := a.addNodes(sliceToArray(tDst), "convert")
+				a.endObject(obj, cgn, conv)
+				a.addressOf(tDst, res, obj)
+				return
+			}
+
+		case *types.Basic:
+			// All basic-to-basic type conversions are no-ops.
+			// This includes uintptr<->unsafe.Pointer conversions,
+			// which we (unsoundly) ignore.
+			return
+		}
+	}
+
+	panic(fmt.Sprintf("illegal *ssa.Convert %s -> %s: %s", tSrc, tDst, conv.Parent()))
+}
+
+// genAppend generates constraints for a call to append.
+func (a *analysis) genAppend(instr *ssa.Call, cgn *cgnode) {
+	// Consider z = append(x, y).   y is optional.
+	// This may allocate a new [1]T array; call its object w.
+	// We get the following constraints:
+	// 	z = x
+	// 	z = &w
+	//     *z = *y
+
+	x := instr.Call.Args[0]
+
+	z := instr
+	a.copy(a.valueNode(z), a.valueNode(x), 1) // z = x
+
+	if len(instr.Call.Args) == 1 {
+		return // no allocation for z = append(x) or _ = append(x).
+	}
+
+	// TODO(adonovan): test append([]byte, ...string) []byte.
+
+	y := instr.Call.Args[1]
+	tArray := sliceToArray(instr.Call.Args[0].Type())
+
+	var w nodeid
+	w = a.nextNode()
+	a.addNodes(tArray, "append")
+	a.endObject(w, cgn, instr)
+
+	a.copyElems(cgn, tArray.Elem(), z, y)        // *z = *y
+	a.addressOf(instr.Type(), a.valueNode(z), w) //  z = &w
+}
+
+// genBuiltinCall generates contraints for a call to a built-in.
+func (a *analysis) genBuiltinCall(instr ssa.CallInstruction, cgn *cgnode) {
+	call := instr.Common()
+	switch call.Value.(*ssa.Builtin).Name() {
+	case "append":
+		// Safe cast: append cannot appear in a go or defer statement.
+		a.genAppend(instr.(*ssa.Call), cgn)
+
+	case "copy":
+		tElem := call.Args[0].Type().Underlying().(*types.Slice).Elem()
+		a.copyElems(cgn, tElem, call.Args[0], call.Args[1])
+
+	case "panic":
+		a.copy(a.panicNode, a.valueNode(call.Args[0]), 1)
+
+	case "recover":
+		if v := instr.Value(); v != nil {
+			a.copy(a.valueNode(v), a.panicNode, 1)
+		}
+
+	case "print":
+		// In the tests, the probe might be the sole reference
+		// to its arg, so make sure we create nodes for it.
+		if len(call.Args) > 0 {
+			a.valueNode(call.Args[0])
+		}
+
+	case "ssa:wrapnilchk":
+		a.copy(a.valueNode(instr.Value()), a.valueNode(call.Args[0]), 1)
+
+	default:
+		// No-ops: close len cap real imag complex print println delete.
+	}
+}
+
+// shouldUseContext defines the context-sensitivity policy.  It
+// returns true if we should analyse all static calls to fn anew.
+//
+// Obviously this interface rather limits how much freedom we have to
+// choose a policy.  The current policy, rather arbitrarily, is true
+// for intrinsics and accessor methods (actually: short, single-block,
+// call-free functions).  This is just a starting point.
+//
+func (a *analysis) shouldUseContext(fn *ssa.Function) bool {
+	if a.findIntrinsic(fn) != nil {
+		return true // treat intrinsics context-sensitively
+	}
+	if len(fn.Blocks) != 1 {
+		return false // too expensive
+	}
+	blk := fn.Blocks[0]
+	if len(blk.Instrs) > 10 {
+		return false // too expensive
+	}
+	if fn.Synthetic != "" && (fn.Pkg == nil || fn != fn.Pkg.Func("init")) {
+		return true // treat synthetic wrappers context-sensitively
+	}
+	for _, instr := range blk.Instrs {
+		switch instr := instr.(type) {
+		case ssa.CallInstruction:
+			// Disallow function calls (except to built-ins)
+			// because of the danger of unbounded recursion.
+			if _, ok := instr.Common().Value.(*ssa.Builtin); !ok {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// genStaticCall generates constraints for a statically dispatched function call.
+func (a *analysis) genStaticCall(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) {
+	fn := call.StaticCallee()
+
+	// Special cases for inlined intrinsics.
+	switch fn {
+	case a.runtimeSetFinalizer:
+		// Inline SetFinalizer so the call appears direct.
+		site.targets = a.addOneNode(tInvalid, "SetFinalizer.targets", nil)
+		a.addConstraint(&runtimeSetFinalizerConstraint{
+			targets: site.targets,
+			x:       a.valueNode(call.Args[0]),
+			f:       a.valueNode(call.Args[1]),
+		})
+		return
+
+	case a.reflectValueCall:
+		// Inline (reflect.Value).Call so the call appears direct.
+		dotdotdot := false
+		ret := reflectCallImpl(a, caller, site, a.valueNode(call.Args[0]), a.valueNode(call.Args[1]), dotdotdot)
+		if result != 0 {
+			a.addressOf(fn.Signature.Results().At(0).Type(), result, ret)
+		}
+		return
+	}
+
+	// Ascertain the context (contour/cgnode) for a particular call.
+	var obj nodeid
+	if a.shouldUseContext(fn) {
+		obj = a.makeFunctionObject(fn, site) // new contour
+	} else {
+		obj = a.objectNode(nil, fn) // shared contour
+	}
+	a.callEdge(caller, site, obj)
+
+	sig := call.Signature()
+
+	// Copy receiver, if any.
+	params := a.funcParams(obj)
+	args := call.Args
+	if sig.Recv() != nil {
+		sz := a.sizeof(sig.Recv().Type())
+		a.copy(params, a.valueNode(args[0]), sz)
+		params += nodeid(sz)
+		args = args[1:]
+	}
+
+	// Copy actual parameters into formal params block.
+	// Must loop, since the actuals aren't contiguous.
+	for i, arg := range args {
+		sz := a.sizeof(sig.Params().At(i).Type())
+		a.copy(params, a.valueNode(arg), sz)
+		params += nodeid(sz)
+	}
+
+	// Copy formal results block to actual result.
+	if result != 0 {
+		a.copy(result, a.funcResults(obj), a.sizeof(sig.Results()))
+	}
+}
+
+// genDynamicCall generates constraints for a dynamic function call.
+func (a *analysis) genDynamicCall(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) {
+	// pts(targets) will be the set of possible call targets.
+	site.targets = a.valueNode(call.Value)
+
+	// We add dynamic closure rules that store the arguments into
+	// the P-block and load the results from the R-block of each
+	// function discovered in pts(targets).
+
+	sig := call.Signature()
+	var offset uint32 = 1 // P/R block starts at offset 1
+	for i, arg := range call.Args {
+		sz := a.sizeof(sig.Params().At(i).Type())
+		a.genStore(caller, call.Value, a.valueNode(arg), offset, sz)
+		offset += sz
+	}
+	if result != 0 {
+		a.genLoad(caller, result, call.Value, offset, a.sizeof(sig.Results()))
+	}
+}
+
+// genInvoke generates constraints for a dynamic method invocation.
+func (a *analysis) genInvoke(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) {
+	if call.Value.Type() == a.reflectType {
+		a.genInvokeReflectType(caller, site, call, result)
+		return
+	}
+
+	sig := call.Signature()
+
+	// Allocate a contiguous targets/params/results block for this call.
+	block := a.nextNode()
+	// pts(targets) will be the set of possible call targets
+	site.targets = a.addOneNode(sig, "invoke.targets", nil)
+	p := a.addNodes(sig.Params(), "invoke.params")
+	r := a.addNodes(sig.Results(), "invoke.results")
+
+	// Copy the actual parameters into the call's params block.
+	for i, n := 0, sig.Params().Len(); i < n; i++ {
+		sz := a.sizeof(sig.Params().At(i).Type())
+		a.copy(p, a.valueNode(call.Args[i]), sz)
+		p += nodeid(sz)
+	}
+	// Copy the call's results block to the actual results.
+	if result != 0 {
+		a.copy(result, r, a.sizeof(sig.Results()))
+	}
+
+	// We add a dynamic invoke constraint that will connect the
+	// caller's and the callee's P/R blocks for each discovered
+	// call target.
+	a.addConstraint(&invokeConstraint{call.Method, a.valueNode(call.Value), block})
+}
+
+// genInvokeReflectType is a specialization of genInvoke where the
+// receiver type is a reflect.Type, under the assumption that there
+// can be at most one implementation of this interface, *reflect.rtype.
+//
+// (Though this may appear to be an instance of a pattern---method
+// calls on interfaces known to have exactly one implementation---in
+// practice it occurs rarely, so we special case for reflect.Type.)
+//
+// In effect we treat this:
+//    var rt reflect.Type = ...
+//    rt.F()
+// as this:
+//    rt.(*reflect.rtype).F()
+//
+func (a *analysis) genInvokeReflectType(caller *cgnode, site *callsite, call *ssa.CallCommon, result nodeid) {
+	// Unpack receiver into rtype
+	rtype := a.addOneNode(a.reflectRtypePtr, "rtype.recv", nil)
+	recv := a.valueNode(call.Value)
+	a.typeAssert(a.reflectRtypePtr, rtype, recv, true)
+
+	// Look up the concrete method.
+	fn := a.prog.LookupMethod(a.reflectRtypePtr, call.Method.Pkg(), call.Method.Name())
+
+	obj := a.makeFunctionObject(fn, site) // new contour for this call
+	a.callEdge(caller, site, obj)
+
+	// From now on, it's essentially a static call, but little is
+	// gained by factoring together the code for both cases.
+
+	sig := fn.Signature // concrete method
+	targets := a.addOneNode(sig, "call.targets", nil)
+	a.addressOf(sig, targets, obj) // (a singleton)
+
+	// Copy receiver.
+	params := a.funcParams(obj)
+	a.copy(params, rtype, 1)
+	params++
+
+	// Copy actual parameters into formal P-block.
+	// Must loop, since the actuals aren't contiguous.
+	for i, arg := range call.Args {
+		sz := a.sizeof(sig.Params().At(i).Type())
+		a.copy(params, a.valueNode(arg), sz)
+		params += nodeid(sz)
+	}
+
+	// Copy formal R-block to actual R-block.
+	if result != 0 {
+		a.copy(result, a.funcResults(obj), a.sizeof(sig.Results()))
+	}
+}
+
+// genCall generates constraints for call instruction instr.
+func (a *analysis) genCall(caller *cgnode, instr ssa.CallInstruction) {
+	call := instr.Common()
+
+	// Intrinsic implementations of built-in functions.
+	if _, ok := call.Value.(*ssa.Builtin); ok {
+		a.genBuiltinCall(instr, caller)
+		return
+	}
+
+	var result nodeid
+	if v := instr.Value(); v != nil {
+		result = a.valueNode(v)
+	}
+
+	site := &callsite{instr: instr}
+	if call.StaticCallee() != nil {
+		a.genStaticCall(caller, site, call, result)
+	} else if call.IsInvoke() {
+		a.genInvoke(caller, site, call, result)
+	} else {
+		a.genDynamicCall(caller, site, call, result)
+	}
+
+	caller.sites = append(caller.sites, site)
+
+	if a.log != nil {
+		// TODO(adonovan): debug: improve log message.
+		fmt.Fprintf(a.log, "\t%s to targets %s from %s\n", site, site.targets, caller)
+	}
+}
+
+// objectNode returns the object to which v points, if known.
+// In other words, if the points-to set of v is a singleton, it
+// returns the sole label, zero otherwise.
+//
+// We exploit this information to make the generated constraints less
+// dynamic.  For example, a complex load constraint can be replaced by
+// a simple copy constraint when the sole destination is known a priori.
+//
+// Some SSA instructions always have singletons points-to sets:
+// 	Alloc, Function, Global, MakeChan, MakeClosure,  MakeInterface,  MakeMap,  MakeSlice.
+// Others may be singletons depending on their operands:
+// 	FreeVar, Const, Convert, FieldAddr, IndexAddr, Slice.
+//
+// Idempotent.  Objects are created as needed, possibly via recursion
+// down the SSA value graph, e.g IndexAddr(FieldAddr(Alloc))).
+//
+func (a *analysis) objectNode(cgn *cgnode, v ssa.Value) nodeid {
+	switch v.(type) {
+	case *ssa.Global, *ssa.Function, *ssa.Const, *ssa.FreeVar:
+		// Global object.
+		obj, ok := a.globalobj[v]
+		if !ok {
+			switch v := v.(type) {
+			case *ssa.Global:
+				obj = a.nextNode()
+				a.addNodes(mustDeref(v.Type()), "global")
+				a.endObject(obj, nil, v)
+
+			case *ssa.Function:
+				obj = a.makeFunctionObject(v, nil)
+
+			case *ssa.Const:
+				// not addressable
+
+			case *ssa.FreeVar:
+				// not addressable
+			}
+
+			if a.log != nil {
+				fmt.Fprintf(a.log, "\tglobalobj[%s] = n%d\n", v, obj)
+			}
+			a.globalobj[v] = obj
+		}
+		return obj
+	}
+
+	// Local object.
+	obj, ok := a.localobj[v]
+	if !ok {
+		switch v := v.(type) {
+		case *ssa.Alloc:
+			obj = a.nextNode()
+			a.addNodes(mustDeref(v.Type()), "alloc")
+			a.endObject(obj, cgn, v)
+
+		case *ssa.MakeSlice:
+			obj = a.nextNode()
+			a.addNodes(sliceToArray(v.Type()), "makeslice")
+			a.endObject(obj, cgn, v)
+
+		case *ssa.MakeChan:
+			obj = a.nextNode()
+			a.addNodes(v.Type().Underlying().(*types.Chan).Elem(), "makechan")
+			a.endObject(obj, cgn, v)
+
+		case *ssa.MakeMap:
+			obj = a.nextNode()
+			tmap := v.Type().Underlying().(*types.Map)
+			a.addNodes(tmap.Key(), "makemap.key")
+			elem := a.addNodes(tmap.Elem(), "makemap.value")
+
+			// To update the value field, MapUpdate
+			// generates store-with-offset constraints which
+			// the presolver can't model, so we must mark
+			// those nodes indirect.
+			for id, end := elem, elem+nodeid(a.sizeof(tmap.Elem())); id < end; id++ {
+				a.mapValues = append(a.mapValues, id)
+			}
+			a.endObject(obj, cgn, v)
+
+		case *ssa.MakeInterface:
+			tConc := v.X.Type()
+			obj = a.makeTagged(tConc, cgn, v)
+
+			// Copy the value into it, if nontrivial.
+			if x := a.valueNode(v.X); x != 0 {
+				a.copy(obj+1, x, a.sizeof(tConc))
+			}
+
+		case *ssa.FieldAddr:
+			if xobj := a.objectNode(cgn, v.X); xobj != 0 {
+				obj = xobj + nodeid(a.offsetOf(mustDeref(v.X.Type()), v.Field))
+			}
+
+		case *ssa.IndexAddr:
+			if xobj := a.objectNode(cgn, v.X); xobj != 0 {
+				obj = xobj + 1
+			}
+
+		case *ssa.Slice:
+			obj = a.objectNode(cgn, v.X)
+
+		case *ssa.Convert:
+			// TODO(adonovan): opt: handle these cases too:
+			// - unsafe.Pointer->*T conversion acts like Alloc
+			// - string->[]byte/[]rune conversion acts like MakeSlice
+		}
+
+		if a.log != nil {
+			fmt.Fprintf(a.log, "\tlocalobj[%s] = n%d\n", v.Name(), obj)
+		}
+		a.localobj[v] = obj
+	}
+	return obj
+}
+
+// genLoad generates constraints for result = *(ptr + val).
+func (a *analysis) genLoad(cgn *cgnode, result nodeid, ptr ssa.Value, offset, sizeof uint32) {
+	if obj := a.objectNode(cgn, ptr); obj != 0 {
+		// Pre-apply loadConstraint.solve().
+		a.copy(result, obj+nodeid(offset), sizeof)
+	} else {
+		a.load(result, a.valueNode(ptr), offset, sizeof)
+	}
+}
+
+// genOffsetAddr generates constraints for a 'v=ptr.field' (FieldAddr)
+// or 'v=ptr[*]' (IndexAddr) instruction v.
+func (a *analysis) genOffsetAddr(cgn *cgnode, v ssa.Value, ptr nodeid, offset uint32) {
+	dst := a.valueNode(v)
+	if obj := a.objectNode(cgn, v); obj != 0 {
+		// Pre-apply offsetAddrConstraint.solve().
+		a.addressOf(v.Type(), dst, obj)
+	} else {
+		a.offsetAddr(v.Type(), dst, ptr, offset)
+	}
+}
+
+// genStore generates constraints for *(ptr + offset) = val.
+func (a *analysis) genStore(cgn *cgnode, ptr ssa.Value, val nodeid, offset, sizeof uint32) {
+	if obj := a.objectNode(cgn, ptr); obj != 0 {
+		// Pre-apply storeConstraint.solve().
+		a.copy(obj+nodeid(offset), val, sizeof)
+	} else {
+		a.store(a.valueNode(ptr), val, offset, sizeof)
+	}
+}
+
+// genInstr generates constraints for instruction instr in context cgn.
+func (a *analysis) genInstr(cgn *cgnode, instr ssa.Instruction) {
+	if a.log != nil {
+		var prefix string
+		if val, ok := instr.(ssa.Value); ok {
+			prefix = val.Name() + " = "
+		}
+		fmt.Fprintf(a.log, "; %s%s\n", prefix, instr)
+	}
+
+	switch instr := instr.(type) {
+	case *ssa.DebugRef:
+		// no-op.
+
+	case *ssa.UnOp:
+		switch instr.Op {
+		case token.ARROW: // <-x
+			// We can ignore instr.CommaOk because the node we're
+			// altering is always at zero offset relative to instr
+			tElem := instr.X.Type().Underlying().(*types.Chan).Elem()
+			a.genLoad(cgn, a.valueNode(instr), instr.X, 0, a.sizeof(tElem))
+
+		case token.MUL: // *x
+			a.genLoad(cgn, a.valueNode(instr), instr.X, 0, a.sizeof(instr.Type()))
+
+		default:
+			// NOT, SUB, XOR: no-op.
+		}
+
+	case *ssa.BinOp:
+		// All no-ops.
+
+	case ssa.CallInstruction: // *ssa.Call, *ssa.Go, *ssa.Defer
+		a.genCall(cgn, instr)
+
+	case *ssa.ChangeType:
+		a.copy(a.valueNode(instr), a.valueNode(instr.X), 1)
+
+	case *ssa.Convert:
+		a.genConv(instr, cgn)
+
+	case *ssa.Extract:
+		a.copy(a.valueNode(instr),
+			a.valueOffsetNode(instr.Tuple, instr.Index),
+			a.sizeof(instr.Type()))
+
+	case *ssa.FieldAddr:
+		a.genOffsetAddr(cgn, instr, a.valueNode(instr.X),
+			a.offsetOf(mustDeref(instr.X.Type()), instr.Field))
+
+	case *ssa.IndexAddr:
+		a.genOffsetAddr(cgn, instr, a.valueNode(instr.X), 1)
+
+	case *ssa.Field:
+		a.copy(a.valueNode(instr),
+			a.valueOffsetNode(instr.X, instr.Field),
+			a.sizeof(instr.Type()))
+
+	case *ssa.Index:
+		a.copy(a.valueNode(instr), 1+a.valueNode(instr.X), a.sizeof(instr.Type()))
+
+	case *ssa.Select:
+		recv := a.valueOffsetNode(instr, 2) // instr : (index, recvOk, recv0, ... recv_n-1)
+		for _, st := range instr.States {
+			elemSize := a.sizeof(st.Chan.Type().Underlying().(*types.Chan).Elem())
+			switch st.Dir {
+			case types.RecvOnly:
+				a.genLoad(cgn, recv, st.Chan, 0, elemSize)
+				recv += nodeid(elemSize)
+
+			case types.SendOnly:
+				a.genStore(cgn, st.Chan, a.valueNode(st.Send), 0, elemSize)
+			}
+		}
+
+	case *ssa.Return:
+		results := a.funcResults(cgn.obj)
+		for _, r := range instr.Results {
+			sz := a.sizeof(r.Type())
+			a.copy(results, a.valueNode(r), sz)
+			results += nodeid(sz)
+		}
+
+	case *ssa.Send:
+		a.genStore(cgn, instr.Chan, a.valueNode(instr.X), 0, a.sizeof(instr.X.Type()))
+
+	case *ssa.Store:
+		a.genStore(cgn, instr.Addr, a.valueNode(instr.Val), 0, a.sizeof(instr.Val.Type()))
+
+	case *ssa.Alloc, *ssa.MakeSlice, *ssa.MakeChan, *ssa.MakeMap, *ssa.MakeInterface:
+		v := instr.(ssa.Value)
+		a.addressOf(v.Type(), a.valueNode(v), a.objectNode(cgn, v))
+
+	case *ssa.ChangeInterface:
+		a.copy(a.valueNode(instr), a.valueNode(instr.X), 1)
+
+	case *ssa.TypeAssert:
+		a.typeAssert(instr.AssertedType, a.valueNode(instr), a.valueNode(instr.X), true)
+
+	case *ssa.Slice:
+		a.copy(a.valueNode(instr), a.valueNode(instr.X), 1)
+
+	case *ssa.If, *ssa.Jump:
+		// no-op.
+
+	case *ssa.Phi:
+		sz := a.sizeof(instr.Type())
+		for _, e := range instr.Edges {
+			a.copy(a.valueNode(instr), a.valueNode(e), sz)
+		}
+
+	case *ssa.MakeClosure:
+		fn := instr.Fn.(*ssa.Function)
+		a.copy(a.valueNode(instr), a.valueNode(fn), 1)
+		// Free variables are treated like global variables.
+		for i, b := range instr.Bindings {
+			a.copy(a.valueNode(fn.FreeVars[i]), a.valueNode(b), a.sizeof(b.Type()))
+		}
+
+	case *ssa.RunDefers:
+		// The analysis is flow insensitive, so we just "call"
+		// defers as we encounter them.
+
+	case *ssa.Range:
+		// Do nothing.  Next{Iter: *ssa.Range} handles this case.
+
+	case *ssa.Next:
+		if !instr.IsString { // map
+			// Assumes that Next is always directly applied to a Range result.
+			theMap := instr.Iter.(*ssa.Range).X
+			tMap := theMap.Type().Underlying().(*types.Map)
+
+			ksize := a.sizeof(tMap.Key())
+			vsize := a.sizeof(tMap.Elem())
+
+			// The k/v components of the Next tuple may each be invalid.
+			tTuple := instr.Type().(*types.Tuple)
+
+			// Load from the map's (k,v) into the tuple's (ok, k, v).
+			osrc := uint32(0) // offset within map object
+			odst := uint32(1) // offset within tuple (initially just after 'ok bool')
+			sz := uint32(0)   // amount to copy
+
+			// Is key valid?
+			if tTuple.At(1).Type() != tInvalid {
+				sz += ksize
+			} else {
+				odst += ksize
+				osrc += ksize
+			}
+
+			// Is value valid?
+			if tTuple.At(2).Type() != tInvalid {
+				sz += vsize
+			}
+
+			a.genLoad(cgn, a.valueNode(instr)+nodeid(odst), theMap, osrc, sz)
+		}
+
+	case *ssa.Lookup:
+		if tMap, ok := instr.X.Type().Underlying().(*types.Map); ok {
+			// CommaOk can be ignored: field 0 is a no-op.
+			ksize := a.sizeof(tMap.Key())
+			vsize := a.sizeof(tMap.Elem())
+			a.genLoad(cgn, a.valueNode(instr), instr.X, ksize, vsize)
+		}
+
+	case *ssa.MapUpdate:
+		tmap := instr.Map.Type().Underlying().(*types.Map)
+		ksize := a.sizeof(tmap.Key())
+		vsize := a.sizeof(tmap.Elem())
+		a.genStore(cgn, instr.Map, a.valueNode(instr.Key), 0, ksize)
+		a.genStore(cgn, instr.Map, a.valueNode(instr.Value), ksize, vsize)
+
+	case *ssa.Panic:
+		a.copy(a.panicNode, a.valueNode(instr.X), 1)
+
+	default:
+		panic(fmt.Sprintf("unimplemented: %T", instr))
+	}
+}
+
+func (a *analysis) makeCGNode(fn *ssa.Function, obj nodeid, callersite *callsite) *cgnode {
+	cgn := &cgnode{fn: fn, obj: obj, callersite: callersite}
+	a.cgnodes = append(a.cgnodes, cgn)
+	return cgn
+}
+
+// genRootCalls generates the synthetic root of the callgraph and the
+// initial calls from it to the analysis scope, such as main, a test
+// or a library.
+//
+func (a *analysis) genRootCalls() *cgnode {
+	r := a.prog.NewFunction("<root>", new(types.Signature), "root of callgraph")
+	root := a.makeCGNode(r, 0, nil)
+
+	// TODO(adonovan): make an ssa utility to construct an actual
+	// root function so we don't need to special-case site-less
+	// call edges.
+
+	// For each main package, call main.init(), main.main().
+	for _, mainPkg := range a.config.Mains {
+		main := mainPkg.Func("main")
+		if main == nil {
+			panic(fmt.Sprintf("%s has no main function", mainPkg))
+		}
+
+		targets := a.addOneNode(main.Signature, "root.targets", nil)
+		site := &callsite{targets: targets}
+		root.sites = append(root.sites, site)
+		for _, fn := range [2]*ssa.Function{mainPkg.Func("init"), main} {
+			if a.log != nil {
+				fmt.Fprintf(a.log, "\troot call to %s:\n", fn)
+			}
+			a.copy(targets, a.valueNode(fn), 1)
+		}
+	}
+
+	return root
+}
+
+// genFunc generates constraints for function fn.
+func (a *analysis) genFunc(cgn *cgnode) {
+	fn := cgn.fn
+
+	impl := a.findIntrinsic(fn)
+
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\n\n==== Generating constraints for %s, %s\n", cgn, cgn.contour())
+
+		// Hack: don't display body if intrinsic.
+		if impl != nil {
+			fn2 := *cgn.fn // copy
+			fn2.Locals = nil
+			fn2.Blocks = nil
+			fn2.WriteTo(a.log)
+		} else {
+			cgn.fn.WriteTo(a.log)
+		}
+	}
+
+	if impl != nil {
+		impl(a, cgn)
+		return
+	}
+
+	if fn.Blocks == nil {
+		// External function with no intrinsic treatment.
+		// We'll warn about calls to such functions at the end.
+		return
+	}
+
+	if a.log != nil {
+		fmt.Fprintln(a.log, "; Creating nodes for local values")
+	}
+
+	a.localval = make(map[ssa.Value]nodeid)
+	a.localobj = make(map[ssa.Value]nodeid)
+
+	// The value nodes for the params are in the func object block.
+	params := a.funcParams(cgn.obj)
+	for _, p := range fn.Params {
+		a.setValueNode(p, params, cgn)
+		params += nodeid(a.sizeof(p.Type()))
+	}
+
+	// Free variables have global cardinality:
+	// the outer function sets them with MakeClosure;
+	// the inner function accesses them with FreeVar.
+	//
+	// TODO(adonovan): treat free vars context-sensitively.
+
+	// Create value nodes for all value instructions
+	// since SSA may contain forward references.
+	var space [10]*ssa.Value
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			switch instr := instr.(type) {
+			case *ssa.Range:
+				// do nothing: it has a funky type,
+				// and *ssa.Next does all the work.
+
+			case ssa.Value:
+				var comment string
+				if a.log != nil {
+					comment = instr.Name()
+				}
+				id := a.addNodes(instr.Type(), comment)
+				a.setValueNode(instr, id, cgn)
+			}
+
+			// Record all address-taken functions (for presolver).
+			rands := instr.Operands(space[:0])
+			if call, ok := instr.(ssa.CallInstruction); ok && !call.Common().IsInvoke() {
+				// Skip CallCommon.Value in "call" mode.
+				// TODO(adonovan): fix: relies on unspecified ordering.  Specify it.
+				rands = rands[1:]
+			}
+			for _, rand := range rands {
+				if atf, ok := (*rand).(*ssa.Function); ok {
+					a.atFuncs[atf] = true
+				}
+			}
+		}
+	}
+
+	// Generate constraints for instructions.
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			a.genInstr(cgn, instr)
+		}
+	}
+
+	a.localval = nil
+	a.localobj = nil
+}
+
+// genMethodsOf generates nodes and constraints for all methods of type T.
+func (a *analysis) genMethodsOf(T types.Type) {
+	itf := isInterface(T)
+
+	// TODO(adonovan): can we skip this entirely if itf is true?
+	// I think so, but the answer may depend on reflection.
+	mset := a.prog.MethodSets.MethodSet(T)
+	for i, n := 0, mset.Len(); i < n; i++ {
+		m := a.prog.MethodValue(mset.At(i))
+		a.valueNode(m)
+
+		if !itf {
+			// Methods of concrete types are address-taken functions.
+			a.atFuncs[m] = true
+		}
+	}
+}
+
+// generate generates offline constraints for the entire program.
+func (a *analysis) generate() {
+	start("Constraint generation")
+	if a.log != nil {
+		fmt.Fprintln(a.log, "==== Generating constraints")
+	}
+
+	// Create a dummy node since we use the nodeid 0 for
+	// non-pointerlike variables.
+	a.addNodes(tInvalid, "(zero)")
+
+	// Create the global node for panic values.
+	a.panicNode = a.addNodes(tEface, "panic")
+
+	// Create nodes and constraints for all methods of reflect.rtype.
+	// (Shared contours are used by dynamic calls to reflect.Type
+	// methods---typically just String().)
+	if rtype := a.reflectRtypePtr; rtype != nil {
+		a.genMethodsOf(rtype)
+	}
+
+	root := a.genRootCalls()
+
+	if a.config.BuildCallGraph {
+		a.result.CallGraph = callgraph.New(root.fn)
+	}
+
+	// Create nodes and constraints for all methods of all types
+	// that are dynamically accessible via reflection or interfaces.
+	for _, T := range a.prog.RuntimeTypes() {
+		a.genMethodsOf(T)
+	}
+
+	// Generate constraints for functions as they become reachable
+	// from the roots.  (No constraints are generated for functions
+	// that are dead in this analysis scope.)
+	for len(a.genq) > 0 {
+		cgn := a.genq[0]
+		a.genq = a.genq[1:]
+		a.genFunc(cgn)
+	}
+
+	// The runtime magically allocates os.Args; so should we.
+	if os := a.prog.ImportedPackage("os"); os != nil {
+		// In effect:  os.Args = new([1]string)[:]
+		T := types.NewSlice(types.Typ[types.String])
+		obj := a.addNodes(sliceToArray(T), "<command-line args>")
+		a.endObject(obj, nil, "<command-line args>")
+		a.addressOf(T, a.objectNode(nil, os.Var("Args")), obj)
+	}
+
+	// Discard generation state, to avoid confusion after node renumbering.
+	a.panicNode = 0
+	a.globalval = nil
+	a.localval = nil
+	a.localobj = nil
+
+	stop("Constraint generation")
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/hvn.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/hvn.go
new file mode 100644
index 00000000..48051ae7
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/hvn.go
@@ -0,0 +1,973 @@
+// 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 pointer
+
+// This file implements Hash-Value Numbering (HVN), a pre-solver
+// constraint optimization described in Hardekopf & Lin, SAS'07 (see
+// doc.go) that analyses the graph topology to determine which sets of
+// variables are "pointer equivalent" (PE), i.e. must have identical
+// points-to sets in the solution.
+//
+// A separate ("offline") graph is constructed.  Its nodes are those of
+// the main-graph, plus an additional node *X for each pointer node X.
+// With this graph we can reason about the unknown points-to set of
+// dereferenced pointers.  (We do not generalize this to represent
+// unknown fields x->f, perhaps because such fields would be numerous,
+// though it might be worth an experiment.)
+//
+// Nodes whose points-to relations are not entirely captured by the
+// graph are marked as "indirect": the *X nodes, the parameters of
+// address-taken functions (which includes all functions in method
+// sets), or nodes updated by the solver rules for reflection, etc.
+//
+// All addr (y=&x) nodes are initially assigned a pointer-equivalence
+// (PE) label equal to x's nodeid in the main graph.  (These are the
+// only PE labels that are less than len(a.nodes).)
+//
+// All offsetAddr (y=&x.f) constraints are initially assigned a PE
+// label; such labels are memoized, keyed by (x, f), so that equivalent
+// nodes y as assigned the same label.
+//
+// Then we process each strongly connected component (SCC) of the graph
+// in topological order, assigning it a PE label based on the set P of
+// PE labels that flow to it from its immediate dependencies.
+//
+// If any node in P is "indirect", the entire SCC is assigned a fresh PE
+// label.  Otherwise:
+//
+// |P|=0  if P is empty, all nodes in the SCC are non-pointers (e.g.
+//        uninitialized variables, or formal params of dead functions)
+//        and the SCC is assigned the PE label of zero.
+//
+// |P|=1  if P is a singleton, the SCC is assigned the same label as the
+//        sole element of P.
+//
+// |P|>1  if P contains multiple labels, a unique label representing P is
+//        invented and recorded in an hash table, so that other
+//        equivalent SCCs may also be assigned this label, akin to
+//        conventional hash-value numbering in a compiler.
+//
+// Finally, a renumbering is computed such that each node is replaced by
+// the lowest-numbered node with the same PE label.  All constraints are
+// renumbered, and any resulting duplicates are eliminated.
+//
+// The only nodes that are not renumbered are the objects x in addr
+// (y=&x) constraints, since the ids of these nodes (and fields derived
+// from them via offsetAddr rules) are the elements of all points-to
+// sets, so they must remain as they are if we want the same solution.
+//
+// The solverStates (node.solve) for nodes in the same equivalence class
+// are linked together so that all nodes in the class have the same
+// solution.  This avoids the need to renumber nodeids buried in
+// Queries, cgnodes, etc (like (*analysis).renumber() does) since only
+// the solution is needed.
+//
+// The result of HVN is that the number of distinct nodes and
+// constraints is reduced, but the solution is identical (almost---see
+// CROSS-CHECK below).  In particular, both linear and cyclic chains of
+// copies are each replaced by a single node.
+//
+// Nodes and constraints created "online" (e.g. while solving reflection
+// constraints) are not subject to this optimization.
+//
+// PERFORMANCE
+//
+// In two benchmarks (guru and godoc), HVN eliminates about two thirds
+// of nodes, the majority accounted for by non-pointers: nodes of
+// non-pointer type, pointers that remain nil, formal parameters of dead
+// functions, nodes of untracked types, etc.  It also reduces the number
+// of constraints, also by about two thirds, and the solving time by
+// 30--42%, although we must pay about 15% for the running time of HVN
+// itself.  The benefit is greater for larger applications.
+//
+// There are many possible optimizations to improve the performance:
+// * Use fewer than 1:1 onodes to main graph nodes: many of the onodes
+//   we create are not needed.
+// * HU (HVN with Union---see paper): coalesce "union" peLabels when
+//   their expanded-out sets are equal.
+// * HR (HVN with deReference---see paper): this will require that we
+//   apply HVN until fixed point, which may need more bookkeeping of the
+//   correspondance of main nodes to onodes.
+// * Location Equivalence (see paper): have points-to sets contain not
+//   locations but location-equivalence class labels, each representing
+//   a set of locations.
+// * HVN with field-sensitive ref: model each of the fields of a
+//   pointer-to-struct.
+//
+// CROSS-CHECK
+//
+// To verify the soundness of the optimization, when the
+// debugHVNCrossCheck option is enabled, we run the solver twice, once
+// before and once after running HVN, dumping the solution to disk, and
+// then we compare the results.  If they are not identical, the analysis
+// panics.
+//
+// The solution dumped to disk includes only the N*N submatrix of the
+// complete solution where N is the number of nodes after generation.
+// In other words, we ignore pointer variables and objects created by
+// the solver itself, since their numbering depends on the solver order,
+// which is affected by the optimization.  In any case, that's the only
+// part the client cares about.
+//
+// The cross-check is too strict and may fail spuriously.  Although the
+// H&L paper describing HVN states that the solutions obtained should be
+// identical, this is not the case in practice because HVN can collapse
+// cycles involving *p even when pts(p)={}.  Consider this example
+// distilled from testdata/hello.go:
+//
+//	var x T
+//	func f(p **T) {
+//		t0 = *p
+//		...
+//		t1 = φ(t0, &x)
+//		*p = t1
+//	}
+//
+// If f is dead code, we get:
+// 	unoptimized:  pts(p)={} pts(t0)={} pts(t1)={&x}
+// 	optimized:    pts(p)={} pts(t0)=pts(t1)=pts(*p)={&x}
+//
+// It's hard to argue that this is a bug: the result is sound and the
+// loss of precision is inconsequential---f is dead code, after all.
+// But unfortunately it limits the usefulness of the cross-check since
+// failures must be carefully analyzed.  Ben Hardekopf suggests (in
+// personal correspondence) some approaches to mitigating it:
+//
+// 	If there is a node with an HVN points-to set that is a superset
+// 	of the NORM points-to set, then either it's a bug or it's a
+// 	result of this issue. If it's a result of this issue, then in
+// 	the offline constraint graph there should be a REF node inside
+// 	some cycle that reaches this node, and in the NORM solution the
+// 	pointer being dereferenced by that REF node should be the empty
+// 	set. If that isn't true then this is a bug. If it is true, then
+// 	you can further check that in the NORM solution the "extra"
+// 	points-to info in the HVN solution does in fact come from that
+// 	purported cycle (if it doesn't, then this is still a bug). If
+// 	you're doing the further check then you'll need to do it for
+// 	each "extra" points-to element in the HVN points-to set.
+//
+// 	There are probably ways to optimize these checks by taking
+// 	advantage of graph properties. For example, extraneous points-to
+// 	info will flow through the graph and end up in many
+// 	nodes. Rather than checking every node with extra info, you
+// 	could probably work out the "origin point" of the extra info and
+// 	just check there. Note that the check in the first bullet is
+// 	looking for soundness bugs, while the check in the second bullet
+// 	is looking for precision bugs; depending on your needs, you may
+// 	care more about one than the other.
+//
+// which we should evaluate.  The cross-check is nonetheless invaluable
+// for all but one of the programs in the pointer_test suite.
+
+import (
+	"fmt"
+	"go/types"
+	"io"
+	"reflect"
+
+	"golang.org/x/tools/container/intsets"
+)
+
+// A peLabel is a pointer-equivalence label: two nodes with the same
+// peLabel have identical points-to solutions.
+//
+// The numbers are allocated consecutively like so:
+// 	0	not a pointer
+//	1..N-1	addrConstraints (equals the constraint's .src field, hence sparse)
+//	...	offsetAddr constraints
+//	...	SCCs (with indirect nodes or multiple inputs)
+//
+// Each PE label denotes a set of pointers containing a single addr, a
+// single offsetAddr, or some set of other PE labels.
+//
+type peLabel int
+
+type hvn struct {
+	a        *analysis
+	N        int                // len(a.nodes) immediately after constraint generation
+	log      io.Writer          // (optional) log of HVN lemmas
+	onodes   []*onode           // nodes of the offline graph
+	label    peLabel            // the next available PE label
+	hvnLabel map[string]peLabel // hash-value numbering (PE label) for each set of onodeids
+	stack    []onodeid          // DFS stack
+	index    int32              // next onode.index, from Tarjan's SCC algorithm
+
+	// For each distinct offsetAddrConstraint (src, offset) pair,
+	// offsetAddrLabels records a unique PE label >= N.
+	offsetAddrLabels map[offsetAddr]peLabel
+}
+
+// The index of an node in the offline graph.
+// (Currently the first N align with the main nodes,
+// but this may change with HRU.)
+type onodeid uint32
+
+// An onode is a node in the offline constraint graph.
+// (Where ambiguous, members of analysis.nodes are referred to as
+// "main graph" nodes.)
+//
+// Edges in the offline constraint graph (edges and implicit) point to
+// the source, i.e. against the flow of values: they are dependencies.
+// Implicit edges are used for SCC computation, but not for gathering
+// incoming labels.
+//
+type onode struct {
+	rep onodeid // index of representative of SCC in offline constraint graph
+
+	edges    intsets.Sparse // constraint edges X-->Y (this onode is X)
+	implicit intsets.Sparse // implicit edges *X-->*Y (this onode is X)
+	peLabels intsets.Sparse // set of peLabels are pointer-equivalent to this one
+	indirect bool           // node has points-to relations not represented in graph
+
+	// Tarjan's SCC algorithm
+	index, lowlink int32 // Tarjan numbering
+	scc            int32 // -ve => on stack; 0 => unvisited; +ve => node is root of a found SCC
+}
+
+type offsetAddr struct {
+	ptr    nodeid
+	offset uint32
+}
+
+// nextLabel issues the next unused pointer-equivalence label.
+func (h *hvn) nextLabel() peLabel {
+	h.label++
+	return h.label
+}
+
+// ref(X) returns the index of the onode for *X.
+func (h *hvn) ref(id onodeid) onodeid {
+	return id + onodeid(len(h.a.nodes))
+}
+
+// hvn computes pointer-equivalence labels (peLabels) using the Hash-based
+// Value Numbering (HVN) algorithm described in Hardekopf & Lin, SAS'07.
+//
+func (a *analysis) hvn() {
+	start("HVN")
+
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\n\n==== Pointer equivalence optimization\n\n")
+	}
+
+	h := hvn{
+		a:                a,
+		N:                len(a.nodes),
+		log:              a.log,
+		hvnLabel:         make(map[string]peLabel),
+		offsetAddrLabels: make(map[offsetAddr]peLabel),
+	}
+
+	if h.log != nil {
+		fmt.Fprintf(h.log, "\nCreating offline graph nodes...\n")
+	}
+
+	// Create offline nodes.  The first N nodes correspond to main
+	// graph nodes; the next N are their corresponding ref() nodes.
+	h.onodes = make([]*onode, 2*h.N)
+	for id := range a.nodes {
+		id := onodeid(id)
+		h.onodes[id] = &onode{}
+		h.onodes[h.ref(id)] = &onode{indirect: true}
+	}
+
+	// Each node initially represents just itself.
+	for id, o := range h.onodes {
+		o.rep = onodeid(id)
+	}
+
+	h.markIndirectNodes()
+
+	// Reserve the first N PE labels for addrConstraints.
+	h.label = peLabel(h.N)
+
+	// Add offline constraint edges.
+	if h.log != nil {
+		fmt.Fprintf(h.log, "\nAdding offline graph edges...\n")
+	}
+	for _, c := range a.constraints {
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "; %s\n", c)
+		}
+		c.presolve(&h)
+	}
+
+	// Find and collapse SCCs.
+	if h.log != nil {
+		fmt.Fprintf(h.log, "\nFinding SCCs...\n")
+	}
+	h.index = 1
+	for id, o := range h.onodes {
+		if id > 0 && o.index == 0 {
+			// Start depth-first search at each unvisited node.
+			h.visit(onodeid(id))
+		}
+	}
+
+	// Dump the solution
+	// (NB: somewhat redundant with logging from simplify().)
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\nPointer equivalences:\n")
+		for id, o := range h.onodes {
+			if id == 0 {
+				continue
+			}
+			if id == int(h.N) {
+				fmt.Fprintf(h.log, "---\n")
+			}
+			fmt.Fprintf(h.log, "o%d\t", id)
+			if o.rep != onodeid(id) {
+				fmt.Fprintf(h.log, "rep=o%d", o.rep)
+			} else {
+				fmt.Fprintf(h.log, "p%d", o.peLabels.Min())
+				if o.indirect {
+					fmt.Fprint(h.log, " indirect")
+				}
+			}
+			fmt.Fprintln(h.log)
+		}
+	}
+
+	// Simplify the main constraint graph
+	h.simplify()
+
+	a.showCounts()
+
+	stop("HVN")
+}
+
+// ---- constraint-specific rules ----
+
+// dst := &src
+func (c *addrConstraint) presolve(h *hvn) {
+	// Each object (src) is an initial PE label.
+	label := peLabel(c.src) // label < N
+	if debugHVNVerbose && h.log != nil {
+		// duplicate log messages are possible
+		fmt.Fprintf(h.log, "\tcreate p%d: {&n%d}\n", label, c.src)
+	}
+	odst := onodeid(c.dst)
+	osrc := onodeid(c.src)
+
+	// Assign dst this label.
+	h.onodes[odst].peLabels.Insert(int(label))
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d has p%d\n", odst, label)
+	}
+
+	h.addImplicitEdge(h.ref(odst), osrc) // *dst ~~> src.
+}
+
+// dst = src
+func (c *copyConstraint) presolve(h *hvn) {
+	odst := onodeid(c.dst)
+	osrc := onodeid(c.src)
+	h.addEdge(odst, osrc)                       //  dst -->  src
+	h.addImplicitEdge(h.ref(odst), h.ref(osrc)) // *dst ~~> *src
+}
+
+// dst = *src + offset
+func (c *loadConstraint) presolve(h *hvn) {
+	odst := onodeid(c.dst)
+	osrc := onodeid(c.src)
+	if c.offset == 0 {
+		h.addEdge(odst, h.ref(osrc)) // dst --> *src
+	} else {
+		// We don't interpret load-with-offset, e.g. results
+		// of map value lookup, R-block of dynamic call, slice
+		// copy/append, reflection.
+		h.markIndirect(odst, "load with offset")
+	}
+}
+
+// *dst + offset = src
+func (c *storeConstraint) presolve(h *hvn) {
+	odst := onodeid(c.dst)
+	osrc := onodeid(c.src)
+	if c.offset == 0 {
+		h.onodes[h.ref(odst)].edges.Insert(int(osrc)) // *dst --> src
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "\to%d --> o%d\n", h.ref(odst), osrc)
+		}
+	} else {
+		// We don't interpret store-with-offset.
+		// See discussion of soundness at markIndirectNodes.
+	}
+}
+
+// dst = &src.offset
+func (c *offsetAddrConstraint) presolve(h *hvn) {
+	// Give each distinct (addr, offset) pair a fresh PE label.
+	// The cache performs CSE, effectively.
+	key := offsetAddr{c.src, c.offset}
+	label, ok := h.offsetAddrLabels[key]
+	if !ok {
+		label = h.nextLabel()
+		h.offsetAddrLabels[key] = label
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "\tcreate p%d: {&n%d.#%d}\n",
+				label, c.src, c.offset)
+		}
+	}
+
+	// Assign dst this label.
+	h.onodes[c.dst].peLabels.Insert(int(label))
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d has p%d\n", c.dst, label)
+	}
+}
+
+// dst = src.(typ)  where typ is an interface
+func (c *typeFilterConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.dst), "typeFilter result")
+}
+
+// dst = src.(typ)  where typ is concrete
+func (c *untagConstraint) presolve(h *hvn) {
+	odst := onodeid(c.dst)
+	for end := odst + onodeid(h.a.sizeof(c.typ)); odst < end; odst++ {
+		h.markIndirect(odst, "untag result")
+	}
+}
+
+// dst = src.method(c.params...)
+func (c *invokeConstraint) presolve(h *hvn) {
+	// All methods are address-taken functions, so
+	// their formal P-blocks were already marked indirect.
+
+	// Mark the caller's targets node as indirect.
+	sig := c.method.Type().(*types.Signature)
+	id := c.params
+	h.markIndirect(onodeid(c.params), "invoke targets node")
+	id++
+
+	id += nodeid(h.a.sizeof(sig.Params()))
+
+	// Mark the caller's R-block as indirect.
+	end := id + nodeid(h.a.sizeof(sig.Results()))
+	for id < end {
+		h.markIndirect(onodeid(id), "invoke R-block")
+		id++
+	}
+}
+
+// markIndirectNodes marks as indirect nodes whose points-to relations
+// are not entirely captured by the offline graph, including:
+//
+//    (a) All address-taken nodes (including the following nodes within
+//        the same object).  This is described in the paper.
+//
+// The most subtle cause of indirect nodes is the generation of
+// store-with-offset constraints since the offline graph doesn't
+// represent them.  A global audit of constraint generation reveals the
+// following uses of store-with-offset:
+//
+//    (b) genDynamicCall, for P-blocks of dynamically called functions,
+//        to which dynamic copy edges will be added to them during
+//        solving: from storeConstraint for standalone functions,
+//        and from invokeConstraint for methods.
+//        All such P-blocks must be marked indirect.
+//    (c) MakeUpdate, to update the value part of a map object.
+//        All MakeMap objects's value parts must be marked indirect.
+//    (d) copyElems, to update the destination array.
+//        All array elements must be marked indirect.
+//
+// Not all indirect marking happens here.  ref() nodes are marked
+// indirect at construction, and each constraint's presolve() method may
+// mark additional nodes.
+//
+func (h *hvn) markIndirectNodes() {
+	// (a) all address-taken nodes, plus all nodes following them
+	//     within the same object, since these may be indirectly
+	//     stored or address-taken.
+	for _, c := range h.a.constraints {
+		if c, ok := c.(*addrConstraint); ok {
+			start := h.a.enclosingObj(c.src)
+			end := start + nodeid(h.a.nodes[start].obj.size)
+			for id := c.src; id < end; id++ {
+				h.markIndirect(onodeid(id), "A-T object")
+			}
+		}
+	}
+
+	// (b) P-blocks of all address-taken functions.
+	for id := 0; id < h.N; id++ {
+		obj := h.a.nodes[id].obj
+
+		// TODO(adonovan): opt: if obj.cgn.fn is a method and
+		// obj.cgn is not its shared contour, this is an
+		// "inlined" static method call.  We needn't consider it
+		// address-taken since no invokeConstraint will affect it.
+
+		if obj != nil && obj.flags&otFunction != 0 && h.a.atFuncs[obj.cgn.fn] {
+			// address-taken function
+			if debugHVNVerbose && h.log != nil {
+				fmt.Fprintf(h.log, "n%d is address-taken: %s\n", id, obj.cgn.fn)
+			}
+			h.markIndirect(onodeid(id), "A-T func identity")
+			id++
+			sig := obj.cgn.fn.Signature
+			psize := h.a.sizeof(sig.Params())
+			if sig.Recv() != nil {
+				psize += h.a.sizeof(sig.Recv().Type())
+			}
+			for end := id + int(psize); id < end; id++ {
+				h.markIndirect(onodeid(id), "A-T func P-block")
+			}
+			id--
+			continue
+		}
+	}
+
+	// (c) all map objects' value fields.
+	for _, id := range h.a.mapValues {
+		h.markIndirect(onodeid(id), "makemap.value")
+	}
+
+	// (d) all array element objects.
+	// TODO(adonovan): opt: can we do better?
+	for id := 0; id < h.N; id++ {
+		// Identity node for an object of array type?
+		if tArray, ok := h.a.nodes[id].typ.(*types.Array); ok {
+			// Mark the array element nodes indirect.
+			// (Skip past the identity field.)
+			for range h.a.flatten(tArray.Elem()) {
+				id++
+				h.markIndirect(onodeid(id), "array elem")
+			}
+		}
+	}
+}
+
+func (h *hvn) markIndirect(oid onodeid, comment string) {
+	h.onodes[oid].indirect = true
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d is indirect: %s\n", oid, comment)
+	}
+}
+
+// Adds an edge dst-->src.
+// Note the unusual convention: edges are dependency (contraflow) edges.
+func (h *hvn) addEdge(odst, osrc onodeid) {
+	h.onodes[odst].edges.Insert(int(osrc))
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d --> o%d\n", odst, osrc)
+	}
+}
+
+func (h *hvn) addImplicitEdge(odst, osrc onodeid) {
+	h.onodes[odst].implicit.Insert(int(osrc))
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d ~~> o%d\n", odst, osrc)
+	}
+}
+
+// visit implements the depth-first search of Tarjan's SCC algorithm.
+// Precondition: x is canonical.
+func (h *hvn) visit(x onodeid) {
+	h.checkCanonical(x)
+	xo := h.onodes[x]
+	xo.index = h.index
+	xo.lowlink = h.index
+	h.index++
+
+	h.stack = append(h.stack, x) // push
+	assert(xo.scc == 0, "node revisited")
+	xo.scc = -1
+
+	var deps []int
+	deps = xo.edges.AppendTo(deps)
+	deps = xo.implicit.AppendTo(deps)
+
+	for _, y := range deps {
+		// Loop invariant: x is canonical.
+
+		y := h.find(onodeid(y))
+
+		if x == y {
+			continue // nodes already coalesced
+		}
+
+		xo := h.onodes[x]
+		yo := h.onodes[y]
+
+		switch {
+		case yo.scc > 0:
+			// y is already a collapsed SCC
+
+		case yo.scc < 0:
+			// y is on the stack, and thus in the current SCC.
+			if yo.index < xo.lowlink {
+				xo.lowlink = yo.index
+			}
+
+		default:
+			// y is unvisited; visit it now.
+			h.visit(y)
+			// Note: x and y are now non-canonical.
+
+			x = h.find(onodeid(x))
+
+			if yo.lowlink < xo.lowlink {
+				xo.lowlink = yo.lowlink
+			}
+		}
+	}
+	h.checkCanonical(x)
+
+	// Is x the root of an SCC?
+	if xo.lowlink == xo.index {
+		// Coalesce all nodes in the SCC.
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "scc o%d\n", x)
+		}
+		for {
+			// Pop y from stack.
+			i := len(h.stack) - 1
+			y := h.stack[i]
+			h.stack = h.stack[:i]
+
+			h.checkCanonical(x)
+			xo := h.onodes[x]
+			h.checkCanonical(y)
+			yo := h.onodes[y]
+
+			if xo == yo {
+				// SCC is complete.
+				xo.scc = 1
+				h.labelSCC(x)
+				break
+			}
+			h.coalesce(x, y)
+		}
+	}
+}
+
+// Precondition: x is canonical.
+func (h *hvn) labelSCC(x onodeid) {
+	h.checkCanonical(x)
+	xo := h.onodes[x]
+	xpe := &xo.peLabels
+
+	// All indirect nodes get new labels.
+	if xo.indirect {
+		label := h.nextLabel()
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "\tcreate p%d: indirect SCC\n", label)
+			fmt.Fprintf(h.log, "\to%d has p%d\n", x, label)
+		}
+
+		// Remove pre-labeling, in case a direct pre-labeled node was
+		// merged with an indirect one.
+		xpe.Clear()
+		xpe.Insert(int(label))
+
+		return
+	}
+
+	// Invariant: all peLabels sets are non-empty.
+	// Those that are logically empty contain zero as their sole element.
+	// No other sets contains zero.
+
+	// Find all labels coming in to the coalesced SCC node.
+	for _, y := range xo.edges.AppendTo(nil) {
+		y := h.find(onodeid(y))
+		if y == x {
+			continue // already coalesced
+		}
+		ype := &h.onodes[y].peLabels
+		if debugHVNVerbose && h.log != nil {
+			fmt.Fprintf(h.log, "\tedge from o%d = %s\n", y, ype)
+		}
+
+		if ype.IsEmpty() {
+			if debugHVNVerbose && h.log != nil {
+				fmt.Fprintf(h.log, "\tnode has no PE label\n")
+			}
+		}
+		assert(!ype.IsEmpty(), "incoming node has no PE label")
+
+		if ype.Has(0) {
+			// {0} represents a non-pointer.
+			assert(ype.Len() == 1, "PE set contains {0, ...}")
+		} else {
+			xpe.UnionWith(ype)
+		}
+	}
+
+	switch xpe.Len() {
+	case 0:
+		// SCC has no incoming non-zero PE labels: it is a non-pointer.
+		xpe.Insert(0)
+
+	case 1:
+		// already a singleton
+
+	default:
+		// SCC has multiple incoming non-zero PE labels.
+		// Find the canonical label representing this set.
+		// We use String() as a fingerprint consistent with Equals().
+		key := xpe.String()
+		label, ok := h.hvnLabel[key]
+		if !ok {
+			label = h.nextLabel()
+			if debugHVNVerbose && h.log != nil {
+				fmt.Fprintf(h.log, "\tcreate p%d: union %s\n", label, xpe.String())
+			}
+			h.hvnLabel[key] = label
+		}
+		xpe.Clear()
+		xpe.Insert(int(label))
+	}
+
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\to%d has p%d\n", x, xpe.Min())
+	}
+}
+
+// coalesce combines two nodes in the offline constraint graph.
+// Precondition: x and y are canonical.
+func (h *hvn) coalesce(x, y onodeid) {
+	xo := h.onodes[x]
+	yo := h.onodes[y]
+
+	// x becomes y's canonical representative.
+	yo.rep = x
+
+	if debugHVNVerbose && h.log != nil {
+		fmt.Fprintf(h.log, "\tcoalesce o%d into o%d\n", y, x)
+	}
+
+	// x accumulates y's edges.
+	xo.edges.UnionWith(&yo.edges)
+	yo.edges.Clear()
+
+	// x accumulates y's implicit edges.
+	xo.implicit.UnionWith(&yo.implicit)
+	yo.implicit.Clear()
+
+	// x accumulates y's pointer-equivalence labels.
+	xo.peLabels.UnionWith(&yo.peLabels)
+	yo.peLabels.Clear()
+
+	// x accumulates y's indirect flag.
+	if yo.indirect {
+		xo.indirect = true
+	}
+}
+
+// simplify computes a degenerate renumbering of nodeids from the PE
+// labels assigned by the hvn, and uses it to simplify the main
+// constraint graph, eliminating non-pointer nodes and duplicate
+// constraints.
+//
+func (h *hvn) simplify() {
+	// canon maps each peLabel to its canonical main node.
+	canon := make([]nodeid, h.label)
+	for i := range canon {
+		canon[i] = nodeid(h.N) // indicates "unset"
+	}
+
+	// mapping maps each main node index to the index of the canonical node.
+	mapping := make([]nodeid, len(h.a.nodes))
+
+	for id := range h.a.nodes {
+		id := nodeid(id)
+		if id == 0 {
+			canon[0] = 0
+			mapping[0] = 0
+			continue
+		}
+		oid := h.find(onodeid(id))
+		peLabels := &h.onodes[oid].peLabels
+		assert(peLabels.Len() == 1, "PE class is not a singleton")
+		label := peLabel(peLabels.Min())
+
+		canonId := canon[label]
+		if canonId == nodeid(h.N) {
+			// id becomes the representative of the PE label.
+			canonId = id
+			canon[label] = canonId
+
+			if h.a.log != nil {
+				fmt.Fprintf(h.a.log, "\tpts(n%d) is canonical : \t(%s)\n",
+					id, h.a.nodes[id].typ)
+			}
+
+		} else {
+			// Link the solver states for the two nodes.
+			assert(h.a.nodes[canonId].solve != nil, "missing solver state")
+			h.a.nodes[id].solve = h.a.nodes[canonId].solve
+
+			if h.a.log != nil {
+				// TODO(adonovan): debug: reorganize the log so it prints
+				// one line:
+				// 	pe y = x1, ..., xn
+				// for each canonical y.  Requires allocation.
+				fmt.Fprintf(h.a.log, "\tpts(n%d) = pts(n%d) : %s\n",
+					id, canonId, h.a.nodes[id].typ)
+			}
+		}
+
+		mapping[id] = canonId
+	}
+
+	// Renumber the constraints, eliminate duplicates, and eliminate
+	// any containing non-pointers (n0).
+	addrs := make(map[addrConstraint]bool)
+	copys := make(map[copyConstraint]bool)
+	loads := make(map[loadConstraint]bool)
+	stores := make(map[storeConstraint]bool)
+	offsetAddrs := make(map[offsetAddrConstraint]bool)
+	untags := make(map[untagConstraint]bool)
+	typeFilters := make(map[typeFilterConstraint]bool)
+	invokes := make(map[invokeConstraint]bool)
+
+	nbefore := len(h.a.constraints)
+	cc := h.a.constraints[:0] // in-situ compaction
+	for _, c := range h.a.constraints {
+		// Renumber.
+		switch c := c.(type) {
+		case *addrConstraint:
+			// Don't renumber c.src since it is the label of
+			// an addressable object and will appear in PT sets.
+			c.dst = mapping[c.dst]
+		default:
+			c.renumber(mapping)
+		}
+
+		if c.ptr() == 0 {
+			continue // skip: constraint attached to non-pointer
+		}
+
+		var dup bool
+		switch c := c.(type) {
+		case *addrConstraint:
+			_, dup = addrs[*c]
+			addrs[*c] = true
+
+		case *copyConstraint:
+			if c.src == c.dst {
+				continue // skip degenerate copies
+			}
+			if c.src == 0 {
+				continue // skip copy from non-pointer
+			}
+			_, dup = copys[*c]
+			copys[*c] = true
+
+		case *loadConstraint:
+			if c.src == 0 {
+				continue // skip load from non-pointer
+			}
+			_, dup = loads[*c]
+			loads[*c] = true
+
+		case *storeConstraint:
+			if c.src == 0 {
+				continue // skip store from non-pointer
+			}
+			_, dup = stores[*c]
+			stores[*c] = true
+
+		case *offsetAddrConstraint:
+			if c.src == 0 {
+				continue // skip offset from non-pointer
+			}
+			_, dup = offsetAddrs[*c]
+			offsetAddrs[*c] = true
+
+		case *untagConstraint:
+			if c.src == 0 {
+				continue // skip untag of non-pointer
+			}
+			_, dup = untags[*c]
+			untags[*c] = true
+
+		case *typeFilterConstraint:
+			if c.src == 0 {
+				continue // skip filter of non-pointer
+			}
+			_, dup = typeFilters[*c]
+			typeFilters[*c] = true
+
+		case *invokeConstraint:
+			if c.params == 0 {
+				panic("non-pointer invoke.params")
+			}
+			if c.iface == 0 {
+				continue // skip invoke on non-pointer
+			}
+			_, dup = invokes[*c]
+			invokes[*c] = true
+
+		default:
+			// We don't bother de-duping advanced constraints
+			// (e.g. reflection) since they are uncommon.
+
+			// Eliminate constraints containing non-pointer nodeids.
+			//
+			// We use reflection to find the fields to avoid
+			// adding yet another method to constraint.
+			//
+			// TODO(adonovan): experiment with a constraint
+			// method that returns a slice of pointers to
+			// nodeids fields to enable uniform iteration;
+			// the renumber() method could be removed and
+			// implemented using the new one.
+			//
+			// TODO(adonovan): opt: this is unsound since
+			// some constraints still have an effect if one
+			// of the operands is zero: rVCall, rVMapIndex,
+			// rvSetMapIndex.  Handle them specially.
+			rtNodeid := reflect.TypeOf(nodeid(0))
+			x := reflect.ValueOf(c).Elem()
+			for i, nf := 0, x.NumField(); i < nf; i++ {
+				f := x.Field(i)
+				if f.Type() == rtNodeid {
+					if f.Uint() == 0 {
+						dup = true // skip it
+						break
+					}
+				}
+			}
+		}
+		if dup {
+			continue // skip duplicates
+		}
+
+		cc = append(cc, c)
+	}
+	h.a.constraints = cc
+
+	if h.log != nil {
+		fmt.Fprintf(h.log, "#constraints: was %d, now %d\n", nbefore, len(h.a.constraints))
+	}
+}
+
+// find returns the canonical onodeid for x.
+// (The onodes form a disjoint set forest.)
+func (h *hvn) find(x onodeid) onodeid {
+	// TODO(adonovan): opt: this is a CPU hotspot.  Try "union by rank".
+	xo := h.onodes[x]
+	rep := xo.rep
+	if rep != x {
+		rep = h.find(rep) // simple path compression
+		xo.rep = rep
+	}
+	return rep
+}
+
+func (h *hvn) checkCanonical(x onodeid) {
+	if debugHVN {
+		assert(x == h.find(x), "not canonical")
+	}
+}
+
+func assert(p bool, msg string) {
+	if debugHVN && !p {
+		panic("assertion failed: " + msg)
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/intrinsics.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/intrinsics.go
new file mode 100644
index 00000000..b7e2b140
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/intrinsics.go
@@ -0,0 +1,361 @@
+// 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 pointer
+
+// This package defines the treatment of intrinsics, i.e. library
+// functions requiring special analytical treatment.
+//
+// Most of these are C or assembly functions, but even some Go
+// functions require may special treatment if the analysis completely
+// replaces the implementation of an API such as reflection.
+
+// TODO(adonovan): support a means of writing analytic summaries in
+// the target code, so that users can summarise the effects of their
+// own C functions using a snippet of Go.
+
+import (
+	"fmt"
+	"go/types"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+// Instances of 'intrinsic' generate analysis constraints for calls to
+// intrinsic functions.
+// Implementations may exploit information from the calling site
+// via cgn.callersite; for shared contours this is nil.
+type intrinsic func(a *analysis, cgn *cgnode)
+
+// Initialized in explicit init() to defeat (spurious) initialization
+// cycle error.
+var intrinsicsByName = make(map[string]intrinsic)
+
+func init() {
+	// Key strings are from Function.String().
+	// That little dot ۰ is an Arabic zero numeral (U+06F0),
+	// categories [Nd].
+	for name, fn := range map[string]intrinsic{
+		// Other packages.
+		"bytes.Equal":                  ext۰NoEffect,
+		"bytes.IndexByte":              ext۰NoEffect,
+		"crypto/aes.decryptBlockAsm":   ext۰NoEffect,
+		"crypto/aes.encryptBlockAsm":   ext۰NoEffect,
+		"crypto/aes.expandKeyAsm":      ext۰NoEffect,
+		"crypto/aes.hasAsm":            ext۰NoEffect,
+		"crypto/md5.block":             ext۰NoEffect,
+		"crypto/rc4.xorKeyStream":      ext۰NoEffect,
+		"crypto/sha1.block":            ext۰NoEffect,
+		"crypto/sha256.block":          ext۰NoEffect,
+		"hash/crc32.castagnoliSSE42":   ext۰NoEffect,
+		"hash/crc32.haveSSE42":         ext۰NoEffect,
+		"math.Abs":                     ext۰NoEffect,
+		"math.Acos":                    ext۰NoEffect,
+		"math.Asin":                    ext۰NoEffect,
+		"math.Atan":                    ext۰NoEffect,
+		"math.Atan2":                   ext۰NoEffect,
+		"math.Ceil":                    ext۰NoEffect,
+		"math.Cos":                     ext۰NoEffect,
+		"math.Dim":                     ext۰NoEffect,
+		"math.Exp":                     ext۰NoEffect,
+		"math.Exp2":                    ext۰NoEffect,
+		"math.Expm1":                   ext۰NoEffect,
+		"math.Float32bits":             ext۰NoEffect,
+		"math.Float32frombits":         ext۰NoEffect,
+		"math.Float64bits":             ext۰NoEffect,
+		"math.Float64frombits":         ext۰NoEffect,
+		"math.Floor":                   ext۰NoEffect,
+		"math.Frexp":                   ext۰NoEffect,
+		"math.Hypot":                   ext۰NoEffect,
+		"math.Ldexp":                   ext۰NoEffect,
+		"math.Log":                     ext۰NoEffect,
+		"math.Log10":                   ext۰NoEffect,
+		"math.Log1p":                   ext۰NoEffect,
+		"math.Log2":                    ext۰NoEffect,
+		"math.Max":                     ext۰NoEffect,
+		"math.Min":                     ext۰NoEffect,
+		"math.Mod":                     ext۰NoEffect,
+		"math.Modf":                    ext۰NoEffect,
+		"math.Remainder":               ext۰NoEffect,
+		"math.Sin":                     ext۰NoEffect,
+		"math.Sincos":                  ext۰NoEffect,
+		"math.Sqrt":                    ext۰NoEffect,
+		"math.Tan":                     ext۰NoEffect,
+		"math.Trunc":                   ext۰NoEffect,
+		"math/big.addMulVVW":           ext۰NoEffect,
+		"math/big.addVV":               ext۰NoEffect,
+		"math/big.addVW":               ext۰NoEffect,
+		"math/big.bitLen":              ext۰NoEffect,
+		"math/big.divWVW":              ext۰NoEffect,
+		"math/big.divWW":               ext۰NoEffect,
+		"math/big.mulAddVWW":           ext۰NoEffect,
+		"math/big.mulWW":               ext۰NoEffect,
+		"math/big.shlVU":               ext۰NoEffect,
+		"math/big.shrVU":               ext۰NoEffect,
+		"math/big.subVV":               ext۰NoEffect,
+		"math/big.subVW":               ext۰NoEffect,
+		"net.runtime_Semacquire":       ext۰NoEffect,
+		"net.runtime_Semrelease":       ext۰NoEffect,
+		"net.runtime_pollClose":        ext۰NoEffect,
+		"net.runtime_pollOpen":         ext۰NoEffect,
+		"net.runtime_pollReset":        ext۰NoEffect,
+		"net.runtime_pollServerInit":   ext۰NoEffect,
+		"net.runtime_pollSetDeadline":  ext۰NoEffect,
+		"net.runtime_pollUnblock":      ext۰NoEffect,
+		"net.runtime_pollWait":         ext۰NoEffect,
+		"net.runtime_pollWaitCanceled": ext۰NoEffect,
+		"os.epipecheck":                ext۰NoEffect,
+		// All other runtime functions are treated as NoEffect.
+		"runtime.SetFinalizer":              ext۰runtime۰SetFinalizer,
+		"strings.IndexByte":                 ext۰NoEffect,
+		"sync.runtime_Semacquire":           ext۰NoEffect,
+		"sync.runtime_Semrelease":           ext۰NoEffect,
+		"sync.runtime_Syncsemacquire":       ext۰NoEffect,
+		"sync.runtime_Syncsemcheck":         ext۰NoEffect,
+		"sync.runtime_Syncsemrelease":       ext۰NoEffect,
+		"sync.runtime_procPin":              ext۰NoEffect,
+		"sync.runtime_procUnpin":            ext۰NoEffect,
+		"sync.runtime_registerPool":         ext۰NoEffect,
+		"sync/atomic.AddInt32":              ext۰NoEffect,
+		"sync/atomic.AddInt64":              ext۰NoEffect,
+		"sync/atomic.AddUint32":             ext۰NoEffect,
+		"sync/atomic.AddUint64":             ext۰NoEffect,
+		"sync/atomic.AddUintptr":            ext۰NoEffect,
+		"sync/atomic.CompareAndSwapInt32":   ext۰NoEffect,
+		"sync/atomic.CompareAndSwapUint32":  ext۰NoEffect,
+		"sync/atomic.CompareAndSwapUint64":  ext۰NoEffect,
+		"sync/atomic.CompareAndSwapUintptr": ext۰NoEffect,
+		"sync/atomic.LoadInt32":             ext۰NoEffect,
+		"sync/atomic.LoadInt64":             ext۰NoEffect,
+		"sync/atomic.LoadPointer":           ext۰NoEffect, // ignore unsafe.Pointers
+		"sync/atomic.LoadUint32":            ext۰NoEffect,
+		"sync/atomic.LoadUint64":            ext۰NoEffect,
+		"sync/atomic.LoadUintptr":           ext۰NoEffect,
+		"sync/atomic.StoreInt32":            ext۰NoEffect,
+		"sync/atomic.StorePointer":          ext۰NoEffect, // ignore unsafe.Pointers
+		"sync/atomic.StoreUint32":           ext۰NoEffect,
+		"sync/atomic.StoreUintptr":          ext۰NoEffect,
+		"syscall.Close":                     ext۰NoEffect,
+		"syscall.Exit":                      ext۰NoEffect,
+		"syscall.Getpid":                    ext۰NoEffect,
+		"syscall.Getwd":                     ext۰NoEffect,
+		"syscall.Kill":                      ext۰NoEffect,
+		"syscall.RawSyscall":                ext۰NoEffect,
+		"syscall.RawSyscall6":               ext۰NoEffect,
+		"syscall.Syscall":                   ext۰NoEffect,
+		"syscall.Syscall6":                  ext۰NoEffect,
+		"syscall.runtime_AfterFork":         ext۰NoEffect,
+		"syscall.runtime_BeforeFork":        ext۰NoEffect,
+		"syscall.setenv_c":                  ext۰NoEffect,
+		"time.Sleep":                        ext۰NoEffect,
+		"time.now":                          ext۰NoEffect,
+		"time.startTimer":                   ext۰time۰startTimer,
+		"time.stopTimer":                    ext۰NoEffect,
+	} {
+		intrinsicsByName[name] = fn
+	}
+}
+
+// findIntrinsic returns the constraint generation function for an
+// intrinsic function fn, or nil if the function should be handled normally.
+//
+func (a *analysis) findIntrinsic(fn *ssa.Function) intrinsic {
+	// Consult the *Function-keyed cache.
+	// A cached nil indicates a normal non-intrinsic function.
+	impl, ok := a.intrinsics[fn]
+	if !ok {
+		impl = intrinsicsByName[fn.String()] // may be nil
+
+		if a.isReflect(fn) {
+			if !a.config.Reflection {
+				impl = ext۰NoEffect // reflection disabled
+			} else if impl == nil {
+				// Ensure all "reflect" code is treated intrinsically.
+				impl = ext۰NotYetImplemented
+			}
+		} else if impl == nil && fn.Pkg != nil && fn.Pkg.Pkg.Path() == "runtime" {
+			// Ignore "runtime" (except SetFinalizer):
+			// it has few interesting effects on aliasing
+			// and is full of unsafe code we can't analyze.
+			impl = ext۰NoEffect
+		}
+
+		a.intrinsics[fn] = impl
+	}
+	return impl
+}
+
+// isReflect reports whether fn belongs to the "reflect" package.
+func (a *analysis) isReflect(fn *ssa.Function) bool {
+	if a.reflectValueObj == nil {
+		return false // "reflect" package not loaded
+	}
+	reflectPackage := a.reflectValueObj.Pkg()
+	if fn.Pkg != nil && fn.Pkg.Pkg == reflectPackage {
+		return true
+	}
+	// Synthetic wrappers have a nil Pkg, so they slip through the
+	// previous check.  Check the receiver package.
+	// TODO(adonovan): should synthetic wrappers have a non-nil Pkg?
+	if recv := fn.Signature.Recv(); recv != nil {
+		if named, ok := deref(recv.Type()).(*types.Named); ok {
+			if named.Obj().Pkg() == reflectPackage {
+				return true // e.g. wrapper of (reflect.Value).f
+			}
+		}
+	}
+	return false
+}
+
+// A trivial intrinsic suitable for any function that does not:
+// 1) induce aliases between its arguments or any global variables;
+// 2) call any functions; or
+// 3) create any labels.
+//
+// Many intrinsics (such as CompareAndSwapInt32) have a fourth kind of
+// effect: loading or storing through a pointer.  Though these could
+// be significant, we deliberately ignore them because they are
+// generally not worth the effort.
+//
+// We sometimes violate condition #3 if the function creates only
+// non-function labels, as the control-flow graph is still sound.
+//
+func ext۰NoEffect(a *analysis, cgn *cgnode) {}
+
+func ext۰NotYetImplemented(a *analysis, cgn *cgnode) {
+	fn := cgn.fn
+	a.warnf(fn.Pos(), "unsound: intrinsic treatment of %s not yet implemented", fn)
+}
+
+// ---------- func runtime.SetFinalizer(x, f interface{}) ----------
+
+// runtime.SetFinalizer(x, f)
+type runtimeSetFinalizerConstraint struct {
+	targets nodeid // (indirect)
+	f       nodeid // (ptr)
+	x       nodeid
+}
+
+func (c *runtimeSetFinalizerConstraint) ptr() nodeid { return c.f }
+func (c *runtimeSetFinalizerConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.targets), "SetFinalizer.targets")
+}
+func (c *runtimeSetFinalizerConstraint) renumber(mapping []nodeid) {
+	c.targets = mapping[c.targets]
+	c.f = mapping[c.f]
+	c.x = mapping[c.x]
+}
+
+func (c *runtimeSetFinalizerConstraint) String() string {
+	return fmt.Sprintf("runtime.SetFinalizer(n%d, n%d)", c.x, c.f)
+}
+
+func (c *runtimeSetFinalizerConstraint) solve(a *analysis, delta *nodeset) {
+	for _, fObj := range delta.AppendTo(a.deltaSpace) {
+		tDyn, f, indirect := a.taggedValue(nodeid(fObj))
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		tSig, ok := tDyn.Underlying().(*types.Signature)
+		if !ok {
+			continue // not a function
+		}
+		if tSig.Recv() != nil {
+			panic(tSig)
+		}
+		if tSig.Params().Len() != 1 {
+			continue //  not a unary function
+		}
+
+		// Extract x to tmp.
+		tx := tSig.Params().At(0).Type()
+		tmp := a.addNodes(tx, "SetFinalizer.tmp")
+		a.typeAssert(tx, tmp, c.x, false)
+
+		// Call f(tmp).
+		a.store(f, tmp, 1, a.sizeof(tx))
+
+		// Add dynamic call target.
+		if a.onlineCopy(c.targets, f) {
+			a.addWork(c.targets)
+		}
+	}
+}
+
+func ext۰runtime۰SetFinalizer(a *analysis, cgn *cgnode) {
+	// This is the shared contour, used for dynamic calls.
+	targets := a.addOneNode(tInvalid, "SetFinalizer.targets", nil)
+	cgn.sites = append(cgn.sites, &callsite{targets: targets})
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&runtimeSetFinalizerConstraint{
+		targets: targets,
+		x:       params,
+		f:       params + 1,
+	})
+}
+
+// ---------- func time.startTimer(t *runtimeTimer) ----------
+
+// time.StartTimer(t)
+type timeStartTimerConstraint struct {
+	targets nodeid // (indirect)
+	t       nodeid // (ptr)
+}
+
+func (c *timeStartTimerConstraint) ptr() nodeid { return c.t }
+func (c *timeStartTimerConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.targets), "StartTimer.targets")
+}
+func (c *timeStartTimerConstraint) renumber(mapping []nodeid) {
+	c.targets = mapping[c.targets]
+	c.t = mapping[c.t]
+}
+
+func (c *timeStartTimerConstraint) String() string {
+	return fmt.Sprintf("time.startTimer(n%d)", c.t)
+}
+
+func (c *timeStartTimerConstraint) solve(a *analysis, delta *nodeset) {
+	for _, tObj := range delta.AppendTo(a.deltaSpace) {
+		t := nodeid(tObj)
+
+		// We model startTimer as if it was defined thus:
+		// 	func startTimer(t *runtimeTimer) { t.f(t.arg) }
+
+		// We hard-code the field offsets of time.runtimeTimer:
+		// type runtimeTimer struct {
+		//  0     __identity__
+		//  1    i      int32
+		//  2    when   int64
+		//  3    period int64
+		//  4    f      func(int64, interface{})
+		//  5    arg    interface{}
+		// }
+		f := t + 4
+		arg := t + 5
+
+		// store t.arg to t.f.params[0]
+		// (offset 1 => skip identity)
+		a.store(f, arg, 1, 1)
+
+		// Add dynamic call target.
+		if a.onlineCopy(c.targets, f) {
+			a.addWork(c.targets)
+		}
+	}
+}
+
+func ext۰time۰startTimer(a *analysis, cgn *cgnode) {
+	// This is the shared contour, used for dynamic calls.
+	targets := a.addOneNode(tInvalid, "startTimer.targets", nil)
+	cgn.sites = append(cgn.sites, &callsite{targets: targets})
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&timeStartTimerConstraint{
+		targets: targets,
+		t:       params,
+	})
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/labels.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/labels.go
new file mode 100644
index 00000000..7d64ef6a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/labels.go
@@ -0,0 +1,152 @@
+// 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 pointer
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"strings"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+// A Label is an entity that may be pointed to by a pointer, map,
+// channel, 'func', slice or interface.
+//
+// Labels include:
+//      - functions
+//      - globals
+//      - tagged objects, representing interfaces and reflect.Values
+//      - arrays created by conversions (e.g. []byte("foo"), []byte(s))
+//      - stack- and heap-allocated variables (including composite literals)
+//      - channels, maps and arrays created by make()
+//      - intrinsic or reflective operations that allocate (e.g. append, reflect.New)
+//      - intrinsic objects, e.g. the initial array behind os.Args.
+//      - and their subelements, e.g. "alloc.y[*].z"
+//
+// Labels are so varied that they defy good generalizations;
+// some have no value, no callgraph node, or no position.
+// Many objects have types that are inexpressible in Go:
+// maps, channels, functions, tagged objects.
+//
+// At most one of Value() or ReflectType() may return non-nil.
+//
+type Label struct {
+	obj        *object    // the addressable memory location containing this label
+	subelement *fieldInfo // subelement path within obj, e.g. ".a.b[*].c"
+}
+
+// Value returns the ssa.Value that allocated this label's object, if any.
+func (l Label) Value() ssa.Value {
+	val, _ := l.obj.data.(ssa.Value)
+	return val
+}
+
+// ReflectType returns the type represented by this label if it is an
+// reflect.rtype instance object or *reflect.rtype-tagged object.
+//
+func (l Label) ReflectType() types.Type {
+	rtype, _ := l.obj.data.(types.Type)
+	return rtype
+}
+
+// Path returns the path to the subelement of the object containing
+// this label.  For example, ".x[*].y".
+//
+func (l Label) Path() string {
+	return l.subelement.path()
+}
+
+// Pos returns the position of this label, if known, zero otherwise.
+func (l Label) Pos() token.Pos {
+	switch data := l.obj.data.(type) {
+	case ssa.Value:
+		return data.Pos()
+	case types.Type:
+		if nt, ok := deref(data).(*types.Named); ok {
+			return nt.Obj().Pos()
+		}
+	}
+	if cgn := l.obj.cgn; cgn != nil {
+		return cgn.fn.Pos()
+	}
+	return token.NoPos
+}
+
+// String returns the printed form of this label.
+//
+// Examples:                                    Object type:
+//      x                                       (a variable)
+//      (sync.Mutex).Lock                       (a function)
+//      convert                                 (array created by conversion)
+//      makemap                                 (map allocated via make)
+//      makechan                                (channel allocated via make)
+//      makeinterface                           (tagged object allocated by makeinterface)
+//      <alloc in reflect.Zero>                 (allocation in instrinsic)
+//      sync.Mutex                              (a reflect.rtype instance)
+//      <command-line arguments>                (an intrinsic object)
+//
+// Labels within compound objects have subelement paths:
+//      x.y[*].z                                (a struct variable, x)
+//      append.y[*].z                           (array allocated by append)
+//      makeslice.y[*].z                        (array allocated via make)
+//
+// TODO(adonovan): expose func LabelString(*types.Package, Label).
+//
+func (l Label) String() string {
+	var s string
+	switch v := l.obj.data.(type) {
+	case types.Type:
+		return v.String()
+
+	case string:
+		s = v // an intrinsic object (e.g. os.Args[*])
+
+	case nil:
+		if l.obj.cgn != nil {
+			// allocation by intrinsic or reflective operation
+			s = fmt.Sprintf("<alloc in %s>", l.obj.cgn.fn)
+		} else {
+			s = "<unknown>" // should be unreachable
+		}
+
+	case *ssa.Function:
+		s = v.String()
+
+	case *ssa.Global:
+		s = v.String()
+
+	case *ssa.Const:
+		s = v.Name()
+
+	case *ssa.Alloc:
+		s = v.Comment
+		if s == "" {
+			s = "alloc"
+		}
+
+	case *ssa.Call:
+		// Currently only calls to append can allocate objects.
+		if v.Call.Value.(*ssa.Builtin).Object().Name() != "append" {
+			panic("unhandled *ssa.Call label: " + v.Name())
+		}
+		s = "append"
+
+	case *ssa.MakeMap, *ssa.MakeChan, *ssa.MakeSlice, *ssa.Convert:
+		s = strings.ToLower(strings.TrimPrefix(fmt.Sprintf("%T", v), "*ssa."))
+
+	case *ssa.MakeInterface:
+		// MakeInterface is usually implicit in Go source (so
+		// Pos()==0), and tagged objects may be allocated
+		// synthetically (so no *MakeInterface data).
+		s = "makeinterface:" + v.X.Type().String()
+
+	default:
+		panic(fmt.Sprintf("unhandled object data type: %T", v))
+	}
+
+	return s + l.subelement.path()
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/opt.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/opt.go
new file mode 100644
index 00000000..81f80aa4
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/opt.go
@@ -0,0 +1,132 @@
+// 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 pointer
+
+// This file implements renumbering, a pre-solver optimization to
+// improve the efficiency of the solver's points-to set representation.
+//
+// TODO(adonovan): rename file "renumber.go"
+
+import "fmt"
+
+// renumber permutes a.nodes so that all nodes within an addressable
+// object appear before all non-addressable nodes, maintaining the
+// order of nodes within the same object (as required by offsetAddr).
+//
+// renumber must update every nodeid in the analysis (constraints,
+// Pointers, callgraph, etc) to reflect the new ordering.
+//
+// This is an optimisation to increase the locality and efficiency of
+// sparse representations of points-to sets.  (Typically only about
+// 20% of nodes are within an object.)
+//
+// NB: nodes added during solving (e.g. for reflection, SetFinalizer)
+// will be appended to the end.
+//
+// Renumbering makes the PTA log inscrutable.  To aid debugging, later
+// phases (e.g. HVN) must not rely on it having occurred.
+//
+func (a *analysis) renumber() {
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\n\n==== Renumbering\n\n")
+	}
+
+	N := nodeid(len(a.nodes))
+	newNodes := make([]*node, N, N)
+	renumbering := make([]nodeid, N, N) // maps old to new
+
+	var i, j nodeid
+
+	// The zero node is special.
+	newNodes[j] = a.nodes[i]
+	renumbering[i] = j
+	i++
+	j++
+
+	// Pass 1: object nodes.
+	for i < N {
+		obj := a.nodes[i].obj
+		if obj == nil {
+			i++
+			continue
+		}
+
+		end := i + nodeid(obj.size)
+		for i < end {
+			newNodes[j] = a.nodes[i]
+			renumbering[i] = j
+			i++
+			j++
+		}
+	}
+	nobj := j
+
+	// Pass 2: non-object nodes.
+	for i = 1; i < N; {
+		obj := a.nodes[i].obj
+		if obj != nil {
+			i += nodeid(obj.size)
+			continue
+		}
+
+		newNodes[j] = a.nodes[i]
+		renumbering[i] = j
+		i++
+		j++
+	}
+
+	if j != N {
+		panic(fmt.Sprintf("internal error: j=%d, N=%d", j, N))
+	}
+
+	// Log the remapping table.
+	if a.log != nil {
+		fmt.Fprintf(a.log, "Renumbering nodes to improve density:\n")
+		fmt.Fprintf(a.log, "(%d object nodes of %d total)\n", nobj, N)
+		for old, new := range renumbering {
+			fmt.Fprintf(a.log, "\tn%d -> n%d\n", old, new)
+		}
+	}
+
+	// Now renumber all existing nodeids to use the new node permutation.
+	// It is critical that all reachable nodeids are accounted for!
+
+	// Renumber nodeids in queried Pointers.
+	for v, ptr := range a.result.Queries {
+		ptr.n = renumbering[ptr.n]
+		a.result.Queries[v] = ptr
+	}
+	for v, ptr := range a.result.IndirectQueries {
+		ptr.n = renumbering[ptr.n]
+		a.result.IndirectQueries[v] = ptr
+	}
+	for _, queries := range a.config.extendedQueries {
+		for _, query := range queries {
+			if query.ptr != nil {
+				query.ptr.n = renumbering[query.ptr.n]
+			}
+		}
+	}
+
+	// Renumber nodeids in global objects.
+	for v, id := range a.globalobj {
+		a.globalobj[v] = renumbering[id]
+	}
+
+	// Renumber nodeids in constraints.
+	for _, c := range a.constraints {
+		c.renumber(renumbering)
+	}
+
+	// Renumber nodeids in the call graph.
+	for _, cgn := range a.cgnodes {
+		cgn.obj = renumbering[cgn.obj]
+		for _, site := range cgn.sites {
+			site.targets = renumbering[site.targets]
+		}
+	}
+
+	a.nodes = newNodes
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/print.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/print.go
new file mode 100644
index 00000000..4f2f4c7a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/print.go
@@ -0,0 +1,43 @@
+// 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 pointer
+
+import "fmt"
+
+func (c *addrConstraint) String() string {
+	return fmt.Sprintf("addr n%d <- {&n%d}", c.dst, c.src)
+}
+
+func (c *copyConstraint) String() string {
+	return fmt.Sprintf("copy n%d <- n%d", c.dst, c.src)
+}
+
+func (c *loadConstraint) String() string {
+	return fmt.Sprintf("load n%d <- n%d[%d]", c.dst, c.src, c.offset)
+}
+
+func (c *storeConstraint) String() string {
+	return fmt.Sprintf("store n%d[%d] <- n%d", c.dst, c.offset, c.src)
+}
+
+func (c *offsetAddrConstraint) String() string {
+	return fmt.Sprintf("offsetAddr n%d <- n%d.#%d", c.dst, c.src, c.offset)
+}
+
+func (c *typeFilterConstraint) String() string {
+	return fmt.Sprintf("typeFilter n%d <- n%d.(%s)", c.dst, c.src, c.typ)
+}
+
+func (c *untagConstraint) String() string {
+	return fmt.Sprintf("untag n%d <- n%d.(%s)", c.dst, c.src, c.typ)
+}
+
+func (c *invokeConstraint) String() string {
+	return fmt.Sprintf("invoke n%d.%s(n%d ...)", c.iface, c.method.Name(), c.params)
+}
+
+func (n nodeid) String() string {
+	return fmt.Sprintf("n%d", n)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/query.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/query.go
new file mode 100644
index 00000000..1263d318
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/query.go
@@ -0,0 +1,221 @@
+package pointer
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// An extendedQuery represents a sequence of destructuring operations
+// applied to an ssa.Value (denoted by "x").
+type extendedQuery struct {
+	ops []interface{}
+	ptr *Pointer
+}
+
+// indexValue returns the value of an integer literal used as an
+// index.
+func indexValue(expr ast.Expr) (int, error) {
+	lit, ok := expr.(*ast.BasicLit)
+	if !ok {
+		return 0, fmt.Errorf("non-integer index (%T)", expr)
+	}
+	if lit.Kind != token.INT {
+		return 0, fmt.Errorf("non-integer index %s", lit.Value)
+	}
+	return strconv.Atoi(lit.Value)
+}
+
+// parseExtendedQuery parses and validates a destructuring Go
+// expression and returns the sequence of destructuring operations.
+// See parseDestructuringExpr for details.
+func parseExtendedQuery(typ types.Type, query string) ([]interface{}, types.Type, error) {
+	expr, err := parser.ParseExpr(query)
+	if err != nil {
+		return nil, nil, err
+	}
+	ops, typ, err := destructuringOps(typ, expr)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(ops) == 0 {
+		return nil, nil, errors.New("invalid query: must not be empty")
+	}
+	if ops[0] != "x" {
+		return nil, nil, fmt.Errorf("invalid query: query operand must be named x")
+	}
+	if !CanPoint(typ) {
+		return nil, nil, fmt.Errorf("query does not describe a pointer-like value: %s", typ)
+	}
+	return ops, typ, nil
+}
+
+// destructuringOps parses a Go expression consisting only of an
+// identifier "x", field selections, indexing, channel receives, load
+// operations and parens---for example: "<-(*x[i])[key]"--- and
+// returns the sequence of destructuring operations on x.
+func destructuringOps(typ types.Type, expr ast.Expr) ([]interface{}, types.Type, error) {
+	switch expr := expr.(type) {
+	case *ast.SelectorExpr:
+		out, typ, err := destructuringOps(typ, expr.X)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		var structT *types.Struct
+		switch typ := typ.(type) {
+		case *types.Pointer:
+			var ok bool
+			structT, ok = typ.Elem().Underlying().(*types.Struct)
+			if !ok {
+				return nil, nil, fmt.Errorf("cannot access field %s of pointer to type %s", expr.Sel.Name, typ.Elem())
+			}
+
+			out = append(out, "load")
+		case *types.Struct:
+			structT = typ
+		default:
+			return nil, nil, fmt.Errorf("cannot access field %s of type %s", expr.Sel.Name, typ)
+		}
+
+		for i := 0; i < structT.NumFields(); i++ {
+			field := structT.Field(i)
+			if field.Name() == expr.Sel.Name {
+				out = append(out, "field", i)
+				return out, field.Type().Underlying(), nil
+			}
+		}
+		// TODO(dh): supporting embedding would need something like
+		// types.LookupFieldOrMethod, but without taking package
+		// boundaries into account, because we may want to access
+		// unexported fields. If we were only interested in one level
+		// of unexported name, we could determine the appropriate
+		// package and run LookupFieldOrMethod with that. However, a
+		// single query may want to cross multiple package boundaries,
+		// and at this point it's not really worth the complexity.
+		return nil, nil, fmt.Errorf("no field %s in %s (embedded fields must be resolved manually)", expr.Sel.Name, structT)
+	case *ast.Ident:
+		return []interface{}{expr.Name}, typ, nil
+	case *ast.BasicLit:
+		return []interface{}{expr.Value}, nil, nil
+	case *ast.IndexExpr:
+		out, typ, err := destructuringOps(typ, expr.X)
+		if err != nil {
+			return nil, nil, err
+		}
+		switch typ := typ.(type) {
+		case *types.Array:
+			out = append(out, "arrayelem")
+			return out, typ.Elem().Underlying(), nil
+		case *types.Slice:
+			out = append(out, "sliceelem")
+			return out, typ.Elem().Underlying(), nil
+		case *types.Map:
+			out = append(out, "mapelem")
+			return out, typ.Elem().Underlying(), nil
+		case *types.Tuple:
+			out = append(out, "index")
+			idx, err := indexValue(expr.Index)
+			if err != nil {
+				return nil, nil, err
+			}
+			out = append(out, idx)
+			if idx >= typ.Len() || idx < 0 {
+				return nil, nil, fmt.Errorf("tuple index %d out of bounds", idx)
+			}
+			return out, typ.At(idx).Type().Underlying(), nil
+		default:
+			return nil, nil, fmt.Errorf("cannot index type %s", typ)
+		}
+
+	case *ast.UnaryExpr:
+		if expr.Op != token.ARROW {
+			return nil, nil, fmt.Errorf("unsupported unary operator %s", expr.Op)
+		}
+		out, typ, err := destructuringOps(typ, expr.X)
+		if err != nil {
+			return nil, nil, err
+		}
+		ch, ok := typ.(*types.Chan)
+		if !ok {
+			return nil, nil, fmt.Errorf("cannot receive from value of type %s", typ)
+		}
+		out = append(out, "recv")
+		return out, ch.Elem().Underlying(), err
+	case *ast.ParenExpr:
+		return destructuringOps(typ, expr.X)
+	case *ast.StarExpr:
+		out, typ, err := destructuringOps(typ, expr.X)
+		if err != nil {
+			return nil, nil, err
+		}
+		ptr, ok := typ.(*types.Pointer)
+		if !ok {
+			return nil, nil, fmt.Errorf("cannot dereference type %s", typ)
+		}
+		out = append(out, "load")
+		return out, ptr.Elem().Underlying(), err
+	default:
+		return nil, nil, fmt.Errorf("unsupported expression %T", expr)
+	}
+}
+
+func (a *analysis) evalExtendedQuery(t types.Type, id nodeid, ops []interface{}) (types.Type, nodeid) {
+	pid := id
+	// TODO(dh): we're allocating intermediary nodes each time
+	// evalExtendedQuery is called. We should probably only generate
+	// them once per (v, ops) pair.
+	for i := 1; i < len(ops); i++ {
+		var nid nodeid
+		switch ops[i] {
+		case "recv":
+			t = t.(*types.Chan).Elem().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.load(nid, pid, 0, a.sizeof(t))
+		case "field":
+			i++ // fetch field index
+			tt := t.(*types.Struct)
+			idx := ops[i].(int)
+			offset := a.offsetOf(t, idx)
+			t = tt.Field(idx).Type().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.copy(nid, pid+nodeid(offset), a.sizeof(t))
+		case "arrayelem":
+			t = t.(*types.Array).Elem().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.copy(nid, 1+pid, a.sizeof(t))
+		case "sliceelem":
+			t = t.(*types.Slice).Elem().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.load(nid, pid, 1, a.sizeof(t))
+		case "mapelem":
+			tt := t.(*types.Map)
+			t = tt.Elem()
+			ksize := a.sizeof(tt.Key())
+			vsize := a.sizeof(tt.Elem())
+			nid = a.addNodes(t, "query.extended")
+			a.load(nid, pid, ksize, vsize)
+		case "index":
+			i++ // fetch index
+			tt := t.(*types.Tuple)
+			idx := ops[i].(int)
+			t = tt.At(idx).Type().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.copy(nid, pid+nodeid(idx), a.sizeof(t))
+		case "load":
+			t = t.(*types.Pointer).Elem().Underlying()
+			nid = a.addNodes(t, "query.extended")
+			a.load(nid, pid, 0, a.sizeof(t))
+		default:
+			// shouldn't happen
+			panic(fmt.Sprintf("unknown op %q", ops[i]))
+		}
+		pid = nid
+	}
+
+	return t, pid
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/reflect.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/reflect.go
new file mode 100644
index 00000000..3439a896
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/reflect.go
@@ -0,0 +1,1975 @@
+// 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 pointer
+
+// This file implements the generation and resolution rules for
+// constraints arising from the use of reflection in the target
+// program.  See doc.go for explanation of the representation.
+//
+// For consistency, the names of all parameters match those of the
+// actual functions in the "reflect" package.
+//
+// To avoid proliferation of equivalent labels, intrinsics should
+// memoize as much as possible, like TypeOf and Zero do for their
+// tagged objects.
+//
+// TODO(adonovan): this file is rather subtle.  Explain how we derive
+// the implementation of each reflect operator from its spec,
+// including the subtleties of reflect.flag{Addr,RO,Indir}.
+// [Hint: our implementation is as if reflect.flagIndir was always
+// true, i.e. reflect.Values are pointers to tagged objects, there is
+// no inline allocation optimization; and indirect tagged objects (not
+// yet implemented) correspond to reflect.Values with
+// reflect.flagAddr.]
+// A picture would help too.
+//
+// TODO(adonovan): try factoring up the common parts of the majority of
+// these constraints that are single input, single output.
+
+import (
+	"fmt"
+	exact "go/constant"
+	"go/types"
+	"reflect"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+func init() {
+	for name, fn := range map[string]intrinsic{
+		// reflect.Value methods.
+		"(reflect.Value).Addr":            ext۰reflect۰Value۰Addr,
+		"(reflect.Value).Bool":            ext۰NoEffect,
+		"(reflect.Value).Bytes":           ext۰reflect۰Value۰Bytes,
+		"(reflect.Value).Call":            ext۰reflect۰Value۰Call,
+		"(reflect.Value).CallSlice":       ext۰reflect۰Value۰CallSlice,
+		"(reflect.Value).CanAddr":         ext۰NoEffect,
+		"(reflect.Value).CanInterface":    ext۰NoEffect,
+		"(reflect.Value).CanSet":          ext۰NoEffect,
+		"(reflect.Value).Cap":             ext۰NoEffect,
+		"(reflect.Value).Close":           ext۰NoEffect,
+		"(reflect.Value).Complex":         ext۰NoEffect,
+		"(reflect.Value).Convert":         ext۰reflect۰Value۰Convert,
+		"(reflect.Value).Elem":            ext۰reflect۰Value۰Elem,
+		"(reflect.Value).Field":           ext۰reflect۰Value۰Field,
+		"(reflect.Value).FieldByIndex":    ext۰reflect۰Value۰FieldByIndex,
+		"(reflect.Value).FieldByName":     ext۰reflect۰Value۰FieldByName,
+		"(reflect.Value).FieldByNameFunc": ext۰reflect۰Value۰FieldByNameFunc,
+		"(reflect.Value).Float":           ext۰NoEffect,
+		"(reflect.Value).Index":           ext۰reflect۰Value۰Index,
+		"(reflect.Value).Int":             ext۰NoEffect,
+		"(reflect.Value).Interface":       ext۰reflect۰Value۰Interface,
+		"(reflect.Value).InterfaceData":   ext۰NoEffect,
+		"(reflect.Value).IsNil":           ext۰NoEffect,
+		"(reflect.Value).IsValid":         ext۰NoEffect,
+		"(reflect.Value).Kind":            ext۰NoEffect,
+		"(reflect.Value).Len":             ext۰NoEffect,
+		"(reflect.Value).MapIndex":        ext۰reflect۰Value۰MapIndex,
+		"(reflect.Value).MapKeys":         ext۰reflect۰Value۰MapKeys,
+		"(reflect.Value).Method":          ext۰reflect۰Value۰Method,
+		"(reflect.Value).MethodByName":    ext۰reflect۰Value۰MethodByName,
+		"(reflect.Value).NumField":        ext۰NoEffect,
+		"(reflect.Value).NumMethod":       ext۰NoEffect,
+		"(reflect.Value).OverflowComplex": ext۰NoEffect,
+		"(reflect.Value).OverflowFloat":   ext۰NoEffect,
+		"(reflect.Value).OverflowInt":     ext۰NoEffect,
+		"(reflect.Value).OverflowUint":    ext۰NoEffect,
+		"(reflect.Value).Pointer":         ext۰NoEffect,
+		"(reflect.Value).Recv":            ext۰reflect۰Value۰Recv,
+		"(reflect.Value).Send":            ext۰reflect۰Value۰Send,
+		"(reflect.Value).Set":             ext۰reflect۰Value۰Set,
+		"(reflect.Value).SetBool":         ext۰NoEffect,
+		"(reflect.Value).SetBytes":        ext۰reflect۰Value۰SetBytes,
+		"(reflect.Value).SetComplex":      ext۰NoEffect,
+		"(reflect.Value).SetFloat":        ext۰NoEffect,
+		"(reflect.Value).SetInt":          ext۰NoEffect,
+		"(reflect.Value).SetLen":          ext۰NoEffect,
+		"(reflect.Value).SetMapIndex":     ext۰reflect۰Value۰SetMapIndex,
+		"(reflect.Value).SetPointer":      ext۰reflect۰Value۰SetPointer,
+		"(reflect.Value).SetString":       ext۰NoEffect,
+		"(reflect.Value).SetUint":         ext۰NoEffect,
+		"(reflect.Value).Slice":           ext۰reflect۰Value۰Slice,
+		"(reflect.Value).String":          ext۰NoEffect,
+		"(reflect.Value).TryRecv":         ext۰reflect۰Value۰Recv,
+		"(reflect.Value).TrySend":         ext۰reflect۰Value۰Send,
+		"(reflect.Value).Type":            ext۰NoEffect,
+		"(reflect.Value).Uint":            ext۰NoEffect,
+		"(reflect.Value).UnsafeAddr":      ext۰NoEffect,
+
+		// Standalone reflect.* functions.
+		"reflect.Append":      ext۰reflect۰Append,
+		"reflect.AppendSlice": ext۰reflect۰AppendSlice,
+		"reflect.Copy":        ext۰reflect۰Copy,
+		"reflect.ChanOf":      ext۰reflect۰ChanOf,
+		"reflect.DeepEqual":   ext۰NoEffect,
+		"reflect.Indirect":    ext۰reflect۰Indirect,
+		"reflect.MakeChan":    ext۰reflect۰MakeChan,
+		"reflect.MakeFunc":    ext۰reflect۰MakeFunc,
+		"reflect.MakeMap":     ext۰reflect۰MakeMap,
+		"reflect.MakeSlice":   ext۰reflect۰MakeSlice,
+		"reflect.MapOf":       ext۰reflect۰MapOf,
+		"reflect.New":         ext۰reflect۰New,
+		"reflect.NewAt":       ext۰reflect۰NewAt,
+		"reflect.PtrTo":       ext۰reflect۰PtrTo,
+		"reflect.Select":      ext۰reflect۰Select,
+		"reflect.SliceOf":     ext۰reflect۰SliceOf,
+		"reflect.TypeOf":      ext۰reflect۰TypeOf,
+		"reflect.ValueOf":     ext۰reflect۰ValueOf,
+		"reflect.Zero":        ext۰reflect۰Zero,
+		"reflect.init":        ext۰NoEffect,
+
+		// *reflect.rtype methods
+		"(*reflect.rtype).Align":           ext۰NoEffect,
+		"(*reflect.rtype).AssignableTo":    ext۰NoEffect,
+		"(*reflect.rtype).Bits":            ext۰NoEffect,
+		"(*reflect.rtype).ChanDir":         ext۰NoEffect,
+		"(*reflect.rtype).ConvertibleTo":   ext۰NoEffect,
+		"(*reflect.rtype).Elem":            ext۰reflect۰rtype۰Elem,
+		"(*reflect.rtype).Field":           ext۰reflect۰rtype۰Field,
+		"(*reflect.rtype).FieldAlign":      ext۰NoEffect,
+		"(*reflect.rtype).FieldByIndex":    ext۰reflect۰rtype۰FieldByIndex,
+		"(*reflect.rtype).FieldByName":     ext۰reflect۰rtype۰FieldByName,
+		"(*reflect.rtype).FieldByNameFunc": ext۰reflect۰rtype۰FieldByNameFunc,
+		"(*reflect.rtype).Implements":      ext۰NoEffect,
+		"(*reflect.rtype).In":              ext۰reflect۰rtype۰In,
+		"(*reflect.rtype).IsVariadic":      ext۰NoEffect,
+		"(*reflect.rtype).Key":             ext۰reflect۰rtype۰Key,
+		"(*reflect.rtype).Kind":            ext۰NoEffect,
+		"(*reflect.rtype).Len":             ext۰NoEffect,
+		"(*reflect.rtype).Method":          ext۰reflect۰rtype۰Method,
+		"(*reflect.rtype).MethodByName":    ext۰reflect۰rtype۰MethodByName,
+		"(*reflect.rtype).Name":            ext۰NoEffect,
+		"(*reflect.rtype).NumField":        ext۰NoEffect,
+		"(*reflect.rtype).NumIn":           ext۰NoEffect,
+		"(*reflect.rtype).NumMethod":       ext۰NoEffect,
+		"(*reflect.rtype).NumOut":          ext۰NoEffect,
+		"(*reflect.rtype).Out":             ext۰reflect۰rtype۰Out,
+		"(*reflect.rtype).PkgPath":         ext۰NoEffect,
+		"(*reflect.rtype).Size":            ext۰NoEffect,
+		"(*reflect.rtype).String":          ext۰NoEffect,
+	} {
+		intrinsicsByName[name] = fn
+	}
+}
+
+// -------------------- (reflect.Value) --------------------
+
+func ext۰reflect۰Value۰Addr(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Bytes() Value ----------
+
+// result = v.Bytes()
+type rVBytesConstraint struct {
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVBytesConstraint) ptr() nodeid { return c.v }
+func (c *rVBytesConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVBytes.result")
+}
+func (c *rVBytesConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVBytesConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Bytes()", c.result, c.v)
+}
+
+func (c *rVBytesConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, slice, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		tSlice, ok := tDyn.Underlying().(*types.Slice)
+		if ok && types.Identical(tSlice.Elem(), types.Typ[types.Uint8]) {
+			if a.onlineCopy(c.result, slice) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Bytes(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVBytesConstraint{
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (Value).Call(in []Value) []Value ----------
+
+// result = v.Call(in)
+type rVCallConstraint struct {
+	cgn       *cgnode
+	targets   nodeid // (indirect)
+	v         nodeid // (ptr)
+	arg       nodeid // = in[*]
+	result    nodeid // (indirect)
+	dotdotdot bool   // interpret last arg as a "..." slice
+}
+
+func (c *rVCallConstraint) ptr() nodeid { return c.v }
+func (c *rVCallConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.targets), "rVCall.targets")
+	h.markIndirect(onodeid(c.result), "rVCall.result")
+}
+func (c *rVCallConstraint) renumber(mapping []nodeid) {
+	c.targets = mapping[c.targets]
+	c.v = mapping[c.v]
+	c.arg = mapping[c.arg]
+	c.result = mapping[c.result]
+}
+
+func (c *rVCallConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Call(n%d)", c.result, c.v, c.arg)
+}
+
+func (c *rVCallConstraint) solve(a *analysis, delta *nodeset) {
+	if c.targets == 0 {
+		panic("no targets")
+	}
+
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, fn, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		tSig, ok := tDyn.Underlying().(*types.Signature)
+		if !ok {
+			continue // not a function
+		}
+		if tSig.Recv() != nil {
+			panic(tSig) // TODO(adonovan): rethink when we implement Method()
+		}
+
+		// Add dynamic call target.
+		if a.onlineCopy(c.targets, fn) {
+			a.addWork(c.targets)
+			// TODO(adonovan): is 'else continue' a sound optimisation here?
+		}
+
+		// Allocate a P/R block.
+		tParams := tSig.Params()
+		tResults := tSig.Results()
+		params := a.addNodes(tParams, "rVCall.params")
+		results := a.addNodes(tResults, "rVCall.results")
+
+		// Make a dynamic call to 'fn'.
+		a.store(fn, params, 1, a.sizeof(tParams))
+		a.load(results, fn, 1+a.sizeof(tParams), a.sizeof(tResults))
+
+		// Populate P by type-asserting each actual arg (all merged in c.arg).
+		for i, n := 0, tParams.Len(); i < n; i++ {
+			T := tParams.At(i).Type()
+			a.typeAssert(T, params, c.arg, false)
+			params += nodeid(a.sizeof(T))
+		}
+
+		// Use R by tagging and copying each actual result to c.result.
+		for i, n := 0, tResults.Len(); i < n; i++ {
+			T := tResults.At(i).Type()
+			// Convert from an arbitrary type to a reflect.Value
+			// (like MakeInterface followed by reflect.ValueOf).
+			if isInterface(T) {
+				// (don't tag)
+				if a.onlineCopy(c.result, results) {
+					changed = true
+				}
+			} else {
+				obj := a.makeTagged(T, c.cgn, nil)
+				a.onlineCopyN(obj+1, results, a.sizeof(T))
+				if a.addLabel(c.result, obj) { // (true)
+					changed = true
+				}
+			}
+			results += nodeid(a.sizeof(T))
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+// Common code for direct (inlined) and indirect calls to (reflect.Value).Call.
+func reflectCallImpl(a *analysis, cgn *cgnode, site *callsite, recv, arg nodeid, dotdotdot bool) nodeid {
+	// Allocate []reflect.Value array for the result.
+	ret := a.nextNode()
+	a.addNodes(types.NewArray(a.reflectValueObj.Type(), 1), "rVCall.ret")
+	a.endObject(ret, cgn, nil)
+
+	// pts(targets) will be the set of possible call targets.
+	site.targets = a.addOneNode(tInvalid, "rvCall.targets", nil)
+
+	// All arguments are merged since they arrive in a slice.
+	argelts := a.addOneNode(a.reflectValueObj.Type(), "rVCall.args", nil)
+	a.load(argelts, arg, 1, 1) // slice elements
+
+	a.addConstraint(&rVCallConstraint{
+		cgn:       cgn,
+		targets:   site.targets,
+		v:         recv,
+		arg:       argelts,
+		result:    ret + 1, // results go into elements of ret
+		dotdotdot: dotdotdot,
+	})
+	return ret
+}
+
+func reflectCall(a *analysis, cgn *cgnode, dotdotdot bool) {
+	// This is the shared contour implementation of (reflect.Value).Call
+	// and CallSlice, as used by indirect calls (rare).
+	// Direct calls are inlined in gen.go, eliding the
+	// intermediate cgnode for Call.
+	site := new(callsite)
+	cgn.sites = append(cgn.sites, site)
+	recv := a.funcParams(cgn.obj)
+	arg := recv + 1
+	ret := reflectCallImpl(a, cgn, site, recv, arg, dotdotdot)
+	a.addressOf(cgn.fn.Signature.Results().At(0).Type(), a.funcResults(cgn.obj), ret)
+}
+
+func ext۰reflect۰Value۰Call(a *analysis, cgn *cgnode) {
+	reflectCall(a, cgn, false)
+}
+
+func ext۰reflect۰Value۰CallSlice(a *analysis, cgn *cgnode) {
+	// TODO(adonovan): implement.  Also, inline direct calls in gen.go too.
+	if false {
+		reflectCall(a, cgn, true)
+	}
+}
+
+func ext۰reflect۰Value۰Convert(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Elem() Value ----------
+
+// result = v.Elem()
+type rVElemConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVElemConstraint) ptr() nodeid { return c.v }
+func (c *rVElemConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVElem.result")
+}
+func (c *rVElemConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVElemConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Elem()", c.result, c.v)
+}
+
+func (c *rVElemConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, payload, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		switch t := tDyn.Underlying().(type) {
+		case *types.Interface:
+			if a.onlineCopy(c.result, payload) {
+				changed = true
+			}
+
+		case *types.Pointer:
+			obj := a.makeTagged(t.Elem(), c.cgn, nil)
+			a.load(obj+1, payload, 0, a.sizeof(t.Elem()))
+			if a.addLabel(c.result, obj) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Elem(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVElemConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰Value۰Field(a *analysis, cgn *cgnode)           {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByIndex(a *analysis, cgn *cgnode)    {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByName(a *analysis, cgn *cgnode)     {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByNameFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Index() Value ----------
+
+// result = v.Index()
+type rVIndexConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVIndexConstraint) ptr() nodeid { return c.v }
+func (c *rVIndexConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVIndex.result")
+}
+func (c *rVIndexConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVIndexConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Index()", c.result, c.v)
+}
+
+func (c *rVIndexConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, payload, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		var res nodeid
+		switch t := tDyn.Underlying().(type) {
+		case *types.Array:
+			res = a.makeTagged(t.Elem(), c.cgn, nil)
+			a.onlineCopyN(res+1, payload+1, a.sizeof(t.Elem()))
+
+		case *types.Slice:
+			res = a.makeTagged(t.Elem(), c.cgn, nil)
+			a.load(res+1, payload, 1, a.sizeof(t.Elem()))
+
+		case *types.Basic:
+			if t.Kind() == types.String {
+				res = a.makeTagged(types.Typ[types.Rune], c.cgn, nil)
+			}
+		}
+		if res != 0 && a.addLabel(c.result, res) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Index(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVIndexConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (Value).Interface() Value ----------
+
+// result = v.Interface()
+type rVInterfaceConstraint struct {
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVInterfaceConstraint) ptr() nodeid { return c.v }
+func (c *rVInterfaceConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVInterface.result")
+}
+func (c *rVInterfaceConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVInterfaceConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Interface()", c.result, c.v)
+}
+
+func (c *rVInterfaceConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, payload, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		if isInterface(tDyn) {
+			if a.onlineCopy(c.result, payload) {
+				a.addWork(c.result)
+			}
+		} else {
+			if a.addLabel(c.result, vObj) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Interface(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVInterfaceConstraint{
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (Value).MapIndex(Value) Value ----------
+
+// result = v.MapIndex(_)
+type rVMapIndexConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVMapIndexConstraint) ptr() nodeid { return c.v }
+func (c *rVMapIndexConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVMapIndex.result")
+}
+func (c *rVMapIndexConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVMapIndexConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.MapIndex(_)", c.result, c.v)
+}
+
+func (c *rVMapIndexConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, m, indirect := a.taggedValue(vObj)
+		tMap, _ := tDyn.Underlying().(*types.Map)
+		if tMap == nil {
+			continue // not a map
+		}
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		obj := a.makeTagged(tMap.Elem(), c.cgn, nil)
+		a.load(obj+1, m, a.sizeof(tMap.Key()), a.sizeof(tMap.Elem()))
+		if a.addLabel(c.result, obj) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰MapIndex(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVMapIndexConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (Value).MapKeys() []Value ----------
+
+// result = v.MapKeys()
+type rVMapKeysConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVMapKeysConstraint) ptr() nodeid { return c.v }
+func (c *rVMapKeysConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVMapKeys.result")
+}
+func (c *rVMapKeysConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVMapKeysConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.MapKeys()", c.result, c.v)
+}
+
+func (c *rVMapKeysConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, m, indirect := a.taggedValue(vObj)
+		tMap, _ := tDyn.Underlying().(*types.Map)
+		if tMap == nil {
+			continue // not a map
+		}
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		kObj := a.makeTagged(tMap.Key(), c.cgn, nil)
+		a.load(kObj+1, m, 0, a.sizeof(tMap.Key()))
+		if a.addLabel(c.result, kObj) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰MapKeys(a *analysis, cgn *cgnode) {
+	// Allocate an array for the result.
+	obj := a.nextNode()
+	T := types.NewSlice(a.reflectValueObj.Type())
+	a.addNodes(sliceToArray(T), "reflect.MapKeys result")
+	a.endObject(obj, cgn, nil)
+	a.addressOf(T, a.funcResults(cgn.obj), obj)
+
+	a.addConstraint(&rVMapKeysConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: obj + 1, // result is stored in array elems
+	})
+}
+
+func ext۰reflect۰Value۰Method(a *analysis, cgn *cgnode)       {} // TODO(adonovan)
+func ext۰reflect۰Value۰MethodByName(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Recv(Value) Value ----------
+
+// result, _ = v.Recv()
+type rVRecvConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVRecvConstraint) ptr() nodeid { return c.v }
+func (c *rVRecvConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVRecv.result")
+}
+func (c *rVRecvConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVRecvConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Recv()", c.result, c.v)
+}
+
+func (c *rVRecvConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, ch, indirect := a.taggedValue(vObj)
+		tChan, _ := tDyn.Underlying().(*types.Chan)
+		if tChan == nil {
+			continue // not a channel
+		}
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		tElem := tChan.Elem()
+		elemObj := a.makeTagged(tElem, c.cgn, nil)
+		a.load(elemObj+1, ch, 0, a.sizeof(tElem))
+		if a.addLabel(c.result, elemObj) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Recv(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVRecvConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (Value).Send(Value) ----------
+
+// v.Send(x)
+type rVSendConstraint struct {
+	cgn *cgnode
+	v   nodeid // (ptr)
+	x   nodeid
+}
+
+func (c *rVSendConstraint) ptr() nodeid   { return c.v }
+func (c *rVSendConstraint) presolve(*hvn) {}
+func (c *rVSendConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.x = mapping[c.x]
+}
+
+func (c *rVSendConstraint) String() string {
+	return fmt.Sprintf("reflect n%d.Send(n%d)", c.v, c.x)
+}
+
+func (c *rVSendConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, ch, indirect := a.taggedValue(vObj)
+		tChan, _ := tDyn.Underlying().(*types.Chan)
+		if tChan == nil {
+			continue // not a channel
+		}
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		// Extract x's payload to xtmp, then store to channel.
+		tElem := tChan.Elem()
+		xtmp := a.addNodes(tElem, "Send.xtmp")
+		a.typeAssert(tElem, xtmp, c.x, false)
+		a.store(ch, xtmp, 0, a.sizeof(tElem))
+	}
+}
+
+func ext۰reflect۰Value۰Send(a *analysis, cgn *cgnode) {
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&rVSendConstraint{
+		cgn: cgn,
+		v:   params,
+		x:   params + 1,
+	})
+}
+
+func ext۰reflect۰Value۰Set(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).SetBytes(x []byte) ----------
+
+// v.SetBytes(x)
+type rVSetBytesConstraint struct {
+	cgn *cgnode
+	v   nodeid // (ptr)
+	x   nodeid
+}
+
+func (c *rVSetBytesConstraint) ptr() nodeid   { return c.v }
+func (c *rVSetBytesConstraint) presolve(*hvn) {}
+func (c *rVSetBytesConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.x = mapping[c.x]
+}
+
+func (c *rVSetBytesConstraint) String() string {
+	return fmt.Sprintf("reflect n%d.SetBytes(n%d)", c.v, c.x)
+}
+
+func (c *rVSetBytesConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, slice, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		tSlice, ok := tDyn.Underlying().(*types.Slice)
+		if ok && types.Identical(tSlice.Elem(), types.Typ[types.Uint8]) {
+			if a.onlineCopy(slice, c.x) {
+				a.addWork(slice)
+			}
+		}
+	}
+}
+
+func ext۰reflect۰Value۰SetBytes(a *analysis, cgn *cgnode) {
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&rVSetBytesConstraint{
+		cgn: cgn,
+		v:   params,
+		x:   params + 1,
+	})
+}
+
+// ---------- func (Value).SetMapIndex(k Value, v Value) ----------
+
+// v.SetMapIndex(key, val)
+type rVSetMapIndexConstraint struct {
+	cgn *cgnode
+	v   nodeid // (ptr)
+	key nodeid
+	val nodeid
+}
+
+func (c *rVSetMapIndexConstraint) ptr() nodeid   { return c.v }
+func (c *rVSetMapIndexConstraint) presolve(*hvn) {}
+func (c *rVSetMapIndexConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.key = mapping[c.key]
+	c.val = mapping[c.val]
+}
+
+func (c *rVSetMapIndexConstraint) String() string {
+	return fmt.Sprintf("reflect n%d.SetMapIndex(n%d, n%d)", c.v, c.key, c.val)
+}
+
+func (c *rVSetMapIndexConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, m, indirect := a.taggedValue(vObj)
+		tMap, _ := tDyn.Underlying().(*types.Map)
+		if tMap == nil {
+			continue // not a map
+		}
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		keysize := a.sizeof(tMap.Key())
+
+		// Extract key's payload to keytmp, then store to map key.
+		keytmp := a.addNodes(tMap.Key(), "SetMapIndex.keytmp")
+		a.typeAssert(tMap.Key(), keytmp, c.key, false)
+		a.store(m, keytmp, 0, keysize)
+
+		// Extract val's payload to vtmp, then store to map value.
+		valtmp := a.addNodes(tMap.Elem(), "SetMapIndex.valtmp")
+		a.typeAssert(tMap.Elem(), valtmp, c.val, false)
+		a.store(m, valtmp, keysize, a.sizeof(tMap.Elem()))
+	}
+}
+
+func ext۰reflect۰Value۰SetMapIndex(a *analysis, cgn *cgnode) {
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&rVSetMapIndexConstraint{
+		cgn: cgn,
+		v:   params,
+		key: params + 1,
+		val: params + 2,
+	})
+}
+
+func ext۰reflect۰Value۰SetPointer(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Slice(v Value, i, j int) Value ----------
+
+// result = v.Slice(_, _)
+type rVSliceConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rVSliceConstraint) ptr() nodeid { return c.v }
+func (c *rVSliceConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rVSlice.result")
+}
+func (c *rVSliceConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *rVSliceConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect n%d.Slice(_, _)", c.result, c.v)
+}
+
+func (c *rVSliceConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, payload, indirect := a.taggedValue(vObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		var res nodeid
+		switch t := tDyn.Underlying().(type) {
+		case *types.Pointer:
+			if tArr, ok := t.Elem().Underlying().(*types.Array); ok {
+				// pointer to array
+				res = a.makeTagged(types.NewSlice(tArr.Elem()), c.cgn, nil)
+				if a.onlineCopy(res+1, payload) {
+					a.addWork(res + 1)
+				}
+			}
+
+		case *types.Array:
+			// TODO(adonovan): implement addressable
+			// arrays when we do indirect tagged objects.
+
+		case *types.Slice:
+			res = vObj
+
+		case *types.Basic:
+			if t == types.Typ[types.String] {
+				res = vObj
+			}
+		}
+
+		if res != 0 && a.addLabel(c.result, res) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Value۰Slice(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rVSliceConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// -------------------- Standalone reflect functions --------------------
+
+func ext۰reflect۰Append(a *analysis, cgn *cgnode)      {} // TODO(adonovan)
+func ext۰reflect۰AppendSlice(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Copy(a *analysis, cgn *cgnode)        {} // TODO(adonovan)
+
+// ---------- func ChanOf(ChanDir, Type) Type ----------
+
+// result = ChanOf(dir, t)
+type reflectChanOfConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+	dirs   []types.ChanDir
+}
+
+func (c *reflectChanOfConstraint) ptr() nodeid { return c.t }
+func (c *reflectChanOfConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectChanOf.result")
+}
+func (c *reflectChanOfConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectChanOfConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.ChanOf(n%d)", c.result, c.t)
+}
+
+func (c *reflectChanOfConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.rtypeTaggedValue(tObj)
+
+		if typeTooHigh(T) {
+			continue
+		}
+
+		for _, dir := range c.dirs {
+			if a.addLabel(c.result, a.makeRtype(types.NewChan(dir, T))) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+// dirMap maps reflect.ChanDir to the set of channel types generated by ChanOf.
+var dirMap = [...][]types.ChanDir{
+	0:               {types.SendOnly, types.RecvOnly, types.SendRecv}, // unknown
+	reflect.RecvDir: {types.RecvOnly},
+	reflect.SendDir: {types.SendOnly},
+	reflect.BothDir: {types.SendRecv},
+}
+
+func ext۰reflect۰ChanOf(a *analysis, cgn *cgnode) {
+	// If we have access to the callsite,
+	// and the channel argument is a constant (as is usual),
+	// only generate the requested direction.
+	var dir reflect.ChanDir // unknown
+	if site := cgn.callersite; site != nil {
+		if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+			v, _ := exact.Int64Val(c.Value)
+			if 0 <= v && v <= int64(reflect.BothDir) {
+				dir = reflect.ChanDir(v)
+			}
+		}
+	}
+
+	params := a.funcParams(cgn.obj)
+	a.addConstraint(&reflectChanOfConstraint{
+		cgn:    cgn,
+		t:      params + 1,
+		result: a.funcResults(cgn.obj),
+		dirs:   dirMap[dir],
+	})
+}
+
+// ---------- func Indirect(v Value) Value ----------
+
+// result = Indirect(v)
+type reflectIndirectConstraint struct {
+	cgn    *cgnode
+	v      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectIndirectConstraint) ptr() nodeid { return c.v }
+func (c *reflectIndirectConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectIndirect.result")
+}
+func (c *reflectIndirectConstraint) renumber(mapping []nodeid) {
+	c.v = mapping[c.v]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectIndirectConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.Indirect(n%d)", c.result, c.v)
+}
+
+func (c *reflectIndirectConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		vObj := nodeid(x)
+		tDyn, _, _ := a.taggedValue(vObj)
+		var res nodeid
+		if tPtr, ok := tDyn.Underlying().(*types.Pointer); ok {
+			// load the payload of the pointer's tagged object
+			// into a new tagged object
+			res = a.makeTagged(tPtr.Elem(), c.cgn, nil)
+			a.load(res+1, vObj+1, 0, a.sizeof(tPtr.Elem()))
+		} else {
+			res = vObj
+		}
+
+		if a.addLabel(c.result, res) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Indirect(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectIndirectConstraint{
+		cgn:    cgn,
+		v:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func MakeChan(Type) Value ----------
+
+// result = MakeChan(typ)
+type reflectMakeChanConstraint struct {
+	cgn    *cgnode
+	typ    nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectMakeChanConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeChanConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectMakeChan.result")
+}
+func (c *reflectMakeChanConstraint) renumber(mapping []nodeid) {
+	c.typ = mapping[c.typ]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectMakeChanConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.MakeChan(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeChanConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		typObj := nodeid(x)
+		T := a.rtypeTaggedValue(typObj)
+		tChan, ok := T.Underlying().(*types.Chan)
+		if !ok || tChan.Dir() != types.SendRecv {
+			continue // not a bidirectional channel type
+		}
+
+		obj := a.nextNode()
+		a.addNodes(tChan.Elem(), "reflect.MakeChan.value")
+		a.endObject(obj, c.cgn, nil)
+
+		// put its address in a new T-tagged object
+		id := a.makeTagged(T, c.cgn, nil)
+		a.addLabel(id+1, obj)
+
+		// flow the T-tagged object to the result
+		if a.addLabel(c.result, id) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰MakeChan(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectMakeChanConstraint{
+		cgn:    cgn,
+		typ:    a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰MakeFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func MakeMap(Type) Value ----------
+
+// result = MakeMap(typ)
+type reflectMakeMapConstraint struct {
+	cgn    *cgnode
+	typ    nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectMakeMapConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeMapConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectMakeMap.result")
+}
+func (c *reflectMakeMapConstraint) renumber(mapping []nodeid) {
+	c.typ = mapping[c.typ]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectMakeMapConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.MakeMap(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeMapConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		typObj := nodeid(x)
+		T := a.rtypeTaggedValue(typObj)
+		tMap, ok := T.Underlying().(*types.Map)
+		if !ok {
+			continue // not a map type
+		}
+
+		mapObj := a.nextNode()
+		a.addNodes(tMap.Key(), "reflect.MakeMap.key")
+		a.addNodes(tMap.Elem(), "reflect.MakeMap.value")
+		a.endObject(mapObj, c.cgn, nil)
+
+		// put its address in a new T-tagged object
+		id := a.makeTagged(T, c.cgn, nil)
+		a.addLabel(id+1, mapObj)
+
+		// flow the T-tagged object to the result
+		if a.addLabel(c.result, id) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰MakeMap(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectMakeMapConstraint{
+		cgn:    cgn,
+		typ:    a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func MakeSlice(Type) Value ----------
+
+// result = MakeSlice(typ)
+type reflectMakeSliceConstraint struct {
+	cgn    *cgnode
+	typ    nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectMakeSliceConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeSliceConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectMakeSlice.result")
+}
+func (c *reflectMakeSliceConstraint) renumber(mapping []nodeid) {
+	c.typ = mapping[c.typ]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectMakeSliceConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.MakeSlice(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeSliceConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		typObj := nodeid(x)
+		T := a.rtypeTaggedValue(typObj)
+		if _, ok := T.Underlying().(*types.Slice); !ok {
+			continue // not a slice type
+		}
+
+		obj := a.nextNode()
+		a.addNodes(sliceToArray(T), "reflect.MakeSlice")
+		a.endObject(obj, c.cgn, nil)
+
+		// put its address in a new T-tagged object
+		id := a.makeTagged(T, c.cgn, nil)
+		a.addLabel(id+1, obj)
+
+		// flow the T-tagged object to the result
+		if a.addLabel(c.result, id) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰MakeSlice(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectMakeSliceConstraint{
+		cgn:    cgn,
+		typ:    a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰MapOf(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func New(Type) Value ----------
+
+// result = New(typ)
+type reflectNewConstraint struct {
+	cgn    *cgnode
+	typ    nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectNewConstraint) ptr() nodeid { return c.typ }
+func (c *reflectNewConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectNew.result")
+}
+func (c *reflectNewConstraint) renumber(mapping []nodeid) {
+	c.typ = mapping[c.typ]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectNewConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.New(n%d)", c.result, c.typ)
+}
+
+func (c *reflectNewConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		typObj := nodeid(x)
+		T := a.rtypeTaggedValue(typObj)
+
+		// allocate new T object
+		newObj := a.nextNode()
+		a.addNodes(T, "reflect.New")
+		a.endObject(newObj, c.cgn, nil)
+
+		// put its address in a new *T-tagged object
+		id := a.makeTagged(types.NewPointer(T), c.cgn, nil)
+		a.addLabel(id+1, newObj)
+
+		// flow the pointer to the result
+		if a.addLabel(c.result, id) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰New(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectNewConstraint{
+		cgn:    cgn,
+		typ:    a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰NewAt(a *analysis, cgn *cgnode) {
+	ext۰reflect۰New(a, cgn)
+
+	// TODO(adonovan): also report dynamic calls to unsound intrinsics.
+	if site := cgn.callersite; site != nil {
+		a.warnf(site.pos(), "unsound: %s contains a reflect.NewAt() call", site.instr.Parent())
+	}
+}
+
+// ---------- func PtrTo(Type) Type ----------
+
+// result = PtrTo(t)
+type reflectPtrToConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectPtrToConstraint) ptr() nodeid { return c.t }
+func (c *reflectPtrToConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectPtrTo.result")
+}
+func (c *reflectPtrToConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectPtrToConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.PtrTo(n%d)", c.result, c.t)
+}
+
+func (c *reflectPtrToConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.rtypeTaggedValue(tObj)
+
+		if typeTooHigh(T) {
+			continue
+		}
+
+		if a.addLabel(c.result, a.makeRtype(types.NewPointer(T))) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰PtrTo(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectPtrToConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰Select(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func SliceOf(Type) Type ----------
+
+// result = SliceOf(t)
+type reflectSliceOfConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectSliceOfConstraint) ptr() nodeid { return c.t }
+func (c *reflectSliceOfConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectSliceOf.result")
+}
+func (c *reflectSliceOfConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectSliceOfConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.SliceOf(n%d)", c.result, c.t)
+}
+
+func (c *reflectSliceOfConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.rtypeTaggedValue(tObj)
+
+		if typeTooHigh(T) {
+			continue
+		}
+
+		if a.addLabel(c.result, a.makeRtype(types.NewSlice(T))) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰SliceOf(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectSliceOfConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func TypeOf(v Value) Type ----------
+
+// result = TypeOf(i)
+type reflectTypeOfConstraint struct {
+	cgn    *cgnode
+	i      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectTypeOfConstraint) ptr() nodeid { return c.i }
+func (c *reflectTypeOfConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectTypeOf.result")
+}
+func (c *reflectTypeOfConstraint) renumber(mapping []nodeid) {
+	c.i = mapping[c.i]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectTypeOfConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.TypeOf(n%d)", c.result, c.i)
+}
+
+func (c *reflectTypeOfConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		iObj := nodeid(x)
+		tDyn, _, _ := a.taggedValue(iObj)
+		if a.addLabel(c.result, a.makeRtype(tDyn)) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰TypeOf(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectTypeOfConstraint{
+		cgn:    cgn,
+		i:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func ValueOf(interface{}) Value ----------
+
+func ext۰reflect۰ValueOf(a *analysis, cgn *cgnode) {
+	// TODO(adonovan): when we start creating indirect tagged
+	// objects, we'll need to handle them specially here since
+	// they must never appear in the PTS of an interface{}.
+	a.copy(a.funcResults(cgn.obj), a.funcParams(cgn.obj), 1)
+}
+
+// ---------- func Zero(Type) Value ----------
+
+// result = Zero(typ)
+type reflectZeroConstraint struct {
+	cgn    *cgnode
+	typ    nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *reflectZeroConstraint) ptr() nodeid { return c.typ }
+func (c *reflectZeroConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "reflectZero.result")
+}
+func (c *reflectZeroConstraint) renumber(mapping []nodeid) {
+	c.typ = mapping[c.typ]
+	c.result = mapping[c.result]
+}
+
+func (c *reflectZeroConstraint) String() string {
+	return fmt.Sprintf("n%d = reflect.Zero(n%d)", c.result, c.typ)
+}
+
+func (c *reflectZeroConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		typObj := nodeid(x)
+		T := a.rtypeTaggedValue(typObj)
+
+		// TODO(adonovan): if T is an interface type, we need
+		// to create an indirect tagged object containing
+		// new(T).  To avoid updates of such shared values,
+		// we'll need another flag on indirect tagged objects
+		// that marks whether they are addressable or
+		// readonly, just like the reflect package does.
+
+		// memoize using a.reflectZeros[T]
+		var id nodeid
+		if z := a.reflectZeros.At(T); false && z != nil {
+			id = z.(nodeid)
+		} else {
+			id = a.makeTagged(T, c.cgn, nil)
+			a.reflectZeros.Set(T, id)
+		}
+		if a.addLabel(c.result, id) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰Zero(a *analysis, cgn *cgnode) {
+	a.addConstraint(&reflectZeroConstraint{
+		cgn:    cgn,
+		typ:    a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// -------------------- (*reflect.rtype) methods --------------------
+
+// ---------- func (*rtype) Elem() Type ----------
+
+// result = Elem(t)
+type rtypeElemConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rtypeElemConstraint) ptr() nodeid { return c.t }
+func (c *rtypeElemConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rtypeElem.result")
+}
+func (c *rtypeElemConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *rtypeElemConstraint) String() string {
+	return fmt.Sprintf("n%d = (*reflect.rtype).Elem(n%d)", c.result, c.t)
+}
+
+func (c *rtypeElemConstraint) solve(a *analysis, delta *nodeset) {
+	// Implemented by *types.{Map,Chan,Array,Slice,Pointer}.
+	type hasElem interface {
+		Elem() types.Type
+	}
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.nodes[tObj].obj.data.(types.Type)
+		if tHasElem, ok := T.Underlying().(hasElem); ok {
+			if a.addLabel(c.result, a.makeRtype(tHasElem.Elem())) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰rtype۰Elem(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rtypeElemConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (*rtype) Field(int) StructField ----------
+// ---------- func (*rtype) FieldByName(string) (StructField, bool) ----------
+
+// result = FieldByName(t, name)
+// result = Field(t, _)
+type rtypeFieldByNameConstraint struct {
+	cgn    *cgnode
+	name   string // name of field; "" for unknown
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rtypeFieldByNameConstraint) ptr() nodeid { return c.t }
+func (c *rtypeFieldByNameConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result+3), "rtypeFieldByName.result.Type")
+}
+func (c *rtypeFieldByNameConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *rtypeFieldByNameConstraint) String() string {
+	return fmt.Sprintf("n%d = (*reflect.rtype).FieldByName(n%d, %q)", c.result, c.t, c.name)
+}
+
+func (c *rtypeFieldByNameConstraint) solve(a *analysis, delta *nodeset) {
+	// type StructField struct {
+	// 0	__identity__
+	// 1	Name      string
+	// 2	PkgPath   string
+	// 3	Type      Type
+	// 4	Tag       StructTag
+	// 5	Offset    uintptr
+	// 6	Index     []int
+	// 7	Anonymous bool
+	// }
+
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.nodes[tObj].obj.data.(types.Type)
+		tStruct, ok := T.Underlying().(*types.Struct)
+		if !ok {
+			continue // not a struct type
+		}
+
+		n := tStruct.NumFields()
+		for i := 0; i < n; i++ {
+			f := tStruct.Field(i)
+			if c.name == "" || c.name == f.Name() {
+
+				// a.offsetOf(Type) is 3.
+				if id := c.result + 3; a.addLabel(id, a.makeRtype(f.Type())) {
+					a.addWork(id)
+				}
+				// TODO(adonovan): StructField.Index should be non-nil.
+			}
+		}
+	}
+}
+
+func ext۰reflect۰rtype۰FieldByName(a *analysis, cgn *cgnode) {
+	// If we have access to the callsite,
+	// and the argument is a string constant,
+	// return only that field.
+	var name string
+	if site := cgn.callersite; site != nil {
+		if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+			name = exact.StringVal(c.Value)
+		}
+	}
+
+	a.addConstraint(&rtypeFieldByNameConstraint{
+		cgn:    cgn,
+		name:   name,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰rtype۰Field(a *analysis, cgn *cgnode) {
+	// No-one ever calls Field with a constant argument,
+	// so we don't specialize that case.
+	a.addConstraint(&rtypeFieldByNameConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰rtype۰FieldByIndex(a *analysis, cgn *cgnode)    {} // TODO(adonovan)
+func ext۰reflect۰rtype۰FieldByNameFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (*rtype) In/Out(i int) Type ----------
+
+// result = In/Out(t, i)
+type rtypeInOutConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+	out    bool
+	i      int // -ve if not a constant
+}
+
+func (c *rtypeInOutConstraint) ptr() nodeid { return c.t }
+func (c *rtypeInOutConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rtypeInOut.result")
+}
+func (c *rtypeInOutConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *rtypeInOutConstraint) String() string {
+	return fmt.Sprintf("n%d = (*reflect.rtype).InOut(n%d, %d)", c.result, c.t, c.i)
+}
+
+func (c *rtypeInOutConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.nodes[tObj].obj.data.(types.Type)
+		sig, ok := T.Underlying().(*types.Signature)
+		if !ok {
+			continue // not a func type
+		}
+
+		tuple := sig.Params()
+		if c.out {
+			tuple = sig.Results()
+		}
+		for i, n := 0, tuple.Len(); i < n; i++ {
+			if c.i < 0 || c.i == i {
+				if a.addLabel(c.result, a.makeRtype(tuple.At(i).Type())) {
+					changed = true
+				}
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰rtype۰InOut(a *analysis, cgn *cgnode, out bool) {
+	// If we have access to the callsite,
+	// and the argument is an int constant,
+	// return only that parameter.
+	index := -1
+	if site := cgn.callersite; site != nil {
+		if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+			v, _ := exact.Int64Val(c.Value)
+			index = int(v)
+		}
+	}
+	a.addConstraint(&rtypeInOutConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+		out:    out,
+		i:      index,
+	})
+}
+
+func ext۰reflect۰rtype۰In(a *analysis, cgn *cgnode) {
+	ext۰reflect۰rtype۰InOut(a, cgn, false)
+}
+
+func ext۰reflect۰rtype۰Out(a *analysis, cgn *cgnode) {
+	ext۰reflect۰rtype۰InOut(a, cgn, true)
+}
+
+// ---------- func (*rtype) Key() Type ----------
+
+// result = Key(t)
+type rtypeKeyConstraint struct {
+	cgn    *cgnode
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rtypeKeyConstraint) ptr() nodeid { return c.t }
+func (c *rtypeKeyConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result), "rtypeKey.result")
+}
+func (c *rtypeKeyConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *rtypeKeyConstraint) String() string {
+	return fmt.Sprintf("n%d = (*reflect.rtype).Key(n%d)", c.result, c.t)
+}
+
+func (c *rtypeKeyConstraint) solve(a *analysis, delta *nodeset) {
+	changed := false
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.nodes[tObj].obj.data.(types.Type)
+		if tMap, ok := T.Underlying().(*types.Map); ok {
+			if a.addLabel(c.result, a.makeRtype(tMap.Key())) {
+				changed = true
+			}
+		}
+	}
+	if changed {
+		a.addWork(c.result)
+	}
+}
+
+func ext۰reflect۰rtype۰Key(a *analysis, cgn *cgnode) {
+	a.addConstraint(&rtypeKeyConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// ---------- func (*rtype) Method(int) (Method, bool) ----------
+// ---------- func (*rtype) MethodByName(string) (Method, bool) ----------
+
+// result = MethodByName(t, name)
+// result = Method(t, _)
+type rtypeMethodByNameConstraint struct {
+	cgn    *cgnode
+	name   string // name of method; "" for unknown
+	t      nodeid // (ptr)
+	result nodeid // (indirect)
+}
+
+func (c *rtypeMethodByNameConstraint) ptr() nodeid { return c.t }
+func (c *rtypeMethodByNameConstraint) presolve(h *hvn) {
+	h.markIndirect(onodeid(c.result+3), "rtypeMethodByName.result.Type")
+	h.markIndirect(onodeid(c.result+4), "rtypeMethodByName.result.Func")
+}
+func (c *rtypeMethodByNameConstraint) renumber(mapping []nodeid) {
+	c.t = mapping[c.t]
+	c.result = mapping[c.result]
+}
+
+func (c *rtypeMethodByNameConstraint) String() string {
+	return fmt.Sprintf("n%d = (*reflect.rtype).MethodByName(n%d, %q)", c.result, c.t, c.name)
+}
+
+// changeRecv returns sig with Recv prepended to Params().
+func changeRecv(sig *types.Signature) *types.Signature {
+	params := sig.Params()
+	n := params.Len()
+	p2 := make([]*types.Var, n+1)
+	p2[0] = sig.Recv()
+	for i := 0; i < n; i++ {
+		p2[i+1] = params.At(i)
+	}
+	return types.NewSignature(nil, types.NewTuple(p2...), sig.Results(), sig.Variadic())
+}
+
+func (c *rtypeMethodByNameConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		tObj := nodeid(x)
+		T := a.nodes[tObj].obj.data.(types.Type)
+
+		isIface := isInterface(T)
+
+		// We don't use Lookup(c.name) when c.name != "" to avoid
+		// ambiguity: >1 unexported methods could match.
+		mset := a.prog.MethodSets.MethodSet(T)
+		for i, n := 0, mset.Len(); i < n; i++ {
+			sel := mset.At(i)
+			if c.name == "" || c.name == sel.Obj().Name() {
+				// type Method struct {
+				// 0     __identity__
+				// 1	Name    string
+				// 2	PkgPath string
+				// 3	Type    Type
+				// 4	Func    Value
+				// 5	Index   int
+				// }
+
+				var sig *types.Signature
+				var fn *ssa.Function
+				if isIface {
+					sig = sel.Type().(*types.Signature)
+				} else {
+					fn = a.prog.MethodValue(sel)
+					// move receiver to params[0]
+					sig = changeRecv(fn.Signature)
+				}
+
+				// a.offsetOf(Type) is 3.
+				if id := c.result + 3; a.addLabel(id, a.makeRtype(sig)) {
+					a.addWork(id)
+				}
+				if fn != nil {
+					// a.offsetOf(Func) is 4.
+					if id := c.result + 4; a.addLabel(id, a.objectNode(nil, fn)) {
+						a.addWork(id)
+					}
+				}
+			}
+		}
+	}
+}
+
+func ext۰reflect۰rtype۰MethodByName(a *analysis, cgn *cgnode) {
+	// If we have access to the callsite,
+	// and the argument is a string constant,
+	// return only that method.
+	var name string
+	if site := cgn.callersite; site != nil {
+		if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+			name = exact.StringVal(c.Value)
+		}
+	}
+
+	a.addConstraint(&rtypeMethodByNameConstraint{
+		cgn:    cgn,
+		name:   name,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+func ext۰reflect۰rtype۰Method(a *analysis, cgn *cgnode) {
+	// No-one ever calls Method with a constant argument,
+	// so we don't specialize that case.
+	a.addConstraint(&rtypeMethodByNameConstraint{
+		cgn:    cgn,
+		t:      a.funcParams(cgn.obj),
+		result: a.funcResults(cgn.obj),
+	})
+}
+
+// typeHeight returns the "height" of the type, which is roughly
+// speaking the number of chan, map, pointer and slice type constructors
+// at the root of T; these are the four type kinds that can be created
+// via reflection.  Chan and map constructors are counted as double the
+// height of slice and pointer constructors since they are less often
+// deeply nested.
+//
+// The solver rules for type constructors must somehow bound the set of
+// types they create to ensure termination of the algorithm in cases
+// where the output of a type constructor flows to its input, e.g.
+//
+// 	func f(t reflect.Type) {
+// 		f(reflect.PtrTo(t))
+// 	}
+//
+// It does this by limiting the type height to k, but this still leaves
+// a potentially exponential (4^k) number of of types that may be
+// enumerated in pathological cases.
+//
+func typeHeight(T types.Type) int {
+	switch T := T.(type) {
+	case *types.Chan:
+		return 2 + typeHeight(T.Elem())
+	case *types.Map:
+		k := typeHeight(T.Key())
+		v := typeHeight(T.Elem())
+		if v > k {
+			k = v // max(k, v)
+		}
+		return 2 + k
+	case *types.Slice:
+		return 1 + typeHeight(T.Elem())
+	case *types.Pointer:
+		return 1 + typeHeight(T.Elem())
+	}
+	return 0
+}
+
+func typeTooHigh(T types.Type) bool {
+	return typeHeight(T) > 3
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/solve.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/solve.go
new file mode 100644
index 00000000..0fdd098b
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/solve.go
@@ -0,0 +1,370 @@
+// 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 pointer
+
+// This file defines a naive Andersen-style solver for the inclusion
+// constraint system.
+
+import (
+	"fmt"
+	"go/types"
+)
+
+type solverState struct {
+	complex []constraint // complex constraints attached to this node
+	copyTo  nodeset      // simple copy constraint edges
+	pts     nodeset      // points-to set of this node
+	prevPTS nodeset      // pts(n) in previous iteration (for difference propagation)
+}
+
+func (a *analysis) solve() {
+	start("Solving")
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\n\n==== Solving constraints\n\n")
+	}
+
+	// Solver main loop.
+	var delta nodeset
+	for {
+		// Add new constraints to the graph:
+		// static constraints from SSA on round 1,
+		// dynamic constraints from reflection thereafter.
+		a.processNewConstraints()
+
+		var x int
+		if !a.work.TakeMin(&x) {
+			break // empty
+		}
+		id := nodeid(x)
+		if a.log != nil {
+			fmt.Fprintf(a.log, "\tnode n%d\n", id)
+		}
+
+		n := a.nodes[id]
+
+		// Difference propagation.
+		delta.Difference(&n.solve.pts.Sparse, &n.solve.prevPTS.Sparse)
+		if delta.IsEmpty() {
+			continue
+		}
+		if a.log != nil {
+			fmt.Fprintf(a.log, "\t\tpts(n%d : %s) = %s + %s\n",
+				id, n.typ, &delta, &n.solve.prevPTS)
+		}
+		n.solve.prevPTS.Copy(&n.solve.pts.Sparse)
+
+		// Apply all resolution rules attached to n.
+		a.solveConstraints(n, &delta)
+
+		if a.log != nil {
+			fmt.Fprintf(a.log, "\t\tpts(n%d) = %s\n", id, &n.solve.pts)
+		}
+	}
+
+	if !a.nodes[0].solve.pts.IsEmpty() {
+		panic(fmt.Sprintf("pts(0) is nonempty: %s", &a.nodes[0].solve.pts))
+	}
+
+	// Release working state (but keep final PTS).
+	for _, n := range a.nodes {
+		n.solve.complex = nil
+		n.solve.copyTo.Clear()
+		n.solve.prevPTS.Clear()
+	}
+
+	if a.log != nil {
+		fmt.Fprintf(a.log, "Solver done\n")
+
+		// Dump solution.
+		for i, n := range a.nodes {
+			if !n.solve.pts.IsEmpty() {
+				fmt.Fprintf(a.log, "pts(n%d) = %s : %s\n", i, &n.solve.pts, n.typ)
+			}
+		}
+	}
+	stop("Solving")
+}
+
+// processNewConstraints takes the new constraints from a.constraints
+// and adds them to the graph, ensuring
+// that new constraints are applied to pre-existing labels and
+// that pre-existing constraints are applied to new labels.
+//
+func (a *analysis) processNewConstraints() {
+	// Take the slice of new constraints.
+	// (May grow during call to solveConstraints.)
+	constraints := a.constraints
+	a.constraints = nil
+
+	// Initialize points-to sets from addr-of (base) constraints.
+	for _, c := range constraints {
+		if c, ok := c.(*addrConstraint); ok {
+			dst := a.nodes[c.dst]
+			dst.solve.pts.add(c.src)
+
+			// Populate the worklist with nodes that point to
+			// something initially (due to addrConstraints) and
+			// have other constraints attached.
+			// (A no-op in round 1.)
+			if !dst.solve.copyTo.IsEmpty() || len(dst.solve.complex) > 0 {
+				a.addWork(c.dst)
+			}
+		}
+	}
+
+	// Attach simple (copy) and complex constraints to nodes.
+	var stale nodeset
+	for _, c := range constraints {
+		var id nodeid
+		switch c := c.(type) {
+		case *addrConstraint:
+			// base constraints handled in previous loop
+			continue
+		case *copyConstraint:
+			// simple (copy) constraint
+			id = c.src
+			a.nodes[id].solve.copyTo.add(c.dst)
+		default:
+			// complex constraint
+			id = c.ptr()
+			solve := a.nodes[id].solve
+			solve.complex = append(solve.complex, c)
+		}
+
+		if n := a.nodes[id]; !n.solve.pts.IsEmpty() {
+			if !n.solve.prevPTS.IsEmpty() {
+				stale.add(id)
+			}
+			a.addWork(id)
+		}
+	}
+	// Apply new constraints to pre-existing PTS labels.
+	var space [50]int
+	for _, id := range stale.AppendTo(space[:0]) {
+		n := a.nodes[nodeid(id)]
+		a.solveConstraints(n, &n.solve.prevPTS)
+	}
+}
+
+// solveConstraints applies each resolution rule attached to node n to
+// the set of labels delta.  It may generate new constraints in
+// a.constraints.
+//
+func (a *analysis) solveConstraints(n *node, delta *nodeset) {
+	if delta.IsEmpty() {
+		return
+	}
+
+	// Process complex constraints dependent on n.
+	for _, c := range n.solve.complex {
+		if a.log != nil {
+			fmt.Fprintf(a.log, "\t\tconstraint %s\n", c)
+		}
+		c.solve(a, delta)
+	}
+
+	// Process copy constraints.
+	var copySeen nodeset
+	for _, x := range n.solve.copyTo.AppendTo(a.deltaSpace) {
+		mid := nodeid(x)
+		if copySeen.add(mid) {
+			if a.nodes[mid].solve.pts.addAll(delta) {
+				a.addWork(mid)
+			}
+		}
+	}
+}
+
+// addLabel adds label to the points-to set of ptr and reports whether the set grew.
+func (a *analysis) addLabel(ptr, label nodeid) bool {
+	b := a.nodes[ptr].solve.pts.add(label)
+	if b && a.log != nil {
+		fmt.Fprintf(a.log, "\t\tpts(n%d) += n%d\n", ptr, label)
+	}
+	return b
+}
+
+func (a *analysis) addWork(id nodeid) {
+	a.work.Insert(int(id))
+	if a.log != nil {
+		fmt.Fprintf(a.log, "\t\twork: n%d\n", id)
+	}
+}
+
+// onlineCopy adds a copy edge.  It is called online, i.e. during
+// solving, so it adds edges and pts members directly rather than by
+// instantiating a 'constraint'.
+//
+// The size of the copy is implicitly 1.
+// It returns true if pts(dst) changed.
+//
+func (a *analysis) onlineCopy(dst, src nodeid) bool {
+	if dst != src {
+		if nsrc := a.nodes[src]; nsrc.solve.copyTo.add(dst) {
+			if a.log != nil {
+				fmt.Fprintf(a.log, "\t\t\tdynamic copy n%d <- n%d\n", dst, src)
+			}
+			// TODO(adonovan): most calls to onlineCopy
+			// are followed by addWork, possibly batched
+			// via a 'changed' flag; see if there's a
+			// noticeable penalty to calling addWork here.
+			return a.nodes[dst].solve.pts.addAll(&nsrc.solve.pts)
+		}
+	}
+	return false
+}
+
+// Returns sizeof.
+// Implicitly adds nodes to worklist.
+//
+// TODO(adonovan): now that we support a.copy() during solving, we
+// could eliminate onlineCopyN, but it's much slower.  Investigate.
+//
+func (a *analysis) onlineCopyN(dst, src nodeid, sizeof uint32) uint32 {
+	for i := uint32(0); i < sizeof; i++ {
+		if a.onlineCopy(dst, src) {
+			a.addWork(dst)
+		}
+		src++
+		dst++
+	}
+	return sizeof
+}
+
+func (c *loadConstraint) solve(a *analysis, delta *nodeset) {
+	var changed bool
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		k := nodeid(x)
+		koff := k + nodeid(c.offset)
+		if a.onlineCopy(c.dst, koff) {
+			changed = true
+		}
+	}
+	if changed {
+		a.addWork(c.dst)
+	}
+}
+
+func (c *storeConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		k := nodeid(x)
+		koff := k + nodeid(c.offset)
+		if a.onlineCopy(koff, c.src) {
+			a.addWork(koff)
+		}
+	}
+}
+
+func (c *offsetAddrConstraint) solve(a *analysis, delta *nodeset) {
+	dst := a.nodes[c.dst]
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		k := nodeid(x)
+		if dst.solve.pts.add(k + nodeid(c.offset)) {
+			a.addWork(c.dst)
+		}
+	}
+}
+
+func (c *typeFilterConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		ifaceObj := nodeid(x)
+		tDyn, _, indirect := a.taggedValue(ifaceObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		if types.AssignableTo(tDyn, c.typ) {
+			if a.addLabel(c.dst, ifaceObj) {
+				a.addWork(c.dst)
+			}
+		}
+	}
+}
+
+func (c *untagConstraint) solve(a *analysis, delta *nodeset) {
+	predicate := types.AssignableTo
+	if c.exact {
+		predicate = types.Identical
+	}
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		ifaceObj := nodeid(x)
+		tDyn, v, indirect := a.taggedValue(ifaceObj)
+		if indirect {
+			// TODO(adonovan): we'll need to implement this
+			// when we start creating indirect tagged objects.
+			panic("indirect tagged object")
+		}
+
+		if predicate(tDyn, c.typ) {
+			// Copy payload sans tag to dst.
+			//
+			// TODO(adonovan): opt: if tDyn is
+			// nonpointerlike we can skip this entire
+			// constraint, perhaps.  We only care about
+			// pointers among the fields.
+			a.onlineCopyN(c.dst, v, a.sizeof(tDyn))
+		}
+	}
+}
+
+func (c *invokeConstraint) solve(a *analysis, delta *nodeset) {
+	for _, x := range delta.AppendTo(a.deltaSpace) {
+		ifaceObj := nodeid(x)
+		tDyn, v, indirect := a.taggedValue(ifaceObj)
+		if indirect {
+			// TODO(adonovan): we may need to implement this if
+			// we ever apply invokeConstraints to reflect.Value PTSs,
+			// e.g. for (reflect.Value).Call.
+			panic("indirect tagged object")
+		}
+
+		// Look up the concrete method.
+		fn := a.prog.LookupMethod(tDyn, c.method.Pkg(), c.method.Name())
+		if fn == nil {
+			panic(fmt.Sprintf("n%d: no ssa.Function for %s", c.iface, c.method))
+		}
+		sig := fn.Signature
+
+		fnObj := a.globalobj[fn] // dynamic calls use shared contour
+		if fnObj == 0 {
+			// a.objectNode(fn) was not called during gen phase.
+			panic(fmt.Sprintf("a.globalobj[%s]==nil", fn))
+		}
+
+		// Make callsite's fn variable point to identity of
+		// concrete method.  (There's no need to add it to
+		// worklist since it never has attached constraints.)
+		a.addLabel(c.params, fnObj)
+
+		// Extract value and connect to method's receiver.
+		// Copy payload to method's receiver param (arg0).
+		arg0 := a.funcParams(fnObj)
+		recvSize := a.sizeof(sig.Recv().Type())
+		a.onlineCopyN(arg0, v, recvSize)
+
+		src := c.params + 1 // skip past identity
+		dst := arg0 + nodeid(recvSize)
+
+		// Copy caller's argument block to method formal parameters.
+		paramsSize := a.sizeof(sig.Params())
+		a.onlineCopyN(dst, src, paramsSize)
+		src += nodeid(paramsSize)
+		dst += nodeid(paramsSize)
+
+		// Copy method results to caller's result block.
+		resultsSize := a.sizeof(sig.Results())
+		a.onlineCopyN(src, dst, resultsSize)
+	}
+}
+
+func (c *addrConstraint) solve(a *analysis, delta *nodeset) {
+	panic("addr is not a complex constraint")
+}
+
+func (c *copyConstraint) solve(a *analysis, delta *nodeset) {
+	panic("copy is not a complex constraint")
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/pointer/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/util.go
new file mode 100644
index 00000000..683fdddd
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/pointer/util.go
@@ -0,0 +1,313 @@
+// 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 pointer
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"log"
+	"os"
+	"os/exec"
+	"runtime"
+	"time"
+
+	"golang.org/x/tools/container/intsets"
+)
+
+// CanPoint reports whether the type T is pointerlike,
+// for the purposes of this analysis.
+func CanPoint(T types.Type) bool {
+	switch T := T.(type) {
+	case *types.Named:
+		if obj := T.Obj(); obj.Name() == "Value" && obj.Pkg().Path() == "reflect" {
+			return true // treat reflect.Value like interface{}
+		}
+		return CanPoint(T.Underlying())
+	case *types.Pointer, *types.Interface, *types.Map, *types.Chan, *types.Signature, *types.Slice:
+		return true
+	}
+
+	return false // array struct tuple builtin basic
+}
+
+// CanHaveDynamicTypes reports whether the type T can "hold" dynamic types,
+// i.e. is an interface (incl. reflect.Type) or a reflect.Value.
+//
+func CanHaveDynamicTypes(T types.Type) bool {
+	switch T := T.(type) {
+	case *types.Named:
+		if obj := T.Obj(); obj.Name() == "Value" && obj.Pkg().Path() == "reflect" {
+			return true // reflect.Value
+		}
+		return CanHaveDynamicTypes(T.Underlying())
+	case *types.Interface:
+		return true
+	}
+	return false
+}
+
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
+
+// mustDeref returns the element type of its argument, which must be a
+// pointer; panic ensues otherwise.
+func mustDeref(typ types.Type) types.Type {
+	return typ.Underlying().(*types.Pointer).Elem()
+}
+
+// deref returns a pointer's element type; otherwise it returns typ.
+func deref(typ types.Type) types.Type {
+	if p, ok := typ.Underlying().(*types.Pointer); ok {
+		return p.Elem()
+	}
+	return typ
+}
+
+// A fieldInfo describes one subelement (node) of the flattening-out
+// of a type T: the subelement's type and its path from the root of T.
+//
+// For example, for this type:
+//     type line struct{ points []struct{x, y int} }
+// flatten() of the inner struct yields the following []fieldInfo:
+//    struct{ x, y int }                      ""
+//    int                                     ".x"
+//    int                                     ".y"
+// and flatten(line) yields:
+//    struct{ points []struct{x, y int} }     ""
+//    struct{ x, y int }                      ".points[*]"
+//    int                                     ".points[*].x
+//    int                                     ".points[*].y"
+//
+type fieldInfo struct {
+	typ types.Type
+
+	// op and tail describe the path to the element (e.g. ".a#2.b[*].c").
+	op   interface{} // *Array: true; *Tuple: int; *Struct: *types.Var; *Named: nil
+	tail *fieldInfo
+}
+
+// path returns a user-friendly string describing the subelement path.
+//
+func (fi *fieldInfo) path() string {
+	var buf bytes.Buffer
+	for p := fi; p != nil; p = p.tail {
+		switch op := p.op.(type) {
+		case bool:
+			fmt.Fprintf(&buf, "[*]")
+		case int:
+			fmt.Fprintf(&buf, "#%d", op)
+		case *types.Var:
+			fmt.Fprintf(&buf, ".%s", op.Name())
+		}
+	}
+	return buf.String()
+}
+
+// flatten returns a list of directly contained fields in the preorder
+// traversal of the type tree of t.  The resulting elements are all
+// scalars (basic types or pointerlike types), except for struct/array
+// "identity" nodes, whose type is that of the aggregate.
+//
+// reflect.Value is considered pointerlike, similar to interface{}.
+//
+// Callers must not mutate the result.
+//
+func (a *analysis) flatten(t types.Type) []*fieldInfo {
+	fl, ok := a.flattenMemo[t]
+	if !ok {
+		switch t := t.(type) {
+		case *types.Named:
+			u := t.Underlying()
+			if isInterface(u) {
+				// Debuggability hack: don't remove
+				// the named type from interfaces as
+				// they're very verbose.
+				fl = append(fl, &fieldInfo{typ: t})
+			} else {
+				fl = a.flatten(u)
+			}
+
+		case *types.Basic,
+			*types.Signature,
+			*types.Chan,
+			*types.Map,
+			*types.Interface,
+			*types.Slice,
+			*types.Pointer:
+			fl = append(fl, &fieldInfo{typ: t})
+
+		case *types.Array:
+			fl = append(fl, &fieldInfo{typ: t}) // identity node
+			for _, fi := range a.flatten(t.Elem()) {
+				fl = append(fl, &fieldInfo{typ: fi.typ, op: true, tail: fi})
+			}
+
+		case *types.Struct:
+			fl = append(fl, &fieldInfo{typ: t}) // identity node
+			for i, n := 0, t.NumFields(); i < n; i++ {
+				f := t.Field(i)
+				for _, fi := range a.flatten(f.Type()) {
+					fl = append(fl, &fieldInfo{typ: fi.typ, op: f, tail: fi})
+				}
+			}
+
+		case *types.Tuple:
+			// No identity node: tuples are never address-taken.
+			n := t.Len()
+			if n == 1 {
+				// Don't add a fieldInfo link for singletons,
+				// e.g. in params/results.
+				fl = append(fl, a.flatten(t.At(0).Type())...)
+			} else {
+				for i := 0; i < n; i++ {
+					f := t.At(i)
+					for _, fi := range a.flatten(f.Type()) {
+						fl = append(fl, &fieldInfo{typ: fi.typ, op: i, tail: fi})
+					}
+				}
+			}
+
+		default:
+			panic(fmt.Sprintf("cannot flatten unsupported type %T", t))
+		}
+
+		a.flattenMemo[t] = fl
+	}
+
+	return fl
+}
+
+// sizeof returns the number of pointerlike abstractions (nodes) in the type t.
+func (a *analysis) sizeof(t types.Type) uint32 {
+	return uint32(len(a.flatten(t)))
+}
+
+// shouldTrack reports whether object type T contains (recursively)
+// any fields whose addresses should be tracked.
+func (a *analysis) shouldTrack(T types.Type) bool {
+	if a.track == trackAll {
+		return true // fast path
+	}
+	track, ok := a.trackTypes[T]
+	if !ok {
+		a.trackTypes[T] = true // break cycles conservatively
+		// NB: reflect.Value, reflect.Type are pre-populated to true.
+		for _, fi := range a.flatten(T) {
+			switch ft := fi.typ.Underlying().(type) {
+			case *types.Interface, *types.Signature:
+				track = true // needed for callgraph
+			case *types.Basic:
+				// no-op
+			case *types.Chan:
+				track = a.track&trackChan != 0 || a.shouldTrack(ft.Elem())
+			case *types.Map:
+				track = a.track&trackMap != 0 || a.shouldTrack(ft.Key()) || a.shouldTrack(ft.Elem())
+			case *types.Slice:
+				track = a.track&trackSlice != 0 || a.shouldTrack(ft.Elem())
+			case *types.Pointer:
+				track = a.track&trackPtr != 0 || a.shouldTrack(ft.Elem())
+			case *types.Array, *types.Struct:
+				// No need to look at field types since they will follow (flattened).
+			default:
+				// Includes *types.Tuple, which are never address-taken.
+				panic(ft)
+			}
+			if track {
+				break
+			}
+		}
+		a.trackTypes[T] = track
+		if !track && a.log != nil {
+			fmt.Fprintf(a.log, "\ttype not tracked: %s\n", T)
+		}
+	}
+	return track
+}
+
+// offsetOf returns the (abstract) offset of field index within struct
+// or tuple typ.
+func (a *analysis) offsetOf(typ types.Type, index int) uint32 {
+	var offset uint32
+	switch t := typ.Underlying().(type) {
+	case *types.Tuple:
+		for i := 0; i < index; i++ {
+			offset += a.sizeof(t.At(i).Type())
+		}
+	case *types.Struct:
+		offset++ // the node for the struct itself
+		for i := 0; i < index; i++ {
+			offset += a.sizeof(t.Field(i).Type())
+		}
+	default:
+		panic(fmt.Sprintf("offsetOf(%s : %T)", typ, typ))
+	}
+	return offset
+}
+
+// sliceToArray returns the type representing the arrays to which
+// slice type slice points.
+func sliceToArray(slice types.Type) *types.Array {
+	return types.NewArray(slice.Underlying().(*types.Slice).Elem(), 1)
+}
+
+// Node set -------------------------------------------------------------------
+
+type nodeset struct {
+	intsets.Sparse
+}
+
+func (ns *nodeset) String() string {
+	var buf bytes.Buffer
+	buf.WriteRune('{')
+	var space [50]int
+	for i, n := range ns.AppendTo(space[:0]) {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		buf.WriteRune('n')
+		fmt.Fprintf(&buf, "%d", n)
+	}
+	buf.WriteRune('}')
+	return buf.String()
+}
+
+func (ns *nodeset) add(n nodeid) bool {
+	return ns.Sparse.Insert(int(n))
+}
+
+func (x *nodeset) addAll(y *nodeset) bool {
+	return x.UnionWith(&y.Sparse)
+}
+
+// Profiling & debugging -------------------------------------------------------
+
+var timers = make(map[string]time.Time)
+
+func start(name string) {
+	if debugTimers {
+		timers[name] = time.Now()
+		log.Printf("%s...\n", name)
+	}
+}
+
+func stop(name string) {
+	if debugTimers {
+		log.Printf("%s took %s\n", name, time.Since(timers[name]))
+	}
+}
+
+// diff runs the command "diff a b" and reports its success.
+func diff(a, b string) bool {
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "plan9":
+		cmd = exec.Command("/bin/diff", "-c", a, b)
+	default:
+		cmd = exec.Command("/usr/bin/diff", "-u", a, b)
+	}
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	return cmd.Run() == nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/blockopt.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/blockopt.go
new file mode 100644
index 00000000..e79260a2
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/blockopt.go
@@ -0,0 +1,187 @@
+// 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 ssa
+
+// Simple block optimizations to simplify the control flow graph.
+
+// TODO(adonovan): opt: instead of creating several "unreachable" blocks
+// per function in the Builder, reuse a single one (e.g. at Blocks[1])
+// to reduce garbage.
+
+import (
+	"fmt"
+	"os"
+)
+
+// If true, perform sanity checking and show progress at each
+// successive iteration of optimizeBlocks.  Very verbose.
+const debugBlockOpt = false
+
+// markReachable sets Index=-1 for all blocks reachable from b.
+func markReachable(b *BasicBlock) {
+	b.Index = -1
+	for _, succ := range b.Succs {
+		if succ.Index == 0 {
+			markReachable(succ)
+		}
+	}
+}
+
+// deleteUnreachableBlocks marks all reachable blocks of f and
+// eliminates (nils) all others, including possibly cyclic subgraphs.
+//
+func deleteUnreachableBlocks(f *Function) {
+	const white, black = 0, -1
+	// We borrow b.Index temporarily as the mark bit.
+	for _, b := range f.Blocks {
+		b.Index = white
+	}
+	markReachable(f.Blocks[0])
+	if f.Recover != nil {
+		markReachable(f.Recover)
+	}
+	for i, b := range f.Blocks {
+		if b.Index == white {
+			for _, c := range b.Succs {
+				if c.Index == black {
+					c.removePred(b) // delete white->black edge
+				}
+			}
+			if debugBlockOpt {
+				fmt.Fprintln(os.Stderr, "unreachable", b)
+			}
+			f.Blocks[i] = nil // delete b
+		}
+	}
+	f.removeNilBlocks()
+}
+
+// jumpThreading attempts to apply simple jump-threading to block b,
+// in which a->b->c become a->c if b is just a Jump.
+// The result is true if the optimization was applied.
+//
+func jumpThreading(f *Function, b *BasicBlock) bool {
+	if b.Index == 0 {
+		return false // don't apply to entry block
+	}
+	if b.Instrs == nil {
+		return false
+	}
+	if _, ok := b.Instrs[0].(*Jump); !ok {
+		return false // not just a jump
+	}
+	c := b.Succs[0]
+	if c == b {
+		return false // don't apply to degenerate jump-to-self.
+	}
+	if c.hasPhi() {
+		return false // not sound without more effort
+	}
+	for j, a := range b.Preds {
+		a.replaceSucc(b, c)
+
+		// If a now has two edges to c, replace its degenerate If by Jump.
+		if len(a.Succs) == 2 && a.Succs[0] == c && a.Succs[1] == c {
+			jump := new(Jump)
+			jump.setBlock(a)
+			a.Instrs[len(a.Instrs)-1] = jump
+			a.Succs = a.Succs[:1]
+			c.removePred(b)
+		} else {
+			if j == 0 {
+				c.replacePred(b, a)
+			} else {
+				c.Preds = append(c.Preds, a)
+			}
+		}
+
+		if debugBlockOpt {
+			fmt.Fprintln(os.Stderr, "jumpThreading", a, b, c)
+		}
+	}
+	f.Blocks[b.Index] = nil // delete b
+	return true
+}
+
+// fuseBlocks attempts to apply the block fusion optimization to block
+// a, in which a->b becomes ab if len(a.Succs)==len(b.Preds)==1.
+// The result is true if the optimization was applied.
+//
+func fuseBlocks(f *Function, a *BasicBlock) bool {
+	if len(a.Succs) != 1 {
+		return false
+	}
+	b := a.Succs[0]
+	if len(b.Preds) != 1 {
+		return false
+	}
+
+	// Degenerate &&/|| ops may result in a straight-line CFG
+	// containing φ-nodes. (Ideally we'd replace such them with
+	// their sole operand but that requires Referrers, built later.)
+	if b.hasPhi() {
+		return false // not sound without further effort
+	}
+
+	// Eliminate jump at end of A, then copy all of B across.
+	a.Instrs = append(a.Instrs[:len(a.Instrs)-1], b.Instrs...)
+	for _, instr := range b.Instrs {
+		instr.setBlock(a)
+	}
+
+	// A inherits B's successors
+	a.Succs = append(a.succs2[:0], b.Succs...)
+
+	// Fix up Preds links of all successors of B.
+	for _, c := range b.Succs {
+		c.replacePred(b, a)
+	}
+
+	if debugBlockOpt {
+		fmt.Fprintln(os.Stderr, "fuseBlocks", a, b)
+	}
+
+	f.Blocks[b.Index] = nil // delete b
+	return true
+}
+
+// optimizeBlocks() performs some simple block optimizations on a
+// completed function: dead block elimination, block fusion, jump
+// threading.
+//
+func optimizeBlocks(f *Function) {
+	deleteUnreachableBlocks(f)
+
+	// Loop until no further progress.
+	changed := true
+	for changed {
+		changed = false
+
+		if debugBlockOpt {
+			f.WriteTo(os.Stderr)
+			mustSanityCheck(f, nil)
+		}
+
+		for _, b := range f.Blocks {
+			// f.Blocks will temporarily contain nils to indicate
+			// deleted blocks; we remove them at the end.
+			if b == nil {
+				continue
+			}
+
+			// Fuse blocks.  b->c becomes bc.
+			if fuseBlocks(f, b) {
+				changed = true
+			}
+
+			// a->b->c becomes a->c if b contains only a Jump.
+			if jumpThreading(f, b) {
+				changed = true
+				continue // (b was disconnected)
+			}
+		}
+	}
+	f.removeNilBlocks()
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/builder.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/builder.go
new file mode 100644
index 00000000..44abc5b2
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/builder.go
@@ -0,0 +1,2379 @@
+// 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 ssa
+
+// This file implements the BUILD phase of SSA construction.
+//
+// SSA construction has two phases, CREATE and BUILD.  In the CREATE phase
+// (create.go), all packages are constructed and type-checked and
+// definitions of all package members are created, method-sets are
+// computed, and wrapper methods are synthesized.
+// ssa.Packages are created in arbitrary order.
+//
+// In the BUILD phase (builder.go), the builder traverses the AST of
+// each Go source function and generates SSA instructions for the
+// function body.  Initializer expressions for package-level variables
+// are emitted to the package's init() function in the order specified
+// by go/types.Info.InitOrder, then code for each function in the
+// package is generated in lexical order.
+// The BUILD phases for distinct packages are independent and are
+// executed in parallel.
+//
+// TODO(adonovan): indeed, building functions is now embarrassingly parallel.
+// Audit for concurrency then benchmark using more goroutines.
+//
+// The builder's and Program's indices (maps) are populated and
+// mutated during the CREATE phase, but during the BUILD phase they
+// remain constant.  The sole exception is Prog.methodSets and its
+// related maps, which are protected by a dedicated mutex.
+
+import (
+	"fmt"
+	"go/ast"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"os"
+	"sync"
+)
+
+type opaqueType struct {
+	types.Type
+	name string
+}
+
+func (t *opaqueType) String() string { return t.name }
+
+var (
+	varOk    = newVar("ok", tBool)
+	varIndex = newVar("index", tInt)
+
+	// Type constants.
+	tBool       = types.Typ[types.Bool]
+	tByte       = types.Typ[types.Byte]
+	tInt        = types.Typ[types.Int]
+	tInvalid    = types.Typ[types.Invalid]
+	tString     = types.Typ[types.String]
+	tUntypedNil = types.Typ[types.UntypedNil]
+	tRangeIter  = &opaqueType{nil, "iter"} // the type of all "range" iterators
+	tEface      = types.NewInterface(nil, nil).Complete()
+
+	// SSA Value constants.
+	vZero = intConst(0)
+	vOne  = intConst(1)
+	vTrue = NewConst(exact.MakeBool(true), tBool)
+)
+
+// builder holds state associated with the package currently being built.
+// Its methods contain all the logic for AST-to-SSA conversion.
+type builder struct{}
+
+// cond emits to fn code to evaluate boolean condition e and jump
+// to t or f depending on its value, performing various simplifications.
+//
+// Postcondition: fn.currentBlock is nil.
+//
+func (b *builder) cond(fn *Function, e ast.Expr, t, f *BasicBlock) {
+	switch e := e.(type) {
+	case *ast.ParenExpr:
+		b.cond(fn, e.X, t, f)
+		return
+
+	case *ast.BinaryExpr:
+		switch e.Op {
+		case token.LAND:
+			ltrue := fn.newBasicBlock("cond.true")
+			b.cond(fn, e.X, ltrue, f)
+			fn.currentBlock = ltrue
+			b.cond(fn, e.Y, t, f)
+			return
+
+		case token.LOR:
+			lfalse := fn.newBasicBlock("cond.false")
+			b.cond(fn, e.X, t, lfalse)
+			fn.currentBlock = lfalse
+			b.cond(fn, e.Y, t, f)
+			return
+		}
+
+	case *ast.UnaryExpr:
+		if e.Op == token.NOT {
+			b.cond(fn, e.X, f, t)
+			return
+		}
+	}
+
+	// A traditional compiler would simplify "if false" (etc) here
+	// but we do not, for better fidelity to the source code.
+	//
+	// The value of a constant condition may be platform-specific,
+	// and may cause blocks that are reachable in some configuration
+	// to be hidden from subsequent analyses such as bug-finding tools.
+	emitIf(fn, b.expr(fn, e), t, f)
+}
+
+// logicalBinop emits code to fn to evaluate e, a &&- or
+// ||-expression whose reified boolean value is wanted.
+// The value is returned.
+//
+func (b *builder) logicalBinop(fn *Function, e *ast.BinaryExpr) Value {
+	rhs := fn.newBasicBlock("binop.rhs")
+	done := fn.newBasicBlock("binop.done")
+
+	// T(e) = T(e.X) = T(e.Y) after untyped constants have been
+	// eliminated.
+	// TODO(adonovan): not true; MyBool==MyBool yields UntypedBool.
+	t := fn.Pkg.typeOf(e)
+
+	var short Value // value of the short-circuit path
+	switch e.Op {
+	case token.LAND:
+		b.cond(fn, e.X, rhs, done)
+		short = NewConst(exact.MakeBool(false), t)
+
+	case token.LOR:
+		b.cond(fn, e.X, done, rhs)
+		short = NewConst(exact.MakeBool(true), t)
+	}
+
+	// Is rhs unreachable?
+	if rhs.Preds == nil {
+		// Simplify false&&y to false, true||y to true.
+		fn.currentBlock = done
+		return short
+	}
+
+	// Is done unreachable?
+	if done.Preds == nil {
+		// Simplify true&&y (or false||y) to y.
+		fn.currentBlock = rhs
+		return b.expr(fn, e.Y)
+	}
+
+	// All edges from e.X to done carry the short-circuit value.
+	var edges []Value
+	for range done.Preds {
+		edges = append(edges, short)
+	}
+
+	// The edge from e.Y to done carries the value of e.Y.
+	fn.currentBlock = rhs
+	edges = append(edges, b.expr(fn, e.Y))
+	emitJump(fn, done)
+	fn.currentBlock = done
+
+	phi := &Phi{Edges: edges, Comment: e.Op.String()}
+	phi.pos = e.OpPos
+	phi.typ = t
+	return done.emit(phi)
+}
+
+// exprN lowers a multi-result expression e to SSA form, emitting code
+// to fn and returning a single Value whose type is a *types.Tuple.
+// The caller must access the components via Extract.
+//
+// Multi-result expressions include CallExprs in a multi-value
+// assignment or return statement, and "value,ok" uses of
+// TypeAssertExpr, IndexExpr (when X is a map), and UnaryExpr (when Op
+// is token.ARROW).
+//
+func (b *builder) exprN(fn *Function, e ast.Expr) Value {
+	typ := fn.Pkg.typeOf(e).(*types.Tuple)
+	switch e := e.(type) {
+	case *ast.ParenExpr:
+		return b.exprN(fn, e.X)
+
+	case *ast.CallExpr:
+		// Currently, no built-in function nor type conversion
+		// has multiple results, so we can avoid some of the
+		// cases for single-valued CallExpr.
+		var c Call
+		b.setCall(fn, e, &c.Call)
+		c.typ = typ
+		return fn.emit(&c)
+
+	case *ast.IndexExpr:
+		mapt := fn.Pkg.typeOf(e.X).Underlying().(*types.Map)
+		lookup := &Lookup{
+			X:       b.expr(fn, e.X),
+			Index:   emitConv(fn, b.expr(fn, e.Index), mapt.Key()),
+			CommaOk: true,
+		}
+		lookup.setType(typ)
+		lookup.setPos(e.Lbrack)
+		return fn.emit(lookup)
+
+	case *ast.TypeAssertExpr:
+		return emitTypeTest(fn, b.expr(fn, e.X), typ.At(0).Type(), e.Lparen)
+
+	case *ast.UnaryExpr: // must be receive <-
+		unop := &UnOp{
+			Op:      token.ARROW,
+			X:       b.expr(fn, e.X),
+			CommaOk: true,
+		}
+		unop.setType(typ)
+		unop.setPos(e.OpPos)
+		return fn.emit(unop)
+	}
+	panic(fmt.Sprintf("exprN(%T) in %s", e, fn))
+}
+
+// builtin emits to fn SSA instructions to implement a call to the
+// built-in function obj with the specified arguments
+// and return type.  It returns the value defined by the result.
+//
+// The result is nil if no special handling was required; in this case
+// the caller should treat this like an ordinary library function
+// call.
+//
+func (b *builder) builtin(fn *Function, obj *types.Builtin, args []ast.Expr, typ types.Type, pos token.Pos) Value {
+	switch obj.Name() {
+	case "make":
+		switch typ.Underlying().(type) {
+		case *types.Slice:
+			n := b.expr(fn, args[1])
+			m := n
+			if len(args) == 3 {
+				m = b.expr(fn, args[2])
+			}
+			if m, ok := m.(*Const); ok {
+				// treat make([]T, n, m) as new([m]T)[:n]
+				cap := m.Int64()
+				at := types.NewArray(typ.Underlying().(*types.Slice).Elem(), cap)
+				alloc := emitNew(fn, at, pos)
+				alloc.Comment = "makeslice"
+				v := &Slice{
+					X:    alloc,
+					High: n,
+				}
+				v.setPos(pos)
+				v.setType(typ)
+				return fn.emit(v)
+			}
+			v := &MakeSlice{
+				Len: n,
+				Cap: m,
+			}
+			v.setPos(pos)
+			v.setType(typ)
+			return fn.emit(v)
+
+		case *types.Map:
+			var res Value
+			if len(args) == 2 {
+				res = b.expr(fn, args[1])
+			}
+			v := &MakeMap{Reserve: res}
+			v.setPos(pos)
+			v.setType(typ)
+			return fn.emit(v)
+
+		case *types.Chan:
+			var sz Value = vZero
+			if len(args) == 2 {
+				sz = b.expr(fn, args[1])
+			}
+			v := &MakeChan{Size: sz}
+			v.setPos(pos)
+			v.setType(typ)
+			return fn.emit(v)
+		}
+
+	case "new":
+		alloc := emitNew(fn, deref(typ), pos)
+		alloc.Comment = "new"
+		return alloc
+
+	case "len", "cap":
+		// Special case: len or cap of an array or *array is
+		// based on the type, not the value which may be nil.
+		// We must still evaluate the value, though.  (If it
+		// was side-effect free, the whole call would have
+		// been constant-folded.)
+		t := deref(fn.Pkg.typeOf(args[0])).Underlying()
+		if at, ok := t.(*types.Array); ok {
+			b.expr(fn, args[0]) // for effects only
+			return intConst(at.Len())
+		}
+		// Otherwise treat as normal.
+
+	case "panic":
+		fn.emit(&Panic{
+			X:   emitConv(fn, b.expr(fn, args[0]), tEface),
+			pos: pos,
+		})
+		fn.currentBlock = fn.newBasicBlock("unreachable")
+		return vTrue // any non-nil Value will do
+	}
+	return nil // treat all others as a regular function call
+}
+
+// addr lowers a single-result addressable expression e to SSA form,
+// emitting code to fn and returning the location (an lvalue) defined
+// by the expression.
+//
+// If escaping is true, addr marks the base variable of the
+// addressable expression e as being a potentially escaping pointer
+// value.  For example, in this code:
+//
+//   a := A{
+//     b: [1]B{B{c: 1}}
+//   }
+//   return &a.b[0].c
+//
+// the application of & causes a.b[0].c to have its address taken,
+// which means that ultimately the local variable a must be
+// heap-allocated.  This is a simple but very conservative escape
+// analysis.
+//
+// Operations forming potentially escaping pointers include:
+// - &x, including when implicit in method call or composite literals.
+// - a[:] iff a is an array (not *array)
+// - references to variables in lexically enclosing functions.
+//
+func (b *builder) addr(fn *Function, e ast.Expr, escaping bool) lvalue {
+	switch e := e.(type) {
+	case *ast.Ident:
+		if isBlankIdent(e) {
+			return blank{}
+		}
+		obj := fn.Pkg.objectOf(e)
+		v := fn.Prog.packageLevelValue(obj) // var (address)
+		if v == nil {
+			v = fn.lookup(obj, escaping)
+		}
+		return &address{addr: v, pos: e.Pos(), expr: e}
+
+	case *ast.CompositeLit:
+		t := deref(fn.Pkg.typeOf(e))
+		var v *Alloc
+		if escaping {
+			v = emitNew(fn, t, e.Lbrace)
+		} else {
+			v = fn.addLocal(t, e.Lbrace)
+		}
+		v.Comment = "complit"
+		var sb storebuf
+		b.compLit(fn, v, e, true, &sb)
+		sb.emit(fn)
+		return &address{addr: v, pos: e.Lbrace, expr: e}
+
+	case *ast.ParenExpr:
+		return b.addr(fn, e.X, escaping)
+
+	case *ast.SelectorExpr:
+		sel, ok := fn.Pkg.info.Selections[e]
+		if !ok {
+			// qualified identifier
+			return b.addr(fn, e.Sel, escaping)
+		}
+		if sel.Kind() != types.FieldVal {
+			panic(sel)
+		}
+		wantAddr := true
+		v := b.receiver(fn, e.X, wantAddr, escaping, sel)
+		last := len(sel.Index()) - 1
+		return &address{
+			addr: emitFieldSelection(fn, v, sel.Index()[last], true, e.Sel),
+			pos:  e.Sel.Pos(),
+			expr: e.Sel,
+		}
+
+	case *ast.IndexExpr:
+		var x Value
+		var et types.Type
+		switch t := fn.Pkg.typeOf(e.X).Underlying().(type) {
+		case *types.Array:
+			x = b.addr(fn, e.X, escaping).address(fn)
+			et = types.NewPointer(t.Elem())
+		case *types.Pointer: // *array
+			x = b.expr(fn, e.X)
+			et = types.NewPointer(t.Elem().Underlying().(*types.Array).Elem())
+		case *types.Slice:
+			x = b.expr(fn, e.X)
+			et = types.NewPointer(t.Elem())
+		case *types.Map:
+			return &element{
+				m:   b.expr(fn, e.X),
+				k:   emitConv(fn, b.expr(fn, e.Index), t.Key()),
+				t:   t.Elem(),
+				pos: e.Lbrack,
+			}
+		default:
+			panic("unexpected container type in IndexExpr: " + t.String())
+		}
+		v := &IndexAddr{
+			X:     x,
+			Index: emitConv(fn, b.expr(fn, e.Index), tInt),
+		}
+		v.setPos(e.Lbrack)
+		v.setType(et)
+		return &address{addr: fn.emit(v), pos: e.Lbrack, expr: e}
+
+	case *ast.StarExpr:
+		return &address{addr: b.expr(fn, e.X), pos: e.Star, expr: e}
+	}
+
+	panic(fmt.Sprintf("unexpected address expression: %T", e))
+}
+
+type store struct {
+	lhs lvalue
+	rhs Value
+}
+
+type storebuf struct{ stores []store }
+
+func (sb *storebuf) store(lhs lvalue, rhs Value) {
+	sb.stores = append(sb.stores, store{lhs, rhs})
+}
+
+func (sb *storebuf) emit(fn *Function) {
+	for _, s := range sb.stores {
+		s.lhs.store(fn, s.rhs)
+	}
+}
+
+// assign emits to fn code to initialize the lvalue loc with the value
+// of expression e.  If isZero is true, assign assumes that loc holds
+// the zero value for its type.
+//
+// This is equivalent to loc.store(fn, b.expr(fn, e)), but may generate
+// better code in some cases, e.g., for composite literals in an
+// addressable location.
+//
+// If sb is not nil, assign generates code to evaluate expression e, but
+// not to update loc.  Instead, the necessary stores are appended to the
+// storebuf sb so that they can be executed later.  This allows correct
+// in-place update of existing variables when the RHS is a composite
+// literal that may reference parts of the LHS.
+//
+func (b *builder) assign(fn *Function, loc lvalue, e ast.Expr, isZero bool, sb *storebuf) {
+	// Can we initialize it in place?
+	if e, ok := unparen(e).(*ast.CompositeLit); ok {
+		// A CompositeLit never evaluates to a pointer,
+		// so if the type of the location is a pointer,
+		// an &-operation is implied.
+		if _, ok := loc.(blank); !ok { // avoid calling blank.typ()
+			if isPointer(loc.typ()) {
+				ptr := b.addr(fn, e, true).address(fn)
+				// copy address
+				if sb != nil {
+					sb.store(loc, ptr)
+				} else {
+					loc.store(fn, ptr)
+				}
+				return
+			}
+		}
+
+		if _, ok := loc.(*address); ok {
+			if isInterface(loc.typ()) {
+				// e.g. var x interface{} = T{...}
+				// Can't in-place initialize an interface value.
+				// Fall back to copying.
+			} else {
+				// x = T{...} or x := T{...}
+				addr := loc.address(fn)
+				if sb != nil {
+					b.compLit(fn, addr, e, isZero, sb)
+				} else {
+					var sb storebuf
+					b.compLit(fn, addr, e, isZero, &sb)
+					sb.emit(fn)
+				}
+
+				// Subtle: emit debug ref for aggregate types only;
+				// slice and map are handled by store ops in compLit.
+				switch loc.typ().Underlying().(type) {
+				case *types.Struct, *types.Array:
+					emitDebugRef(fn, e, addr, true)
+				}
+
+				return
+			}
+		}
+	}
+
+	// simple case: just copy
+	rhs := b.expr(fn, e)
+	if sb != nil {
+		sb.store(loc, rhs)
+	} else {
+		loc.store(fn, rhs)
+	}
+}
+
+// expr lowers a single-result expression e to SSA form, emitting code
+// to fn and returning the Value defined by the expression.
+//
+func (b *builder) expr(fn *Function, e ast.Expr) Value {
+	e = unparen(e)
+
+	tv := fn.Pkg.info.Types[e]
+
+	// Is expression a constant?
+	if tv.Value != nil {
+		return NewConst(tv.Value, tv.Type)
+	}
+
+	var v Value
+	if tv.Addressable() {
+		// Prefer pointer arithmetic ({Index,Field}Addr) followed
+		// by Load over subelement extraction (e.g. Index, Field),
+		// to avoid large copies.
+		v = b.addr(fn, e, false).load(fn)
+	} else {
+		v = b.expr0(fn, e, tv)
+	}
+	if fn.debugInfo() {
+		emitDebugRef(fn, e, v, false)
+	}
+	return v
+}
+
+func (b *builder) expr0(fn *Function, e ast.Expr, tv types.TypeAndValue) Value {
+	switch e := e.(type) {
+	case *ast.BasicLit:
+		panic("non-constant BasicLit") // unreachable
+
+	case *ast.FuncLit:
+		fn2 := &Function{
+			name:      fmt.Sprintf("%s$%d", fn.Name(), 1+len(fn.AnonFuncs)),
+			Signature: fn.Pkg.typeOf(e.Type).Underlying().(*types.Signature),
+			pos:       e.Type.Func,
+			parent:    fn,
+			Pkg:       fn.Pkg,
+			Prog:      fn.Prog,
+			syntax:    e,
+		}
+		fn.AnonFuncs = append(fn.AnonFuncs, fn2)
+		b.buildFunction(fn2)
+		if fn2.FreeVars == nil {
+			return fn2
+		}
+		v := &MakeClosure{Fn: fn2}
+		v.setType(tv.Type)
+		for _, fv := range fn2.FreeVars {
+			v.Bindings = append(v.Bindings, fv.outer)
+			fv.outer = nil
+		}
+		return fn.emit(v)
+
+	case *ast.TypeAssertExpr: // single-result form only
+		return emitTypeAssert(fn, b.expr(fn, e.X), tv.Type, e.Lparen)
+
+	case *ast.CallExpr:
+		if fn.Pkg.info.Types[e.Fun].IsType() {
+			// Explicit type conversion, e.g. string(x) or big.Int(x)
+			x := b.expr(fn, e.Args[0])
+			y := emitConv(fn, x, tv.Type)
+			if y != x {
+				switch y := y.(type) {
+				case *Convert:
+					y.pos = e.Lparen
+				case *ChangeType:
+					y.pos = e.Lparen
+				case *MakeInterface:
+					y.pos = e.Lparen
+				}
+			}
+			return y
+		}
+		// Call to "intrinsic" built-ins, e.g. new, make, panic.
+		if id, ok := unparen(e.Fun).(*ast.Ident); ok {
+			if obj, ok := fn.Pkg.info.Uses[id].(*types.Builtin); ok {
+				if v := b.builtin(fn, obj, e.Args, tv.Type, e.Lparen); v != nil {
+					return v
+				}
+			}
+		}
+		// Regular function call.
+		var v Call
+		b.setCall(fn, e, &v.Call)
+		v.setType(tv.Type)
+		return fn.emit(&v)
+
+	case *ast.UnaryExpr:
+		switch e.Op {
+		case token.AND: // &X --- potentially escaping.
+			addr := b.addr(fn, e.X, true)
+			if _, ok := unparen(e.X).(*ast.StarExpr); ok {
+				// &*p must panic if p is nil (http://golang.org/s/go12nil).
+				// For simplicity, we'll just (suboptimally) rely
+				// on the side effects of a load.
+				// TODO(adonovan): emit dedicated nilcheck.
+				addr.load(fn)
+			}
+			return addr.address(fn)
+		case token.ADD:
+			return b.expr(fn, e.X)
+		case token.NOT, token.ARROW, token.SUB, token.XOR: // ! <- - ^
+			v := &UnOp{
+				Op: e.Op,
+				X:  b.expr(fn, e.X),
+			}
+			v.setPos(e.OpPos)
+			v.setType(tv.Type)
+			return fn.emit(v)
+		default:
+			panic(e.Op)
+		}
+
+	case *ast.BinaryExpr:
+		switch e.Op {
+		case token.LAND, token.LOR:
+			return b.logicalBinop(fn, e)
+		case token.SHL, token.SHR:
+			fallthrough
+		case token.ADD, token.SUB, token.MUL, token.QUO, token.REM, token.AND, token.OR, token.XOR, token.AND_NOT:
+			return emitArith(fn, e.Op, b.expr(fn, e.X), b.expr(fn, e.Y), tv.Type, e.OpPos)
+
+		case token.EQL, token.NEQ, token.GTR, token.LSS, token.LEQ, token.GEQ:
+			cmp := emitCompare(fn, e.Op, b.expr(fn, e.X), b.expr(fn, e.Y), e.OpPos)
+			// The type of x==y may be UntypedBool.
+			return emitConv(fn, cmp, DefaultType(tv.Type))
+		default:
+			panic("illegal op in BinaryExpr: " + e.Op.String())
+		}
+
+	case *ast.SliceExpr:
+		var low, high, max Value
+		var x Value
+		switch fn.Pkg.typeOf(e.X).Underlying().(type) {
+		case *types.Array:
+			// Potentially escaping.
+			x = b.addr(fn, e.X, true).address(fn)
+		case *types.Basic, *types.Slice, *types.Pointer: // *array
+			x = b.expr(fn, e.X)
+		default:
+			panic("unreachable")
+		}
+		if e.High != nil {
+			high = b.expr(fn, e.High)
+		}
+		if e.Low != nil {
+			low = b.expr(fn, e.Low)
+		}
+		if e.Slice3 {
+			max = b.expr(fn, e.Max)
+		}
+		v := &Slice{
+			X:    x,
+			Low:  low,
+			High: high,
+			Max:  max,
+		}
+		v.setPos(e.Lbrack)
+		v.setType(tv.Type)
+		return fn.emit(v)
+
+	case *ast.Ident:
+		obj := fn.Pkg.info.Uses[e]
+		// Universal built-in or nil?
+		switch obj := obj.(type) {
+		case *types.Builtin:
+			return &Builtin{name: obj.Name(), sig: tv.Type.(*types.Signature)}
+		case *types.Nil:
+			return nilConst(tv.Type)
+		}
+		// Package-level func or var?
+		if v := fn.Prog.packageLevelValue(obj); v != nil {
+			if _, ok := obj.(*types.Var); ok {
+				return emitLoad(fn, v) // var (address)
+			}
+			return v // (func)
+		}
+		// Local var.
+		return emitLoad(fn, fn.lookup(obj, false)) // var (address)
+
+	case *ast.SelectorExpr:
+		sel, ok := fn.Pkg.info.Selections[e]
+		if !ok {
+			// qualified identifier
+			return b.expr(fn, e.Sel)
+		}
+		switch sel.Kind() {
+		case types.MethodExpr:
+			// (*T).f or T.f, the method f from the method-set of type T.
+			// The result is a "thunk".
+			return emitConv(fn, makeThunk(fn.Prog, sel), tv.Type)
+
+		case types.MethodVal:
+			// e.f where e is an expression and f is a method.
+			// The result is a "bound".
+			obj := sel.Obj().(*types.Func)
+			rt := recvType(obj)
+			wantAddr := isPointer(rt)
+			escaping := true
+			v := b.receiver(fn, e.X, wantAddr, escaping, sel)
+			if isInterface(rt) {
+				// If v has interface type I,
+				// we must emit a check that v is non-nil.
+				// We use: typeassert v.(I).
+				emitTypeAssert(fn, v, rt, token.NoPos)
+			}
+			c := &MakeClosure{
+				Fn:       makeBound(fn.Prog, obj),
+				Bindings: []Value{v},
+			}
+			c.setPos(e.Sel.Pos())
+			c.setType(tv.Type)
+			return fn.emit(c)
+
+		case types.FieldVal:
+			indices := sel.Index()
+			last := len(indices) - 1
+			v := b.expr(fn, e.X)
+			v = emitImplicitSelections(fn, v, indices[:last])
+			v = emitFieldSelection(fn, v, indices[last], false, e.Sel)
+			return v
+		}
+
+		panic("unexpected expression-relative selector")
+
+	case *ast.IndexExpr:
+		switch t := fn.Pkg.typeOf(e.X).Underlying().(type) {
+		case *types.Array:
+			// Non-addressable array (in a register).
+			v := &Index{
+				X:     b.expr(fn, e.X),
+				Index: emitConv(fn, b.expr(fn, e.Index), tInt),
+			}
+			v.setPos(e.Lbrack)
+			v.setType(t.Elem())
+			return fn.emit(v)
+
+		case *types.Map:
+			// Maps are not addressable.
+			mapt := fn.Pkg.typeOf(e.X).Underlying().(*types.Map)
+			v := &Lookup{
+				X:     b.expr(fn, e.X),
+				Index: emitConv(fn, b.expr(fn, e.Index), mapt.Key()),
+			}
+			v.setPos(e.Lbrack)
+			v.setType(mapt.Elem())
+			return fn.emit(v)
+
+		case *types.Basic: // => string
+			// Strings are not addressable.
+			v := &Lookup{
+				X:     b.expr(fn, e.X),
+				Index: b.expr(fn, e.Index),
+			}
+			v.setPos(e.Lbrack)
+			v.setType(tByte)
+			return fn.emit(v)
+
+		case *types.Slice, *types.Pointer: // *array
+			// Addressable slice/array; use IndexAddr and Load.
+			return b.addr(fn, e, false).load(fn)
+
+		default:
+			panic("unexpected container type in IndexExpr: " + t.String())
+		}
+
+	case *ast.CompositeLit, *ast.StarExpr:
+		// Addressable types (lvalues)
+		return b.addr(fn, e, false).load(fn)
+	}
+
+	panic(fmt.Sprintf("unexpected expr: %T", e))
+}
+
+// stmtList emits to fn code for all statements in list.
+func (b *builder) stmtList(fn *Function, list []ast.Stmt) {
+	for _, s := range list {
+		b.stmt(fn, s)
+	}
+}
+
+// receiver emits to fn code for expression e in the "receiver"
+// position of selection e.f (where f may be a field or a method) and
+// returns the effective receiver after applying the implicit field
+// selections of sel.
+//
+// wantAddr requests that the result is an an address.  If
+// !sel.Indirect(), this may require that e be built in addr() mode; it
+// must thus be addressable.
+//
+// escaping is defined as per builder.addr().
+//
+func (b *builder) receiver(fn *Function, e ast.Expr, wantAddr, escaping bool, sel *types.Selection) Value {
+	var v Value
+	if wantAddr && !sel.Indirect() && !isPointer(fn.Pkg.typeOf(e)) {
+		v = b.addr(fn, e, escaping).address(fn)
+	} else {
+		v = b.expr(fn, e)
+	}
+
+	last := len(sel.Index()) - 1
+	v = emitImplicitSelections(fn, v, sel.Index()[:last])
+	if !wantAddr && isPointer(v.Type()) {
+		v = emitLoad(fn, v)
+	}
+	return v
+}
+
+// setCallFunc populates the function parts of a CallCommon structure
+// (Func, Method, Recv, Args[0]) based on the kind of invocation
+// occurring in e.
+//
+func (b *builder) setCallFunc(fn *Function, e *ast.CallExpr, c *CallCommon) {
+	c.pos = e.Lparen
+
+	// Is this a method call?
+	if selector, ok := unparen(e.Fun).(*ast.SelectorExpr); ok {
+		sel, ok := fn.Pkg.info.Selections[selector]
+		if ok && sel.Kind() == types.MethodVal {
+			obj := sel.Obj().(*types.Func)
+			recv := recvType(obj)
+			wantAddr := isPointer(recv)
+			escaping := true
+			v := b.receiver(fn, selector.X, wantAddr, escaping, sel)
+			if isInterface(recv) {
+				// Invoke-mode call.
+				c.Value = v
+				c.Method = obj
+			} else {
+				// "Call"-mode call.
+				c.Value = fn.Prog.declaredFunc(obj)
+				c.Args = append(c.Args, v)
+			}
+			return
+		}
+
+		// sel.Kind()==MethodExpr indicates T.f() or (*T).f():
+		// a statically dispatched call to the method f in the
+		// method-set of T or *T.  T may be an interface.
+		//
+		// e.Fun would evaluate to a concrete method, interface
+		// wrapper function, or promotion wrapper.
+		//
+		// For now, we evaluate it in the usual way.
+		//
+		// TODO(adonovan): opt: inline expr() here, to make the
+		// call static and to avoid generation of wrappers.
+		// It's somewhat tricky as it may consume the first
+		// actual parameter if the call is "invoke" mode.
+		//
+		// Examples:
+		//  type T struct{}; func (T) f() {}   // "call" mode
+		//  type T interface { f() }           // "invoke" mode
+		//
+		//  type S struct{ T }
+		//
+		//  var s S
+		//  S.f(s)
+		//  (*S).f(&s)
+		//
+		// Suggested approach:
+		// - consume the first actual parameter expression
+		//   and build it with b.expr().
+		// - apply implicit field selections.
+		// - use MethodVal logic to populate fields of c.
+	}
+
+	// Evaluate the function operand in the usual way.
+	c.Value = b.expr(fn, e.Fun)
+}
+
+// emitCallArgs emits to f code for the actual parameters of call e to
+// a (possibly built-in) function of effective type sig.
+// The argument values are appended to args, which is then returned.
+//
+func (b *builder) emitCallArgs(fn *Function, sig *types.Signature, e *ast.CallExpr, args []Value) []Value {
+	// f(x, y, z...): pass slice z straight through.
+	if e.Ellipsis != 0 {
+		for i, arg := range e.Args {
+			v := emitConv(fn, b.expr(fn, arg), sig.Params().At(i).Type())
+			args = append(args, v)
+		}
+		return args
+	}
+
+	offset := len(args) // 1 if call has receiver, 0 otherwise
+
+	// Evaluate actual parameter expressions.
+	//
+	// If this is a chained call of the form f(g()) where g has
+	// multiple return values (MRV), they are flattened out into
+	// args; a suffix of them may end up in a varargs slice.
+	for _, arg := range e.Args {
+		v := b.expr(fn, arg)
+		if ttuple, ok := v.Type().(*types.Tuple); ok { // MRV chain
+			for i, n := 0, ttuple.Len(); i < n; i++ {
+				args = append(args, emitExtract(fn, v, i))
+			}
+		} else {
+			args = append(args, v)
+		}
+	}
+
+	// Actual->formal assignability conversions for normal parameters.
+	np := sig.Params().Len() // number of normal parameters
+	if sig.Variadic() {
+		np--
+	}
+	for i := 0; i < np; i++ {
+		args[offset+i] = emitConv(fn, args[offset+i], sig.Params().At(i).Type())
+	}
+
+	// Actual->formal assignability conversions for variadic parameter,
+	// and construction of slice.
+	if sig.Variadic() {
+		varargs := args[offset+np:]
+		st := sig.Params().At(np).Type().(*types.Slice)
+		vt := st.Elem()
+		if len(varargs) == 0 {
+			args = append(args, nilConst(st))
+		} else {
+			// Replace a suffix of args with a slice containing it.
+			at := types.NewArray(vt, int64(len(varargs)))
+			a := emitNew(fn, at, token.NoPos)
+			a.setPos(e.Rparen)
+			a.Comment = "varargs"
+			for i, arg := range varargs {
+				iaddr := &IndexAddr{
+					X:     a,
+					Index: intConst(int64(i)),
+				}
+				iaddr.setType(types.NewPointer(vt))
+				fn.emit(iaddr)
+				emitStore(fn, iaddr, arg, arg.Pos())
+			}
+			s := &Slice{X: a}
+			s.setType(st)
+			args[offset+np] = fn.emit(s)
+			args = args[:offset+np+1]
+		}
+	}
+	return args
+}
+
+// setCall emits to fn code to evaluate all the parameters of a function
+// call e, and populates *c with those values.
+//
+func (b *builder) setCall(fn *Function, e *ast.CallExpr, c *CallCommon) {
+	// First deal with the f(...) part and optional receiver.
+	b.setCallFunc(fn, e, c)
+
+	// Then append the other actual parameters.
+	sig, _ := fn.Pkg.typeOf(e.Fun).Underlying().(*types.Signature)
+	if sig == nil {
+		panic(fmt.Sprintf("no signature for call of %s", e.Fun))
+	}
+	c.Args = b.emitCallArgs(fn, sig, e, c.Args)
+}
+
+// assignOp emits to fn code to perform loc += incr or loc -= incr.
+func (b *builder) assignOp(fn *Function, loc lvalue, incr Value, op token.Token) {
+	oldv := loc.load(fn)
+	loc.store(fn, emitArith(fn, op, oldv, emitConv(fn, incr, oldv.Type()), loc.typ(), token.NoPos))
+}
+
+// localValueSpec emits to fn code to define all of the vars in the
+// function-local ValueSpec, spec.
+//
+func (b *builder) localValueSpec(fn *Function, spec *ast.ValueSpec) {
+	switch {
+	case len(spec.Values) == len(spec.Names):
+		// e.g. var x, y = 0, 1
+		// 1:1 assignment
+		for i, id := range spec.Names {
+			if !isBlankIdent(id) {
+				fn.addLocalForIdent(id)
+			}
+			lval := b.addr(fn, id, false) // non-escaping
+			b.assign(fn, lval, spec.Values[i], true, nil)
+		}
+
+	case len(spec.Values) == 0:
+		// e.g. var x, y int
+		// Locals are implicitly zero-initialized.
+		for _, id := range spec.Names {
+			if !isBlankIdent(id) {
+				lhs := fn.addLocalForIdent(id)
+				if fn.debugInfo() {
+					emitDebugRef(fn, id, lhs, true)
+				}
+			}
+		}
+
+	default:
+		// e.g. var x, y = pos()
+		tuple := b.exprN(fn, spec.Values[0])
+		for i, id := range spec.Names {
+			if !isBlankIdent(id) {
+				fn.addLocalForIdent(id)
+				lhs := b.addr(fn, id, false) // non-escaping
+				lhs.store(fn, emitExtract(fn, tuple, i))
+			}
+		}
+	}
+}
+
+// assignStmt emits code to fn for a parallel assignment of rhss to lhss.
+// isDef is true if this is a short variable declaration (:=).
+//
+// Note the similarity with localValueSpec.
+//
+func (b *builder) assignStmt(fn *Function, lhss, rhss []ast.Expr, isDef bool) {
+	// Side effects of all LHSs and RHSs must occur in left-to-right order.
+	lvals := make([]lvalue, len(lhss))
+	isZero := make([]bool, len(lhss))
+	for i, lhs := range lhss {
+		var lval lvalue = blank{}
+		if !isBlankIdent(lhs) {
+			if isDef {
+				if obj := fn.Pkg.info.Defs[lhs.(*ast.Ident)]; obj != nil {
+					fn.addNamedLocal(obj)
+					isZero[i] = true
+				}
+			}
+			lval = b.addr(fn, lhs, false) // non-escaping
+		}
+		lvals[i] = lval
+	}
+	if len(lhss) == len(rhss) {
+		// Simple assignment:   x     = f()        (!isDef)
+		// Parallel assignment: x, y  = f(), g()   (!isDef)
+		// or short var decl:   x, y := f(), g()   (isDef)
+		//
+		// In all cases, the RHSs may refer to the LHSs,
+		// so we need a storebuf.
+		var sb storebuf
+		for i := range rhss {
+			b.assign(fn, lvals[i], rhss[i], isZero[i], &sb)
+		}
+		sb.emit(fn)
+	} else {
+		// e.g. x, y = pos()
+		tuple := b.exprN(fn, rhss[0])
+		emitDebugRef(fn, rhss[0], tuple, false)
+		for i, lval := range lvals {
+			lval.store(fn, emitExtract(fn, tuple, i))
+		}
+	}
+}
+
+// arrayLen returns the length of the array whose composite literal elements are elts.
+func (b *builder) arrayLen(fn *Function, elts []ast.Expr) int64 {
+	var max int64 = -1
+	var i int64 = -1
+	for _, e := range elts {
+		if kv, ok := e.(*ast.KeyValueExpr); ok {
+			i = b.expr(fn, kv.Key).(*Const).Int64()
+		} else {
+			i++
+		}
+		if i > max {
+			max = i
+		}
+	}
+	return max + 1
+}
+
+// compLit emits to fn code to initialize a composite literal e at
+// address addr with type typ.
+//
+// Nested composite literals are recursively initialized in place
+// where possible. If isZero is true, compLit assumes that addr
+// holds the zero value for typ.
+//
+// Because the elements of a composite literal may refer to the
+// variables being updated, as in the second line below,
+//	x := T{a: 1}
+//	x = T{a: x.a}
+// all the reads must occur before all the writes.  Thus all stores to
+// loc are emitted to the storebuf sb for later execution.
+//
+// A CompositeLit may have pointer type only in the recursive (nested)
+// case when the type name is implicit.  e.g. in []*T{{}}, the inner
+// literal has type *T behaves like &T{}.
+// In that case, addr must hold a T, not a *T.
+//
+func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero bool, sb *storebuf) {
+	typ := deref(fn.Pkg.typeOf(e))
+	switch t := typ.Underlying().(type) {
+	case *types.Struct:
+		if !isZero && len(e.Elts) != t.NumFields() {
+			// memclear
+			sb.store(&address{addr, e.Lbrace, nil},
+				zeroValue(fn, deref(addr.Type())))
+			isZero = true
+		}
+		for i, e := range e.Elts {
+			fieldIndex := i
+			pos := e.Pos()
+			if kv, ok := e.(*ast.KeyValueExpr); ok {
+				fname := kv.Key.(*ast.Ident).Name
+				for i, n := 0, t.NumFields(); i < n; i++ {
+					sf := t.Field(i)
+					if sf.Name() == fname {
+						fieldIndex = i
+						pos = kv.Colon
+						e = kv.Value
+						break
+					}
+				}
+			}
+			sf := t.Field(fieldIndex)
+			faddr := &FieldAddr{
+				X:     addr,
+				Field: fieldIndex,
+			}
+			faddr.setType(types.NewPointer(sf.Type()))
+			fn.emit(faddr)
+			b.assign(fn, &address{addr: faddr, pos: pos, expr: e}, e, isZero, sb)
+		}
+
+	case *types.Array, *types.Slice:
+		var at *types.Array
+		var array Value
+		switch t := t.(type) {
+		case *types.Slice:
+			at = types.NewArray(t.Elem(), b.arrayLen(fn, e.Elts))
+			alloc := emitNew(fn, at, e.Lbrace)
+			alloc.Comment = "slicelit"
+			array = alloc
+		case *types.Array:
+			at = t
+			array = addr
+
+			if !isZero && int64(len(e.Elts)) != at.Len() {
+				// memclear
+				sb.store(&address{array, e.Lbrace, nil},
+					zeroValue(fn, deref(array.Type())))
+			}
+		}
+
+		var idx *Const
+		for _, e := range e.Elts {
+			pos := e.Pos()
+			if kv, ok := e.(*ast.KeyValueExpr); ok {
+				idx = b.expr(fn, kv.Key).(*Const)
+				pos = kv.Colon
+				e = kv.Value
+			} else {
+				var idxval int64
+				if idx != nil {
+					idxval = idx.Int64() + 1
+				}
+				idx = intConst(idxval)
+			}
+			iaddr := &IndexAddr{
+				X:     array,
+				Index: idx,
+			}
+			iaddr.setType(types.NewPointer(at.Elem()))
+			fn.emit(iaddr)
+			if t != at { // slice
+				// backing array is unaliased => storebuf not needed.
+				b.assign(fn, &address{addr: iaddr, pos: pos, expr: e}, e, true, nil)
+			} else {
+				b.assign(fn, &address{addr: iaddr, pos: pos, expr: e}, e, true, sb)
+			}
+		}
+
+		if t != at { // slice
+			s := &Slice{X: array}
+			s.setPos(e.Lbrace)
+			s.setType(typ)
+			sb.store(&address{addr: addr, pos: e.Lbrace, expr: e}, fn.emit(s))
+		}
+
+	case *types.Map:
+		m := &MakeMap{Reserve: intConst(int64(len(e.Elts)))}
+		m.setPos(e.Lbrace)
+		m.setType(typ)
+		fn.emit(m)
+		for _, e := range e.Elts {
+			e := e.(*ast.KeyValueExpr)
+
+			// If a key expression in a map literal is  itself a
+			// composite literal, the type may be omitted.
+			// For example:
+			//	map[*struct{}]bool{{}: true}
+			// An &-operation may be implied:
+			//	map[*struct{}]bool{&struct{}{}: true}
+			var key Value
+			if _, ok := unparen(e.Key).(*ast.CompositeLit); ok && isPointer(t.Key()) {
+				// A CompositeLit never evaluates to a pointer,
+				// so if the type of the location is a pointer,
+				// an &-operation is implied.
+				key = b.addr(fn, e.Key, true).address(fn)
+			} else {
+				key = b.expr(fn, e.Key)
+			}
+
+			loc := element{
+				m:   m,
+				k:   emitConv(fn, key, t.Key()),
+				t:   t.Elem(),
+				pos: e.Colon,
+			}
+
+			// We call assign() only because it takes care
+			// of any &-operation required in the recursive
+			// case, e.g.,
+			// map[int]*struct{}{0: {}} implies &struct{}{}.
+			// In-place update is of course impossible,
+			// and no storebuf is needed.
+			b.assign(fn, &loc, e.Value, true, nil)
+		}
+		sb.store(&address{addr: addr, pos: e.Lbrace, expr: e}, m)
+
+	default:
+		panic("unexpected CompositeLit type: " + t.String())
+	}
+}
+
+// switchStmt emits to fn code for the switch statement s, optionally
+// labelled by label.
+//
+func (b *builder) switchStmt(fn *Function, s *ast.SwitchStmt, label *lblock) {
+	// We treat SwitchStmt like a sequential if-else chain.
+	// Multiway dispatch can be recovered later by ssautil.Switches()
+	// to those cases that are free of side effects.
+	if s.Init != nil {
+		b.stmt(fn, s.Init)
+	}
+	var tag Value = vTrue
+	if s.Tag != nil {
+		tag = b.expr(fn, s.Tag)
+	}
+	done := fn.newBasicBlock("switch.done")
+	if label != nil {
+		label._break = done
+	}
+	// We pull the default case (if present) down to the end.
+	// But each fallthrough label must point to the next
+	// body block in source order, so we preallocate a
+	// body block (fallthru) for the next case.
+	// Unfortunately this makes for a confusing block order.
+	var dfltBody *[]ast.Stmt
+	var dfltFallthrough *BasicBlock
+	var fallthru, dfltBlock *BasicBlock
+	ncases := len(s.Body.List)
+	for i, clause := range s.Body.List {
+		body := fallthru
+		if body == nil {
+			body = fn.newBasicBlock("switch.body") // first case only
+		}
+
+		// Preallocate body block for the next case.
+		fallthru = done
+		if i+1 < ncases {
+			fallthru = fn.newBasicBlock("switch.body")
+		}
+
+		cc := clause.(*ast.CaseClause)
+		if cc.List == nil {
+			// Default case.
+			dfltBody = &cc.Body
+			dfltFallthrough = fallthru
+			dfltBlock = body
+			continue
+		}
+
+		var nextCond *BasicBlock
+		for _, cond := range cc.List {
+			nextCond = fn.newBasicBlock("switch.next")
+			// TODO(adonovan): opt: when tag==vTrue, we'd
+			// get better code if we use b.cond(cond)
+			// instead of BinOp(EQL, tag, b.expr(cond))
+			// followed by If.  Don't forget conversions
+			// though.
+			cond := emitCompare(fn, token.EQL, tag, b.expr(fn, cond), token.NoPos)
+			emitIf(fn, cond, body, nextCond)
+			fn.currentBlock = nextCond
+		}
+		fn.currentBlock = body
+		fn.targets = &targets{
+			tail:         fn.targets,
+			_break:       done,
+			_fallthrough: fallthru,
+		}
+		b.stmtList(fn, cc.Body)
+		fn.targets = fn.targets.tail
+		emitJump(fn, done)
+		fn.currentBlock = nextCond
+	}
+	if dfltBlock != nil {
+		emitJump(fn, dfltBlock)
+		fn.currentBlock = dfltBlock
+		fn.targets = &targets{
+			tail:         fn.targets,
+			_break:       done,
+			_fallthrough: dfltFallthrough,
+		}
+		b.stmtList(fn, *dfltBody)
+		fn.targets = fn.targets.tail
+	}
+	emitJump(fn, done)
+	fn.currentBlock = done
+}
+
+// typeSwitchStmt emits to fn code for the type switch statement s, optionally
+// labelled by label.
+//
+func (b *builder) typeSwitchStmt(fn *Function, s *ast.TypeSwitchStmt, label *lblock) {
+	// We treat TypeSwitchStmt like a sequential if-else chain.
+	// Multiway dispatch can be recovered later by ssautil.Switches().
+
+	// Typeswitch lowering:
+	//
+	// var x X
+	// switch y := x.(type) {
+	// case T1, T2: S1                  // >1 	(y := x)
+	// case nil:    SN                  // nil 	(y := x)
+	// default:     SD                  // 0 types 	(y := x)
+	// case T3:     S3                  // 1 type 	(y := x.(T3))
+	// }
+	//
+	//      ...s.Init...
+	// 	x := eval x
+	// .caseT1:
+	// 	t1, ok1 := typeswitch,ok x <T1>
+	// 	if ok1 then goto S1 else goto .caseT2
+	// .caseT2:
+	// 	t2, ok2 := typeswitch,ok x <T2>
+	// 	if ok2 then goto S1 else goto .caseNil
+	// .S1:
+	//      y := x
+	// 	...S1...
+	// 	goto done
+	// .caseNil:
+	// 	if t2, ok2 := typeswitch,ok x <T2>
+	// 	if x == nil then goto SN else goto .caseT3
+	// .SN:
+	//      y := x
+	// 	...SN...
+	// 	goto done
+	// .caseT3:
+	// 	t3, ok3 := typeswitch,ok x <T3>
+	// 	if ok3 then goto S3 else goto default
+	// .S3:
+	//      y := t3
+	// 	...S3...
+	// 	goto done
+	// .default:
+	//      y := x
+	// 	...SD...
+	// 	goto done
+	// .done:
+
+	if s.Init != nil {
+		b.stmt(fn, s.Init)
+	}
+
+	var x Value
+	switch ass := s.Assign.(type) {
+	case *ast.ExprStmt: // x.(type)
+		x = b.expr(fn, unparen(ass.X).(*ast.TypeAssertExpr).X)
+	case *ast.AssignStmt: // y := x.(type)
+		x = b.expr(fn, unparen(ass.Rhs[0]).(*ast.TypeAssertExpr).X)
+	}
+
+	done := fn.newBasicBlock("typeswitch.done")
+	if label != nil {
+		label._break = done
+	}
+	var default_ *ast.CaseClause
+	for _, clause := range s.Body.List {
+		cc := clause.(*ast.CaseClause)
+		if cc.List == nil {
+			default_ = cc
+			continue
+		}
+		body := fn.newBasicBlock("typeswitch.body")
+		var next *BasicBlock
+		var casetype types.Type
+		var ti Value // ti, ok := typeassert,ok x <Ti>
+		for _, cond := range cc.List {
+			next = fn.newBasicBlock("typeswitch.next")
+			casetype = fn.Pkg.typeOf(cond)
+			var condv Value
+			if casetype == tUntypedNil {
+				condv = emitCompare(fn, token.EQL, x, nilConst(x.Type()), token.NoPos)
+				ti = x
+			} else {
+				yok := emitTypeTest(fn, x, casetype, cc.Case)
+				ti = emitExtract(fn, yok, 0)
+				condv = emitExtract(fn, yok, 1)
+			}
+			emitIf(fn, condv, body, next)
+			fn.currentBlock = next
+		}
+		if len(cc.List) != 1 {
+			ti = x
+		}
+		fn.currentBlock = body
+		b.typeCaseBody(fn, cc, ti, done)
+		fn.currentBlock = next
+	}
+	if default_ != nil {
+		b.typeCaseBody(fn, default_, x, done)
+	} else {
+		emitJump(fn, done)
+	}
+	fn.currentBlock = done
+}
+
+func (b *builder) typeCaseBody(fn *Function, cc *ast.CaseClause, x Value, done *BasicBlock) {
+	if obj := fn.Pkg.info.Implicits[cc]; obj != nil {
+		// In a switch y := x.(type), each case clause
+		// implicitly declares a distinct object y.
+		// In a single-type case, y has that type.
+		// In multi-type cases, 'case nil' and default,
+		// y has the same type as the interface operand.
+		emitStore(fn, fn.addNamedLocal(obj), x, obj.Pos())
+	}
+	fn.targets = &targets{
+		tail:   fn.targets,
+		_break: done,
+	}
+	b.stmtList(fn, cc.Body)
+	fn.targets = fn.targets.tail
+	emitJump(fn, done)
+}
+
+// selectStmt emits to fn code for the select statement s, optionally
+// labelled by label.
+//
+func (b *builder) selectStmt(fn *Function, s *ast.SelectStmt, label *lblock) {
+	// A blocking select of a single case degenerates to a
+	// simple send or receive.
+	// TODO(adonovan): opt: is this optimization worth its weight?
+	if len(s.Body.List) == 1 {
+		clause := s.Body.List[0].(*ast.CommClause)
+		if clause.Comm != nil {
+			b.stmt(fn, clause.Comm)
+			done := fn.newBasicBlock("select.done")
+			if label != nil {
+				label._break = done
+			}
+			fn.targets = &targets{
+				tail:   fn.targets,
+				_break: done,
+			}
+			b.stmtList(fn, clause.Body)
+			fn.targets = fn.targets.tail
+			emitJump(fn, done)
+			fn.currentBlock = done
+			return
+		}
+	}
+
+	// First evaluate all channels in all cases, and find
+	// the directions of each state.
+	var states []*SelectState
+	blocking := true
+	debugInfo := fn.debugInfo()
+	for _, clause := range s.Body.List {
+		var st *SelectState
+		switch comm := clause.(*ast.CommClause).Comm.(type) {
+		case nil: // default case
+			blocking = false
+			continue
+
+		case *ast.SendStmt: // ch<- i
+			ch := b.expr(fn, comm.Chan)
+			st = &SelectState{
+				Dir:  types.SendOnly,
+				Chan: ch,
+				Send: emitConv(fn, b.expr(fn, comm.Value),
+					ch.Type().Underlying().(*types.Chan).Elem()),
+				Pos: comm.Arrow,
+			}
+			if debugInfo {
+				st.DebugNode = comm
+			}
+
+		case *ast.AssignStmt: // x := <-ch
+			recv := unparen(comm.Rhs[0]).(*ast.UnaryExpr)
+			st = &SelectState{
+				Dir:  types.RecvOnly,
+				Chan: b.expr(fn, recv.X),
+				Pos:  recv.OpPos,
+			}
+			if debugInfo {
+				st.DebugNode = recv
+			}
+
+		case *ast.ExprStmt: // <-ch
+			recv := unparen(comm.X).(*ast.UnaryExpr)
+			st = &SelectState{
+				Dir:  types.RecvOnly,
+				Chan: b.expr(fn, recv.X),
+				Pos:  recv.OpPos,
+			}
+			if debugInfo {
+				st.DebugNode = recv
+			}
+		}
+		states = append(states, st)
+	}
+
+	// We dispatch on the (fair) result of Select using a
+	// sequential if-else chain, in effect:
+	//
+	// idx, recvOk, r0...r_n-1 := select(...)
+	// if idx == 0 {  // receive on channel 0  (first receive => r0)
+	//     x, ok := r0, recvOk
+	//     ...state0...
+	// } else if v == 1 {   // send on channel 1
+	//     ...state1...
+	// } else {
+	//     ...default...
+	// }
+	sel := &Select{
+		States:   states,
+		Blocking: blocking,
+	}
+	sel.setPos(s.Select)
+	var vars []*types.Var
+	vars = append(vars, varIndex, varOk)
+	for _, st := range states {
+		if st.Dir == types.RecvOnly {
+			tElem := st.Chan.Type().Underlying().(*types.Chan).Elem()
+			vars = append(vars, anonVar(tElem))
+		}
+	}
+	sel.setType(types.NewTuple(vars...))
+
+	fn.emit(sel)
+	idx := emitExtract(fn, sel, 0)
+
+	done := fn.newBasicBlock("select.done")
+	if label != nil {
+		label._break = done
+	}
+
+	var defaultBody *[]ast.Stmt
+	state := 0
+	r := 2 // index in 'sel' tuple of value; increments if st.Dir==RECV
+	for _, cc := range s.Body.List {
+		clause := cc.(*ast.CommClause)
+		if clause.Comm == nil {
+			defaultBody = &clause.Body
+			continue
+		}
+		body := fn.newBasicBlock("select.body")
+		next := fn.newBasicBlock("select.next")
+		emitIf(fn, emitCompare(fn, token.EQL, idx, intConst(int64(state)), token.NoPos), body, next)
+		fn.currentBlock = body
+		fn.targets = &targets{
+			tail:   fn.targets,
+			_break: done,
+		}
+		switch comm := clause.Comm.(type) {
+		case *ast.ExprStmt: // <-ch
+			if debugInfo {
+				v := emitExtract(fn, sel, r)
+				emitDebugRef(fn, states[state].DebugNode.(ast.Expr), v, false)
+			}
+			r++
+
+		case *ast.AssignStmt: // x := <-states[state].Chan
+			if comm.Tok == token.DEFINE {
+				fn.addLocalForIdent(comm.Lhs[0].(*ast.Ident))
+			}
+			x := b.addr(fn, comm.Lhs[0], false) // non-escaping
+			v := emitExtract(fn, sel, r)
+			if debugInfo {
+				emitDebugRef(fn, states[state].DebugNode.(ast.Expr), v, false)
+			}
+			x.store(fn, v)
+
+			if len(comm.Lhs) == 2 { // x, ok := ...
+				if comm.Tok == token.DEFINE {
+					fn.addLocalForIdent(comm.Lhs[1].(*ast.Ident))
+				}
+				ok := b.addr(fn, comm.Lhs[1], false) // non-escaping
+				ok.store(fn, emitExtract(fn, sel, 1))
+			}
+			r++
+		}
+		b.stmtList(fn, clause.Body)
+		fn.targets = fn.targets.tail
+		emitJump(fn, done)
+		fn.currentBlock = next
+		state++
+	}
+	if defaultBody != nil {
+		fn.targets = &targets{
+			tail:   fn.targets,
+			_break: done,
+		}
+		b.stmtList(fn, *defaultBody)
+		fn.targets = fn.targets.tail
+	} else {
+		// A blocking select must match some case.
+		// (This should really be a runtime.errorString, not a string.)
+		fn.emit(&Panic{
+			X: emitConv(fn, stringConst("blocking select matched no case"), tEface),
+		})
+		fn.currentBlock = fn.newBasicBlock("unreachable")
+	}
+	emitJump(fn, done)
+	fn.currentBlock = done
+}
+
+// forStmt emits to fn code for the for statement s, optionally
+// labelled by label.
+//
+func (b *builder) forStmt(fn *Function, s *ast.ForStmt, label *lblock) {
+	//	...init...
+	//      jump loop
+	// loop:
+	//      if cond goto body else done
+	// body:
+	//      ...body...
+	//      jump post
+	// post:				 (target of continue)
+	//      ...post...
+	//      jump loop
+	// done:                                 (target of break)
+	if s.Init != nil {
+		b.stmt(fn, s.Init)
+	}
+	body := fn.newBasicBlock("for.body")
+	done := fn.newBasicBlock("for.done") // target of 'break'
+	loop := body                         // target of back-edge
+	if s.Cond != nil {
+		loop = fn.newBasicBlock("for.loop")
+	}
+	cont := loop // target of 'continue'
+	if s.Post != nil {
+		cont = fn.newBasicBlock("for.post")
+	}
+	if label != nil {
+		label._break = done
+		label._continue = cont
+	}
+	emitJump(fn, loop)
+	fn.currentBlock = loop
+	if loop != body {
+		b.cond(fn, s.Cond, body, done)
+		fn.currentBlock = body
+	}
+	fn.targets = &targets{
+		tail:      fn.targets,
+		_break:    done,
+		_continue: cont,
+	}
+	b.stmt(fn, s.Body)
+	fn.targets = fn.targets.tail
+	emitJump(fn, cont)
+
+	if s.Post != nil {
+		fn.currentBlock = cont
+		b.stmt(fn, s.Post)
+		emitJump(fn, loop) // back-edge
+	}
+	fn.currentBlock = done
+}
+
+// rangeIndexed emits to fn the header for an integer-indexed loop
+// over array, *array or slice value x.
+// The v result is defined only if tv is non-nil.
+// forPos is the position of the "for" token.
+//
+func (b *builder) rangeIndexed(fn *Function, x Value, tv types.Type, pos token.Pos) (k, v Value, loop, done *BasicBlock) {
+	//
+	//      length = len(x)
+	//      index = -1
+	// loop:                                   (target of continue)
+	//      index++
+	// 	if index < length goto body else done
+	// body:
+	//      k = index
+	//      v = x[index]
+	//      ...body...
+	// 	jump loop
+	// done:                                   (target of break)
+
+	// Determine number of iterations.
+	var length Value
+	if arr, ok := deref(x.Type()).Underlying().(*types.Array); ok {
+		// For array or *array, the number of iterations is
+		// known statically thanks to the type.  We avoid a
+		// data dependence upon x, permitting later dead-code
+		// elimination if x is pure, static unrolling, etc.
+		// Ranging over a nil *array may have >0 iterations.
+		// We still generate code for x, in case it has effects.
+		length = intConst(arr.Len())
+	} else {
+		// length = len(x).
+		var c Call
+		c.Call.Value = makeLen(x.Type())
+		c.Call.Args = []Value{x}
+		c.setType(tInt)
+		length = fn.emit(&c)
+	}
+
+	index := fn.addLocal(tInt, token.NoPos)
+	emitStore(fn, index, intConst(-1), pos)
+
+	loop = fn.newBasicBlock("rangeindex.loop")
+	emitJump(fn, loop)
+	fn.currentBlock = loop
+
+	incr := &BinOp{
+		Op: token.ADD,
+		X:  emitLoad(fn, index),
+		Y:  vOne,
+	}
+	incr.setType(tInt)
+	emitStore(fn, index, fn.emit(incr), pos)
+
+	body := fn.newBasicBlock("rangeindex.body")
+	done = fn.newBasicBlock("rangeindex.done")
+	emitIf(fn, emitCompare(fn, token.LSS, incr, length, token.NoPos), body, done)
+	fn.currentBlock = body
+
+	k = emitLoad(fn, index)
+	if tv != nil {
+		switch t := x.Type().Underlying().(type) {
+		case *types.Array:
+			instr := &Index{
+				X:     x,
+				Index: k,
+			}
+			instr.setType(t.Elem())
+			v = fn.emit(instr)
+
+		case *types.Pointer: // *array
+			instr := &IndexAddr{
+				X:     x,
+				Index: k,
+			}
+			instr.setType(types.NewPointer(t.Elem().Underlying().(*types.Array).Elem()))
+			v = emitLoad(fn, fn.emit(instr))
+
+		case *types.Slice:
+			instr := &IndexAddr{
+				X:     x,
+				Index: k,
+			}
+			instr.setType(types.NewPointer(t.Elem()))
+			v = emitLoad(fn, fn.emit(instr))
+
+		default:
+			panic("rangeIndexed x:" + t.String())
+		}
+	}
+	return
+}
+
+// rangeIter emits to fn the header for a loop using
+// Range/Next/Extract to iterate over map or string value x.
+// tk and tv are the types of the key/value results k and v, or nil
+// if the respective component is not wanted.
+//
+func (b *builder) rangeIter(fn *Function, x Value, tk, tv types.Type, pos token.Pos) (k, v Value, loop, done *BasicBlock) {
+	//
+	//	it = range x
+	// loop:                                   (target of continue)
+	//	okv = next it                      (ok, key, value)
+	//  	ok = extract okv #0
+	// 	if ok goto body else done
+	// body:
+	// 	k = extract okv #1
+	// 	v = extract okv #2
+	//      ...body...
+	// 	jump loop
+	// done:                                   (target of break)
+	//
+
+	if tk == nil {
+		tk = tInvalid
+	}
+	if tv == nil {
+		tv = tInvalid
+	}
+
+	rng := &Range{X: x}
+	rng.setPos(pos)
+	rng.setType(tRangeIter)
+	it := fn.emit(rng)
+
+	loop = fn.newBasicBlock("rangeiter.loop")
+	emitJump(fn, loop)
+	fn.currentBlock = loop
+
+	_, isString := x.Type().Underlying().(*types.Basic)
+
+	okv := &Next{
+		Iter:     it,
+		IsString: isString,
+	}
+	okv.setType(types.NewTuple(
+		varOk,
+		newVar("k", tk),
+		newVar("v", tv),
+	))
+	fn.emit(okv)
+
+	body := fn.newBasicBlock("rangeiter.body")
+	done = fn.newBasicBlock("rangeiter.done")
+	emitIf(fn, emitExtract(fn, okv, 0), body, done)
+	fn.currentBlock = body
+
+	if tk != tInvalid {
+		k = emitExtract(fn, okv, 1)
+	}
+	if tv != tInvalid {
+		v = emitExtract(fn, okv, 2)
+	}
+	return
+}
+
+// rangeChan emits to fn the header for a loop that receives from
+// channel x until it fails.
+// tk is the channel's element type, or nil if the k result is
+// not wanted
+// pos is the position of the '=' or ':=' token.
+//
+func (b *builder) rangeChan(fn *Function, x Value, tk types.Type, pos token.Pos) (k Value, loop, done *BasicBlock) {
+	//
+	// loop:                                   (target of continue)
+	//      ko = <-x                           (key, ok)
+	//      ok = extract ko #1
+	//      if ok goto body else done
+	// body:
+	//      k = extract ko #0
+	//      ...
+	//      goto loop
+	// done:                                   (target of break)
+
+	loop = fn.newBasicBlock("rangechan.loop")
+	emitJump(fn, loop)
+	fn.currentBlock = loop
+	recv := &UnOp{
+		Op:      token.ARROW,
+		X:       x,
+		CommaOk: true,
+	}
+	recv.setPos(pos)
+	recv.setType(types.NewTuple(
+		newVar("k", x.Type().Underlying().(*types.Chan).Elem()),
+		varOk,
+	))
+	ko := fn.emit(recv)
+	body := fn.newBasicBlock("rangechan.body")
+	done = fn.newBasicBlock("rangechan.done")
+	emitIf(fn, emitExtract(fn, ko, 1), body, done)
+	fn.currentBlock = body
+	if tk != nil {
+		k = emitExtract(fn, ko, 0)
+	}
+	return
+}
+
+// rangeStmt emits to fn code for the range statement s, optionally
+// labelled by label.
+//
+func (b *builder) rangeStmt(fn *Function, s *ast.RangeStmt, label *lblock) {
+	var tk, tv types.Type
+	if s.Key != nil && !isBlankIdent(s.Key) {
+		tk = fn.Pkg.typeOf(s.Key)
+	}
+	if s.Value != nil && !isBlankIdent(s.Value) {
+		tv = fn.Pkg.typeOf(s.Value)
+	}
+
+	// If iteration variables are defined (:=), this
+	// occurs once outside the loop.
+	//
+	// Unlike a short variable declaration, a RangeStmt
+	// using := never redeclares an existing variable; it
+	// always creates a new one.
+	if s.Tok == token.DEFINE {
+		if tk != nil {
+			fn.addLocalForIdent(s.Key.(*ast.Ident))
+		}
+		if tv != nil {
+			fn.addLocalForIdent(s.Value.(*ast.Ident))
+		}
+	}
+
+	x := b.expr(fn, s.X)
+
+	var k, v Value
+	var loop, done *BasicBlock
+	switch rt := x.Type().Underlying().(type) {
+	case *types.Slice, *types.Array, *types.Pointer: // *array
+		k, v, loop, done = b.rangeIndexed(fn, x, tv, s.For)
+
+	case *types.Chan:
+		k, loop, done = b.rangeChan(fn, x, tk, s.For)
+
+	case *types.Map, *types.Basic: // string
+		k, v, loop, done = b.rangeIter(fn, x, tk, tv, s.For)
+
+	default:
+		panic("Cannot range over: " + rt.String())
+	}
+
+	// Evaluate both LHS expressions before we update either.
+	var kl, vl lvalue
+	if tk != nil {
+		kl = b.addr(fn, s.Key, false) // non-escaping
+	}
+	if tv != nil {
+		vl = b.addr(fn, s.Value, false) // non-escaping
+	}
+	if tk != nil {
+		kl.store(fn, k)
+	}
+	if tv != nil {
+		vl.store(fn, v)
+	}
+
+	if label != nil {
+		label._break = done
+		label._continue = loop
+	}
+
+	fn.targets = &targets{
+		tail:      fn.targets,
+		_break:    done,
+		_continue: loop,
+	}
+	b.stmt(fn, s.Body)
+	fn.targets = fn.targets.tail
+	emitJump(fn, loop) // back-edge
+	fn.currentBlock = done
+}
+
+// stmt lowers statement s to SSA form, emitting code to fn.
+func (b *builder) stmt(fn *Function, _s ast.Stmt) {
+	// The label of the current statement.  If non-nil, its _goto
+	// target is always set; its _break and _continue are set only
+	// within the body of switch/typeswitch/select/for/range.
+	// It is effectively an additional default-nil parameter of stmt().
+	var label *lblock
+start:
+	switch s := _s.(type) {
+	case *ast.EmptyStmt:
+		// ignore.  (Usually removed by gofmt.)
+
+	case *ast.DeclStmt: // Con, Var or Typ
+		d := s.Decl.(*ast.GenDecl)
+		if d.Tok == token.VAR {
+			for _, spec := range d.Specs {
+				if vs, ok := spec.(*ast.ValueSpec); ok {
+					b.localValueSpec(fn, vs)
+				}
+			}
+		}
+
+	case *ast.LabeledStmt:
+		label = fn.labelledBlock(s.Label)
+		emitJump(fn, label._goto)
+		fn.currentBlock = label._goto
+		_s = s.Stmt
+		goto start // effectively: tailcall stmt(fn, s.Stmt, label)
+
+	case *ast.ExprStmt:
+		b.expr(fn, s.X)
+
+	case *ast.SendStmt:
+		fn.emit(&Send{
+			Chan: b.expr(fn, s.Chan),
+			X: emitConv(fn, b.expr(fn, s.Value),
+				fn.Pkg.typeOf(s.Chan).Underlying().(*types.Chan).Elem()),
+			pos: s.Arrow,
+		})
+
+	case *ast.IncDecStmt:
+		op := token.ADD
+		if s.Tok == token.DEC {
+			op = token.SUB
+		}
+		loc := b.addr(fn, s.X, false)
+		b.assignOp(fn, loc, NewConst(exact.MakeInt64(1), loc.typ()), op)
+
+	case *ast.AssignStmt:
+		switch s.Tok {
+		case token.ASSIGN, token.DEFINE:
+			b.assignStmt(fn, s.Lhs, s.Rhs, s.Tok == token.DEFINE)
+
+		default: // +=, etc.
+			op := s.Tok + token.ADD - token.ADD_ASSIGN
+			b.assignOp(fn, b.addr(fn, s.Lhs[0], false), b.expr(fn, s.Rhs[0]), op)
+		}
+
+	case *ast.GoStmt:
+		// The "intrinsics" new/make/len/cap are forbidden here.
+		// panic is treated like an ordinary function call.
+		v := Go{pos: s.Go}
+		b.setCall(fn, s.Call, &v.Call)
+		fn.emit(&v)
+
+	case *ast.DeferStmt:
+		// The "intrinsics" new/make/len/cap are forbidden here.
+		// panic is treated like an ordinary function call.
+		v := Defer{pos: s.Defer}
+		b.setCall(fn, s.Call, &v.Call)
+		fn.emit(&v)
+
+		// A deferred call can cause recovery from panic,
+		// and control resumes at the Recover block.
+		createRecoverBlock(fn)
+
+	case *ast.ReturnStmt:
+		var results []Value
+		if len(s.Results) == 1 && fn.Signature.Results().Len() > 1 {
+			// Return of one expression in a multi-valued function.
+			tuple := b.exprN(fn, s.Results[0])
+			ttuple := tuple.Type().(*types.Tuple)
+			for i, n := 0, ttuple.Len(); i < n; i++ {
+				results = append(results,
+					emitConv(fn, emitExtract(fn, tuple, i),
+						fn.Signature.Results().At(i).Type()))
+			}
+		} else {
+			// 1:1 return, or no-arg return in non-void function.
+			for i, r := range s.Results {
+				v := emitConv(fn, b.expr(fn, r), fn.Signature.Results().At(i).Type())
+				results = append(results, v)
+			}
+		}
+		if fn.namedResults != nil {
+			// Function has named result parameters (NRPs).
+			// Perform parallel assignment of return operands to NRPs.
+			for i, r := range results {
+				emitStore(fn, fn.namedResults[i], r, s.Return)
+			}
+		}
+		// Run function calls deferred in this
+		// function when explicitly returning from it.
+		fn.emit(new(RunDefers))
+		if fn.namedResults != nil {
+			// Reload NRPs to form the result tuple.
+			results = results[:0]
+			for _, r := range fn.namedResults {
+				results = append(results, emitLoad(fn, r))
+			}
+		}
+		fn.emit(&Return{Results: results, pos: s.Return})
+		fn.currentBlock = fn.newBasicBlock("unreachable")
+
+	case *ast.BranchStmt:
+		var block *BasicBlock
+		switch s.Tok {
+		case token.BREAK:
+			if s.Label != nil {
+				block = fn.labelledBlock(s.Label)._break
+			} else {
+				for t := fn.targets; t != nil && block == nil; t = t.tail {
+					block = t._break
+				}
+			}
+
+		case token.CONTINUE:
+			if s.Label != nil {
+				block = fn.labelledBlock(s.Label)._continue
+			} else {
+				for t := fn.targets; t != nil && block == nil; t = t.tail {
+					block = t._continue
+				}
+			}
+
+		case token.FALLTHROUGH:
+			for t := fn.targets; t != nil && block == nil; t = t.tail {
+				block = t._fallthrough
+			}
+
+		case token.GOTO:
+			block = fn.labelledBlock(s.Label)._goto
+		}
+		emitJump(fn, block)
+		fn.currentBlock = fn.newBasicBlock("unreachable")
+
+	case *ast.BlockStmt:
+		b.stmtList(fn, s.List)
+
+	case *ast.IfStmt:
+		if s.Init != nil {
+			b.stmt(fn, s.Init)
+		}
+		then := fn.newBasicBlock("if.then")
+		done := fn.newBasicBlock("if.done")
+		els := done
+		if s.Else != nil {
+			els = fn.newBasicBlock("if.else")
+		}
+		b.cond(fn, s.Cond, then, els)
+		fn.currentBlock = then
+		b.stmt(fn, s.Body)
+		emitJump(fn, done)
+
+		if s.Else != nil {
+			fn.currentBlock = els
+			b.stmt(fn, s.Else)
+			emitJump(fn, done)
+		}
+
+		fn.currentBlock = done
+
+	case *ast.SwitchStmt:
+		b.switchStmt(fn, s, label)
+
+	case *ast.TypeSwitchStmt:
+		b.typeSwitchStmt(fn, s, label)
+
+	case *ast.SelectStmt:
+		b.selectStmt(fn, s, label)
+
+	case *ast.ForStmt:
+		b.forStmt(fn, s, label)
+
+	case *ast.RangeStmt:
+		b.rangeStmt(fn, s, label)
+
+	default:
+		panic(fmt.Sprintf("unexpected statement kind: %T", s))
+	}
+}
+
+// buildFunction builds SSA code for the body of function fn.  Idempotent.
+func (b *builder) buildFunction(fn *Function) {
+	if fn.Blocks != nil {
+		return // building already started
+	}
+
+	var recvField *ast.FieldList
+	var body *ast.BlockStmt
+	var functype *ast.FuncType
+	switch n := fn.syntax.(type) {
+	case nil:
+		return // not a Go source function.  (Synthetic, or from object file.)
+	case *ast.FuncDecl:
+		functype = n.Type
+		recvField = n.Recv
+		body = n.Body
+	case *ast.FuncLit:
+		functype = n.Type
+		body = n.Body
+	default:
+		panic(n)
+	}
+
+	if body == nil {
+		// External function.
+		if fn.Params == nil {
+			// This condition ensures we add a non-empty
+			// params list once only, but we may attempt
+			// the degenerate empty case repeatedly.
+			// TODO(adonovan): opt: don't do that.
+
+			// We set Function.Params even though there is no body
+			// code to reference them.  This simplifies clients.
+			if recv := fn.Signature.Recv(); recv != nil {
+				fn.addParamObj(recv)
+			}
+			params := fn.Signature.Params()
+			for i, n := 0, params.Len(); i < n; i++ {
+				fn.addParamObj(params.At(i))
+			}
+		}
+		return
+	}
+	if fn.Prog.mode&LogSource != 0 {
+		defer logStack("build function %s @ %s", fn, fn.Prog.Fset.Position(fn.pos))()
+	}
+	fn.startBody()
+	fn.createSyntacticParams(recvField, functype)
+	b.stmt(fn, body)
+	if cb := fn.currentBlock; cb != nil && (cb == fn.Blocks[0] || cb == fn.Recover || cb.Preds != nil) {
+		// Control fell off the end of the function's body block.
+		//
+		// Block optimizations eliminate the current block, if
+		// unreachable.  It is a builder invariant that
+		// if this no-arg return is ill-typed for
+		// fn.Signature.Results, this block must be
+		// unreachable.  The sanity checker checks this.
+		fn.emit(new(RunDefers))
+		fn.emit(new(Return))
+	}
+	fn.finishBody()
+}
+
+// buildFuncDecl builds SSA code for the function or method declared
+// by decl in package pkg.
+//
+func (b *builder) buildFuncDecl(pkg *Package, decl *ast.FuncDecl) {
+	id := decl.Name
+	if isBlankIdent(id) {
+		return // discard
+	}
+	fn := pkg.values[pkg.info.Defs[id]].(*Function)
+	if decl.Recv == nil && id.Name == "init" {
+		var v Call
+		v.Call.Value = fn
+		v.setType(types.NewTuple())
+		pkg.init.emit(&v)
+	}
+	b.buildFunction(fn)
+}
+
+// Build calls Package.Build for each package in prog.
+// Building occurs in parallel unless the BuildSerially mode flag was set.
+//
+// Build is intended for whole-program analysis; a typical compiler
+// need only build a single package.
+//
+// Build is idempotent and thread-safe.
+//
+func (prog *Program) Build() {
+	var wg sync.WaitGroup
+	for _, p := range prog.packages {
+		if prog.mode&BuildSerially != 0 {
+			p.Build()
+		} else {
+			wg.Add(1)
+			go func(p *Package) {
+				p.Build()
+				wg.Done()
+			}(p)
+		}
+	}
+	wg.Wait()
+}
+
+// Build builds SSA code for all functions and vars in package p.
+//
+// Precondition: CreatePackage must have been called for all of p's
+// direct imports (and hence its direct imports must have been
+// error-free).
+//
+// Build is idempotent and thread-safe.
+//
+func (p *Package) Build() { p.buildOnce.Do(p.build) }
+
+func (p *Package) build() {
+	if p.info == nil {
+		return // synthetic package, e.g. "testmain"
+	}
+
+	// Ensure we have runtime type info for all exported members.
+	// TODO(adonovan): ideally belongs in memberFromObject, but
+	// that would require package creation in topological order.
+	for name, mem := range p.Members {
+		if ast.IsExported(name) {
+			p.Prog.needMethodsOf(mem.Type())
+		}
+	}
+	if p.Prog.mode&LogSource != 0 {
+		defer logStack("build %s", p)()
+	}
+	init := p.init
+	init.startBody()
+
+	var done *BasicBlock
+
+	if p.Prog.mode&BareInits == 0 {
+		// Make init() skip if package is already initialized.
+		initguard := p.Var("init$guard")
+		doinit := init.newBasicBlock("init.start")
+		done = init.newBasicBlock("init.done")
+		emitIf(init, emitLoad(init, initguard), done, doinit)
+		init.currentBlock = doinit
+		emitStore(init, initguard, vTrue, token.NoPos)
+
+		// Call the init() function of each package we import.
+		for _, pkg := range p.Pkg.Imports() {
+			prereq := p.Prog.packages[pkg]
+			if prereq == nil {
+				panic(fmt.Sprintf("Package(%q).Build(): unsatisfied import: Program.CreatePackage(%q) was not called", p.Pkg.Path(), pkg.Path()))
+			}
+			var v Call
+			v.Call.Value = prereq.init
+			v.Call.pos = init.pos
+			v.setType(types.NewTuple())
+			init.emit(&v)
+		}
+	}
+
+	var b builder
+
+	// Initialize package-level vars in correct order.
+	for _, varinit := range p.info.InitOrder {
+		if init.Prog.mode&LogSource != 0 {
+			fmt.Fprintf(os.Stderr, "build global initializer %v @ %s\n",
+				varinit.Lhs, p.Prog.Fset.Position(varinit.Rhs.Pos()))
+		}
+		if len(varinit.Lhs) == 1 {
+			// 1:1 initialization: var x, y = a(), b()
+			var lval lvalue
+			if v := varinit.Lhs[0]; v.Name() != "_" {
+				lval = &address{addr: p.values[v].(*Global), pos: v.Pos()}
+			} else {
+				lval = blank{}
+			}
+			b.assign(init, lval, varinit.Rhs, true, nil)
+		} else {
+			// n:1 initialization: var x, y :=  f()
+			tuple := b.exprN(init, varinit.Rhs)
+			for i, v := range varinit.Lhs {
+				if v.Name() == "_" {
+					continue
+				}
+				emitStore(init, p.values[v].(*Global), emitExtract(init, tuple, i), v.Pos())
+			}
+		}
+	}
+
+	// Build all package-level functions, init functions
+	// and methods, including unreachable/blank ones.
+	// We build them in source order, but it's not significant.
+	for _, file := range p.files {
+		for _, decl := range file.Decls {
+			if decl, ok := decl.(*ast.FuncDecl); ok {
+				b.buildFuncDecl(p, decl)
+			}
+		}
+	}
+
+	// Finish up init().
+	if p.Prog.mode&BareInits == 0 {
+		emitJump(init, done)
+		init.currentBlock = done
+	}
+	init.emit(new(Return))
+	init.finishBody()
+
+	p.info = nil // We no longer need ASTs or go/types deductions.
+
+	if p.Prog.mode&SanityCheckFunctions != 0 {
+		sanityCheckPackage(p)
+	}
+}
+
+// Like ObjectOf, but panics instead of returning nil.
+// Only valid during p's create and build phases.
+func (p *Package) objectOf(id *ast.Ident) types.Object {
+	if o := p.info.ObjectOf(id); o != nil {
+		return o
+	}
+	panic(fmt.Sprintf("no types.Object for ast.Ident %s @ %s",
+		id.Name, p.Prog.Fset.Position(id.Pos())))
+}
+
+// Like TypeOf, but panics instead of returning nil.
+// Only valid during p's create and build phases.
+func (p *Package) typeOf(e ast.Expr) types.Type {
+	if T := p.info.TypeOf(e); T != nil {
+		return T
+	}
+	panic(fmt.Sprintf("no type for %T @ %s",
+		e, p.Prog.Fset.Position(e.Pos())))
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/const.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/const.go
new file mode 100644
index 00000000..2870eea5
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/const.go
@@ -0,0 +1,169 @@
+// 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 ssa
+
+// This file defines the Const SSA value type.
+
+import (
+	"fmt"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// NewConst returns a new constant of the specified value and type.
+// val must be valid according to the specification of Const.Value.
+//
+func NewConst(val exact.Value, typ types.Type) *Const {
+	return &Const{typ, val}
+}
+
+// intConst returns an 'int' constant that evaluates to i.
+// (i is an int64 in case the host is narrower than the target.)
+func intConst(i int64) *Const {
+	return NewConst(exact.MakeInt64(i), tInt)
+}
+
+// nilConst returns a nil constant of the specified type, which may
+// be any reference type, including interfaces.
+//
+func nilConst(typ types.Type) *Const {
+	return NewConst(nil, typ)
+}
+
+// stringConst returns a 'string' constant that evaluates to s.
+func stringConst(s string) *Const {
+	return NewConst(exact.MakeString(s), tString)
+}
+
+// zeroConst returns a new "zero" constant of the specified type,
+// which must not be an array or struct type: the zero values of
+// aggregates are well-defined but cannot be represented by Const.
+//
+func zeroConst(t types.Type) *Const {
+	switch t := t.(type) {
+	case *types.Basic:
+		switch {
+		case t.Info()&types.IsBoolean != 0:
+			return NewConst(exact.MakeBool(false), t)
+		case t.Info()&types.IsNumeric != 0:
+			return NewConst(exact.MakeInt64(0), t)
+		case t.Info()&types.IsString != 0:
+			return NewConst(exact.MakeString(""), t)
+		case t.Kind() == types.UnsafePointer:
+			fallthrough
+		case t.Kind() == types.UntypedNil:
+			return nilConst(t)
+		default:
+			panic(fmt.Sprint("zeroConst for unexpected type:", t))
+		}
+	case *types.Pointer, *types.Slice, *types.Interface, *types.Chan, *types.Map, *types.Signature:
+		return nilConst(t)
+	case *types.Named:
+		return NewConst(zeroConst(t.Underlying()).Value, t)
+	case *types.Array, *types.Struct, *types.Tuple:
+		panic(fmt.Sprint("zeroConst applied to aggregate:", t))
+	}
+	panic(fmt.Sprint("zeroConst: unexpected ", t))
+}
+
+func (c *Const) RelString(from *types.Package) string {
+	var s string
+	if c.Value == nil {
+		s = "nil"
+	} else if c.Value.Kind() == exact.String {
+		s = exact.StringVal(c.Value)
+		const max = 20
+		// TODO(adonovan): don't cut a rune in half.
+		if len(s) > max {
+			s = s[:max-3] + "..." // abbreviate
+		}
+		s = strconv.Quote(s)
+	} else {
+		s = c.Value.String()
+	}
+	return s + ":" + relType(c.Type(), from)
+}
+
+func (c *Const) Name() string {
+	return c.RelString(nil)
+}
+
+func (c *Const) String() string {
+	return c.Name()
+}
+
+func (c *Const) Type() types.Type {
+	return c.typ
+}
+
+func (c *Const) Referrers() *[]Instruction {
+	return nil
+}
+
+func (c *Const) Parent() *Function { return nil }
+
+func (c *Const) Pos() token.Pos {
+	return token.NoPos
+}
+
+// IsNil returns true if this constant represents a typed or untyped nil value.
+func (c *Const) IsNil() bool {
+	return c.Value == nil
+}
+
+// TODO(adonovan): move everything below into golang.org/x/tools/go/ssa/interp.
+
+// Int64 returns the numeric value of this constant truncated to fit
+// a signed 64-bit integer.
+//
+func (c *Const) Int64() int64 {
+	switch x := exact.ToInt(c.Value); x.Kind() {
+	case exact.Int:
+		if i, ok := exact.Int64Val(x); ok {
+			return i
+		}
+		return 0
+	case exact.Float:
+		f, _ := exact.Float64Val(x)
+		return int64(f)
+	}
+	panic(fmt.Sprintf("unexpected constant value: %T", c.Value))
+}
+
+// Uint64 returns the numeric value of this constant truncated to fit
+// an unsigned 64-bit integer.
+//
+func (c *Const) Uint64() uint64 {
+	switch x := exact.ToInt(c.Value); x.Kind() {
+	case exact.Int:
+		if u, ok := exact.Uint64Val(x); ok {
+			return u
+		}
+		return 0
+	case exact.Float:
+		f, _ := exact.Float64Val(x)
+		return uint64(f)
+	}
+	panic(fmt.Sprintf("unexpected constant value: %T", c.Value))
+}
+
+// Float64 returns the numeric value of this constant truncated to fit
+// a float64.
+//
+func (c *Const) Float64() float64 {
+	f, _ := exact.Float64Val(c.Value)
+	return f
+}
+
+// Complex128 returns the complex value of this constant truncated to
+// fit a complex128.
+//
+func (c *Const) Complex128() complex128 {
+	re, _ := exact.Float64Val(exact.Real(c.Value))
+	im, _ := exact.Float64Val(exact.Imag(c.Value))
+	return complex(re, im)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/create.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/create.go
new file mode 100644
index 00000000..69ac12b1
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/create.go
@@ -0,0 +1,263 @@
+// 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 ssa
+
+// This file implements the CREATE phase of SSA construction.
+// See builder.go for explanation.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"os"
+	"sync"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// NewProgram returns a new SSA Program.
+//
+// mode controls diagnostics and checking during SSA construction.
+//
+func NewProgram(fset *token.FileSet, mode BuilderMode) *Program {
+	prog := &Program{
+		Fset:     fset,
+		imported: make(map[string]*Package),
+		packages: make(map[*types.Package]*Package),
+		thunks:   make(map[selectionKey]*Function),
+		bounds:   make(map[*types.Func]*Function),
+		mode:     mode,
+	}
+
+	h := typeutil.MakeHasher() // protected by methodsMu, in effect
+	prog.methodSets.SetHasher(h)
+	prog.canon.SetHasher(h)
+
+	return prog
+}
+
+// memberFromObject populates package pkg with a member for the
+// typechecker object obj.
+//
+// For objects from Go source code, syntax is the associated syntax
+// tree (for funcs and vars only); it will be used during the build
+// phase.
+//
+func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
+	name := obj.Name()
+	switch obj := obj.(type) {
+	case *types.Builtin:
+		if pkg.Pkg != types.Unsafe {
+			panic("unexpected builtin object: " + obj.String())
+		}
+
+	case *types.TypeName:
+		pkg.Members[name] = &Type{
+			object: obj,
+			pkg:    pkg,
+		}
+
+	case *types.Const:
+		c := &NamedConst{
+			object: obj,
+			Value:  NewConst(obj.Val(), obj.Type()),
+			pkg:    pkg,
+		}
+		pkg.values[obj] = c.Value
+		pkg.Members[name] = c
+
+	case *types.Var:
+		g := &Global{
+			Pkg:    pkg,
+			name:   name,
+			object: obj,
+			typ:    types.NewPointer(obj.Type()), // address
+			pos:    obj.Pos(),
+		}
+		pkg.values[obj] = g
+		pkg.Members[name] = g
+
+	case *types.Func:
+		sig := obj.Type().(*types.Signature)
+		if sig.Recv() == nil && name == "init" {
+			pkg.ninit++
+			name = fmt.Sprintf("init#%d", pkg.ninit)
+		}
+		fn := &Function{
+			name:      name,
+			object:    obj,
+			Signature: sig,
+			syntax:    syntax,
+			pos:       obj.Pos(),
+			Pkg:       pkg,
+			Prog:      pkg.Prog,
+		}
+		if syntax == nil {
+			fn.Synthetic = "loaded from gc object file"
+		}
+
+		pkg.values[obj] = fn
+		if sig.Recv() == nil {
+			pkg.Members[name] = fn // package-level function
+		}
+
+	default: // (incl. *types.Package)
+		panic("unexpected Object type: " + obj.String())
+	}
+}
+
+// membersFromDecl populates package pkg with members for each
+// typechecker object (var, func, const or type) associated with the
+// specified decl.
+//
+func membersFromDecl(pkg *Package, decl ast.Decl) {
+	switch decl := decl.(type) {
+	case *ast.GenDecl: // import, const, type or var
+		switch decl.Tok {
+		case token.CONST:
+			for _, spec := range decl.Specs {
+				for _, id := range spec.(*ast.ValueSpec).Names {
+					if !isBlankIdent(id) {
+						memberFromObject(pkg, pkg.info.Defs[id], nil)
+					}
+				}
+			}
+
+		case token.VAR:
+			for _, spec := range decl.Specs {
+				for _, id := range spec.(*ast.ValueSpec).Names {
+					if !isBlankIdent(id) {
+						memberFromObject(pkg, pkg.info.Defs[id], spec)
+					}
+				}
+			}
+
+		case token.TYPE:
+			for _, spec := range decl.Specs {
+				id := spec.(*ast.TypeSpec).Name
+				if !isBlankIdent(id) {
+					memberFromObject(pkg, pkg.info.Defs[id], nil)
+				}
+			}
+		}
+
+	case *ast.FuncDecl:
+		id := decl.Name
+		if !isBlankIdent(id) {
+			memberFromObject(pkg, pkg.info.Defs[id], decl)
+		}
+	}
+}
+
+// CreatePackage constructs and returns an SSA Package from the
+// specified type-checked, error-free file ASTs, and populates its
+// Members mapping.
+//
+// importable determines whether this package should be returned by a
+// subsequent call to ImportedPackage(pkg.Path()).
+//
+// The real work of building SSA form for each function is not done
+// until a subsequent call to Package.Build().
+//
+func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *types.Info, importable bool) *Package {
+	p := &Package{
+		Prog:    prog,
+		Members: make(map[string]Member),
+		values:  make(map[types.Object]Value),
+		Pkg:     pkg,
+		info:    info,  // transient (CREATE and BUILD phases)
+		files:   files, // transient (CREATE and BUILD phases)
+	}
+
+	// Add init() function.
+	p.init = &Function{
+		name:      "init",
+		Signature: new(types.Signature),
+		Synthetic: "package initializer",
+		Pkg:       p,
+		Prog:      prog,
+	}
+	p.Members[p.init.name] = p.init
+
+	// CREATE phase.
+	// Allocate all package members: vars, funcs, consts and types.
+	if len(files) > 0 {
+		// Go source package.
+		for _, file := range files {
+			for _, decl := range file.Decls {
+				membersFromDecl(p, decl)
+			}
+		}
+	} else {
+		// GC-compiled binary package (or "unsafe")
+		// No code.
+		// No position information.
+		scope := p.Pkg.Scope()
+		for _, name := range scope.Names() {
+			obj := scope.Lookup(name)
+			memberFromObject(p, obj, nil)
+			if obj, ok := obj.(*types.TypeName); ok {
+				if named, ok := obj.Type().(*types.Named); ok {
+					for i, n := 0, named.NumMethods(); i < n; i++ {
+						memberFromObject(p, named.Method(i), nil)
+					}
+				}
+			}
+		}
+	}
+
+	if prog.mode&BareInits == 0 {
+		// Add initializer guard variable.
+		initguard := &Global{
+			Pkg:  p,
+			name: "init$guard",
+			typ:  types.NewPointer(tBool),
+		}
+		p.Members[initguard.Name()] = initguard
+	}
+
+	if prog.mode&GlobalDebug != 0 {
+		p.SetDebugMode(true)
+	}
+
+	if prog.mode&PrintPackages != 0 {
+		printMu.Lock()
+		p.WriteTo(os.Stdout)
+		printMu.Unlock()
+	}
+
+	if importable {
+		prog.imported[p.Pkg.Path()] = p
+	}
+	prog.packages[p.Pkg] = p
+
+	return p
+}
+
+// printMu serializes printing of Packages/Functions to stdout.
+var printMu sync.Mutex
+
+// AllPackages returns a new slice containing all packages in the
+// program prog in unspecified order.
+//
+func (prog *Program) AllPackages() []*Package {
+	pkgs := make([]*Package, 0, len(prog.packages))
+	for _, pkg := range prog.packages {
+		pkgs = append(pkgs, pkg)
+	}
+	return pkgs
+}
+
+// ImportedPackage returns the importable SSA Package whose import
+// path is path, or nil if no such SSA package has been created.
+//
+// Not all packages are importable.  For example, no import
+// declaration can resolve to the x_test package created by 'go test'
+// or the ad-hoc main package created 'go build foo.go'.
+//
+func (prog *Program) ImportedPackage(path string) *Package {
+	return prog.imported[path]
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/doc.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/doc.go
new file mode 100644
index 00000000..2aa04f43
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/doc.go
@@ -0,0 +1,123 @@
+// 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 ssa defines a representation of the elements of Go programs
+// (packages, types, functions, variables and constants) using a
+// static single-assignment (SSA) form intermediate representation
+// (IR) for the bodies of functions.
+//
+// THIS INTERFACE IS EXPERIMENTAL AND IS LIKELY TO CHANGE.
+//
+// For an introduction to SSA form, see
+// http://en.wikipedia.org/wiki/Static_single_assignment_form.
+// This page provides a broader reading list:
+// http://www.dcs.gla.ac.uk/~jsinger/ssa.html.
+//
+// The level of abstraction of the SSA form is intentionally close to
+// the source language to facilitate construction of source analysis
+// tools.  It is not intended for machine code generation.
+//
+// All looping, branching and switching constructs are replaced with
+// unstructured control flow.  Higher-level control flow constructs
+// such as multi-way branch can be reconstructed as needed; see
+// ssautil.Switches() for an example.
+//
+// To construct an SSA-form program, call ssautil.CreateProgram on a
+// loader.Program, a set of type-checked packages created from
+// parsed Go source files.  The resulting ssa.Program contains all the
+// packages and their members, but SSA code is not created for
+// function bodies until a subsequent call to (*Package).Build.
+//
+// The builder initially builds a naive SSA form in which all local
+// variables are addresses of stack locations with explicit loads and
+// stores.  Registerisation of eligible locals and φ-node insertion
+// using dominance and dataflow are then performed as a second pass
+// called "lifting" to improve the accuracy and performance of
+// subsequent analyses; this pass can be skipped by setting the
+// NaiveForm builder flag.
+//
+// The primary interfaces of this package are:
+//
+//    - Member: a named member of a Go package.
+//    - Value: an expression that yields a value.
+//    - Instruction: a statement that consumes values and performs computation.
+//    - Node: a Value or Instruction (emphasizing its membership in the SSA value graph)
+//
+// A computation that yields a result implements both the Value and
+// Instruction interfaces.  The following table shows for each
+// concrete type which of these interfaces it implements.
+//
+//                      Value?          Instruction?    Member?
+//   *Alloc             ✔               ✔
+//   *BinOp             ✔               ✔
+//   *Builtin           ✔
+//   *Call              ✔               ✔
+//   *ChangeInterface   ✔               ✔
+//   *ChangeType        ✔               ✔
+//   *Const             ✔
+//   *Convert           ✔               ✔
+//   *DebugRef                          ✔
+//   *Defer                             ✔
+//   *Extract           ✔               ✔
+//   *Field             ✔               ✔
+//   *FieldAddr         ✔               ✔
+//   *FreeVar           ✔
+//   *Function          ✔                               ✔ (func)
+//   *Global            ✔                               ✔ (var)
+//   *Go                                ✔
+//   *If                                ✔
+//   *Index             ✔               ✔
+//   *IndexAddr         ✔               ✔
+//   *Jump                              ✔
+//   *Lookup            ✔               ✔
+//   *MakeChan          ✔               ✔
+//   *MakeClosure       ✔               ✔
+//   *MakeInterface     ✔               ✔
+//   *MakeMap           ✔               ✔
+//   *MakeSlice         ✔               ✔
+//   *MapUpdate                         ✔
+//   *NamedConst                                        ✔ (const)
+//   *Next              ✔               ✔
+//   *Panic                             ✔
+//   *Parameter         ✔
+//   *Phi               ✔               ✔
+//   *Range             ✔               ✔
+//   *Return                            ✔
+//   *RunDefers                         ✔
+//   *Select            ✔               ✔
+//   *Send                              ✔
+//   *Slice             ✔               ✔
+//   *Store                             ✔
+//   *Type                                              ✔ (type)
+//   *TypeAssert        ✔               ✔
+//   *UnOp              ✔               ✔
+//
+// Other key types in this package include: Program, Package, Function
+// and BasicBlock.
+//
+// The program representation constructed by this package is fully
+// resolved internally, i.e. it does not rely on the names of Values,
+// Packages, Functions, Types or BasicBlocks for the correct
+// interpretation of the program.  Only the identities of objects and
+// the topology of the SSA and type graphs are semantically
+// significant.  (There is one exception: Ids, used to identify field
+// and method names, contain strings.)  Avoidance of name-based
+// operations simplifies the implementation of subsequent passes and
+// can make them very efficient.  Many objects are nonetheless named
+// to aid in debugging, but it is not essential that the names be
+// either accurate or unambiguous.  The public API exposes a number of
+// name-based maps for client convenience.
+//
+// The ssa/ssautil package provides various utilities that depend only
+// on the public API of this package.
+//
+// TODO(adonovan): Consider the exceptional control-flow implications
+// of defer and recover().
+//
+// TODO(adonovan): write a how-to document for all the various cases
+// of trying to determine corresponding elements across the four
+// domains of source locations, ast.Nodes, types.Objects,
+// ssa.Values/Instructions.
+//
+package ssa // import "golang.org/x/tools/go/ssa"
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/dom.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/dom.go
new file mode 100644
index 00000000..12ef4308
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/dom.go
@@ -0,0 +1,341 @@
+// 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 ssa
+
+// This file defines algorithms related to dominance.
+
+// Dominator tree construction ----------------------------------------
+//
+// We use the algorithm described in Lengauer & Tarjan. 1979.  A fast
+// algorithm for finding dominators in a flowgraph.
+// http://doi.acm.org/10.1145/357062.357071
+//
+// We also apply the optimizations to SLT described in Georgiadis et
+// al, Finding Dominators in Practice, JGAA 2006,
+// http://jgaa.info/accepted/2006/GeorgiadisTarjanWerneck2006.10.1.pdf
+// to avoid the need for buckets of size > 1.
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"os"
+	"sort"
+)
+
+// Idom returns the block that immediately dominates b:
+// its parent in the dominator tree, if any.
+// Neither the entry node (b.Index==0) nor recover node
+// (b==b.Parent().Recover()) have a parent.
+//
+func (b *BasicBlock) Idom() *BasicBlock { return b.dom.idom }
+
+// Dominees returns the list of blocks that b immediately dominates:
+// its children in the dominator tree.
+//
+func (b *BasicBlock) Dominees() []*BasicBlock { return b.dom.children }
+
+// Dominates reports whether b dominates c.
+func (b *BasicBlock) Dominates(c *BasicBlock) bool {
+	return b.dom.pre <= c.dom.pre && c.dom.post <= b.dom.post
+}
+
+type byDomPreorder []*BasicBlock
+
+func (a byDomPreorder) Len() int           { return len(a) }
+func (a byDomPreorder) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byDomPreorder) Less(i, j int) bool { return a[i].dom.pre < a[j].dom.pre }
+
+// DomPreorder returns a new slice containing the blocks of f in
+// dominator tree preorder.
+//
+func (f *Function) DomPreorder() []*BasicBlock {
+	n := len(f.Blocks)
+	order := make(byDomPreorder, n, n)
+	copy(order, f.Blocks)
+	sort.Sort(order)
+	return order
+}
+
+// domInfo contains a BasicBlock's dominance information.
+type domInfo struct {
+	idom      *BasicBlock   // immediate dominator (parent in domtree)
+	children  []*BasicBlock // nodes immediately dominated by this one
+	pre, post int32         // pre- and post-order numbering within domtree
+}
+
+// ltState holds the working state for Lengauer-Tarjan algorithm
+// (during which domInfo.pre is repurposed for CFG DFS preorder number).
+type ltState struct {
+	// Each slice is indexed by b.Index.
+	sdom     []*BasicBlock // b's semidominator
+	parent   []*BasicBlock // b's parent in DFS traversal of CFG
+	ancestor []*BasicBlock // b's ancestor with least sdom
+}
+
+// dfs implements the depth-first search part of the LT algorithm.
+func (lt *ltState) dfs(v *BasicBlock, i int32, preorder []*BasicBlock) int32 {
+	preorder[i] = v
+	v.dom.pre = i // For now: DFS preorder of spanning tree of CFG
+	i++
+	lt.sdom[v.Index] = v
+	lt.link(nil, v)
+	for _, w := range v.Succs {
+		if lt.sdom[w.Index] == nil {
+			lt.parent[w.Index] = v
+			i = lt.dfs(w, i, preorder)
+		}
+	}
+	return i
+}
+
+// eval implements the EVAL part of the LT algorithm.
+func (lt *ltState) eval(v *BasicBlock) *BasicBlock {
+	// TODO(adonovan): opt: do path compression per simple LT.
+	u := v
+	for ; lt.ancestor[v.Index] != nil; v = lt.ancestor[v.Index] {
+		if lt.sdom[v.Index].dom.pre < lt.sdom[u.Index].dom.pre {
+			u = v
+		}
+	}
+	return u
+}
+
+// link implements the LINK part of the LT algorithm.
+func (lt *ltState) link(v, w *BasicBlock) {
+	lt.ancestor[w.Index] = v
+}
+
+// buildDomTree computes the dominator tree of f using the LT algorithm.
+// Precondition: all blocks are reachable (e.g. optimizeBlocks has been run).
+//
+func buildDomTree(f *Function) {
+	// The step numbers refer to the original LT paper; the
+	// reordering is due to Georgiadis.
+
+	// Clear any previous domInfo.
+	for _, b := range f.Blocks {
+		b.dom = domInfo{}
+	}
+
+	n := len(f.Blocks)
+	// Allocate space for 5 contiguous [n]*BasicBlock arrays:
+	// sdom, parent, ancestor, preorder, buckets.
+	space := make([]*BasicBlock, 5*n, 5*n)
+	lt := ltState{
+		sdom:     space[0:n],
+		parent:   space[n : 2*n],
+		ancestor: space[2*n : 3*n],
+	}
+
+	// Step 1.  Number vertices by depth-first preorder.
+	preorder := space[3*n : 4*n]
+	root := f.Blocks[0]
+	prenum := lt.dfs(root, 0, preorder)
+	recover := f.Recover
+	if recover != nil {
+		lt.dfs(recover, prenum, preorder)
+	}
+
+	buckets := space[4*n : 5*n]
+	copy(buckets, preorder)
+
+	// In reverse preorder...
+	for i := int32(n) - 1; i > 0; i-- {
+		w := preorder[i]
+
+		// Step 3. Implicitly define the immediate dominator of each node.
+		for v := buckets[i]; v != w; v = buckets[v.dom.pre] {
+			u := lt.eval(v)
+			if lt.sdom[u.Index].dom.pre < i {
+				v.dom.idom = u
+			} else {
+				v.dom.idom = w
+			}
+		}
+
+		// Step 2. Compute the semidominators of all nodes.
+		lt.sdom[w.Index] = lt.parent[w.Index]
+		for _, v := range w.Preds {
+			u := lt.eval(v)
+			if lt.sdom[u.Index].dom.pre < lt.sdom[w.Index].dom.pre {
+				lt.sdom[w.Index] = lt.sdom[u.Index]
+			}
+		}
+
+		lt.link(lt.parent[w.Index], w)
+
+		if lt.parent[w.Index] == lt.sdom[w.Index] {
+			w.dom.idom = lt.parent[w.Index]
+		} else {
+			buckets[i] = buckets[lt.sdom[w.Index].dom.pre]
+			buckets[lt.sdom[w.Index].dom.pre] = w
+		}
+	}
+
+	// The final 'Step 3' is now outside the loop.
+	for v := buckets[0]; v != root; v = buckets[v.dom.pre] {
+		v.dom.idom = root
+	}
+
+	// Step 4. Explicitly define the immediate dominator of each
+	// node, in preorder.
+	for _, w := range preorder[1:] {
+		if w == root || w == recover {
+			w.dom.idom = nil
+		} else {
+			if w.dom.idom != lt.sdom[w.Index] {
+				w.dom.idom = w.dom.idom.dom.idom
+			}
+			// Calculate Children relation as inverse of Idom.
+			w.dom.idom.dom.children = append(w.dom.idom.dom.children, w)
+		}
+	}
+
+	pre, post := numberDomTree(root, 0, 0)
+	if recover != nil {
+		numberDomTree(recover, pre, post)
+	}
+
+	// printDomTreeDot(os.Stderr, f)        // debugging
+	// printDomTreeText(os.Stderr, root, 0) // debugging
+
+	if f.Prog.mode&SanityCheckFunctions != 0 {
+		sanityCheckDomTree(f)
+	}
+}
+
+// numberDomTree sets the pre- and post-order numbers of a depth-first
+// traversal of the dominator tree rooted at v.  These are used to
+// answer dominance queries in constant time.
+//
+func numberDomTree(v *BasicBlock, pre, post int32) (int32, int32) {
+	v.dom.pre = pre
+	pre++
+	for _, child := range v.dom.children {
+		pre, post = numberDomTree(child, pre, post)
+	}
+	v.dom.post = post
+	post++
+	return pre, post
+}
+
+// Testing utilities ----------------------------------------
+
+// sanityCheckDomTree checks the correctness of the dominator tree
+// computed by the LT algorithm by comparing against the dominance
+// relation computed by a naive Kildall-style forward dataflow
+// analysis (Algorithm 10.16 from the "Dragon" book).
+//
+func sanityCheckDomTree(f *Function) {
+	n := len(f.Blocks)
+
+	// D[i] is the set of blocks that dominate f.Blocks[i],
+	// represented as a bit-set of block indices.
+	D := make([]big.Int, n)
+
+	one := big.NewInt(1)
+
+	// all is the set of all blocks; constant.
+	var all big.Int
+	all.Set(one).Lsh(&all, uint(n)).Sub(&all, one)
+
+	// Initialization.
+	for i, b := range f.Blocks {
+		if i == 0 || b == f.Recover {
+			// A root is dominated only by itself.
+			D[i].SetBit(&D[0], 0, 1)
+		} else {
+			// All other blocks are (initially) dominated
+			// by every block.
+			D[i].Set(&all)
+		}
+	}
+
+	// Iteration until fixed point.
+	for changed := true; changed; {
+		changed = false
+		for i, b := range f.Blocks {
+			if i == 0 || b == f.Recover {
+				continue
+			}
+			// Compute intersection across predecessors.
+			var x big.Int
+			x.Set(&all)
+			for _, pred := range b.Preds {
+				x.And(&x, &D[pred.Index])
+			}
+			x.SetBit(&x, i, 1) // a block always dominates itself.
+			if D[i].Cmp(&x) != 0 {
+				D[i].Set(&x)
+				changed = true
+			}
+		}
+	}
+
+	// Check the entire relation.  O(n^2).
+	// The Recover block (if any) must be treated specially so we skip it.
+	ok := true
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			b, c := f.Blocks[i], f.Blocks[j]
+			if c == f.Recover {
+				continue
+			}
+			actual := b.Dominates(c)
+			expected := D[j].Bit(i) == 1
+			if actual != expected {
+				fmt.Fprintf(os.Stderr, "dominates(%s, %s)==%t, want %t\n", b, c, actual, expected)
+				ok = false
+			}
+		}
+	}
+
+	preorder := f.DomPreorder()
+	for _, b := range f.Blocks {
+		if got := preorder[b.dom.pre]; got != b {
+			fmt.Fprintf(os.Stderr, "preorder[%d]==%s, want %s\n", b.dom.pre, got, b)
+			ok = false
+		}
+	}
+
+	if !ok {
+		panic("sanityCheckDomTree failed for " + f.String())
+	}
+
+}
+
+// Printing functions ----------------------------------------
+
+// printDomTree prints the dominator tree as text, using indentation.
+func printDomTreeText(buf *bytes.Buffer, v *BasicBlock, indent int) {
+	fmt.Fprintf(buf, "%*s%s\n", 4*indent, "", v)
+	for _, child := range v.dom.children {
+		printDomTreeText(buf, child, indent+1)
+	}
+}
+
+// printDomTreeDot prints the dominator tree of f in AT&T GraphViz
+// (.dot) format.
+func printDomTreeDot(buf *bytes.Buffer, f *Function) {
+	fmt.Fprintln(buf, "//", f)
+	fmt.Fprintln(buf, "digraph domtree {")
+	for i, b := range f.Blocks {
+		v := b.dom
+		fmt.Fprintf(buf, "\tn%d [label=\"%s (%d, %d)\",shape=\"rectangle\"];\n", v.pre, b, v.pre, v.post)
+		// TODO(adonovan): improve appearance of edges
+		// belonging to both dominator tree and CFG.
+
+		// Dominator tree edge.
+		if i != 0 {
+			fmt.Fprintf(buf, "\tn%d -> n%d [style=\"solid\",weight=100];\n", v.idom.dom.pre, v.pre)
+		}
+		// CFG edges.
+		for _, pred := range b.Preds {
+			fmt.Fprintf(buf, "\tn%d -> n%d [style=\"dotted\",weight=0];\n", pred.dom.pre, v.pre)
+		}
+	}
+	fmt.Fprintln(buf, "}")
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/emit.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/emit.go
new file mode 100644
index 00000000..1036988a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/emit.go
@@ -0,0 +1,468 @@
+// 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 ssa
+
+// Helpers for emitting SSA instructions.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// emitNew emits to f a new (heap Alloc) instruction allocating an
+// object of type typ.  pos is the optional source location.
+//
+func emitNew(f *Function, typ types.Type, pos token.Pos) *Alloc {
+	v := &Alloc{Heap: true}
+	v.setType(types.NewPointer(typ))
+	v.setPos(pos)
+	f.emit(v)
+	return v
+}
+
+// emitLoad emits to f an instruction to load the address addr into a
+// new temporary, and returns the value so defined.
+//
+func emitLoad(f *Function, addr Value) *UnOp {
+	v := &UnOp{Op: token.MUL, X: addr}
+	v.setType(deref(addr.Type()))
+	f.emit(v)
+	return v
+}
+
+// emitDebugRef emits to f a DebugRef pseudo-instruction associating
+// expression e with value v.
+//
+func emitDebugRef(f *Function, e ast.Expr, v Value, isAddr bool) {
+	if !f.debugInfo() {
+		return // debugging not enabled
+	}
+	if v == nil || e == nil {
+		panic("nil")
+	}
+	var obj types.Object
+	e = unparen(e)
+	if id, ok := e.(*ast.Ident); ok {
+		if isBlankIdent(id) {
+			return
+		}
+		obj = f.Pkg.objectOf(id)
+		switch obj.(type) {
+		case *types.Nil, *types.Const, *types.Builtin:
+			return
+		}
+	}
+	f.emit(&DebugRef{
+		X:      v,
+		Expr:   e,
+		IsAddr: isAddr,
+		object: obj,
+	})
+}
+
+// emitArith emits to f code to compute the binary operation op(x, y)
+// where op is an eager shift, logical or arithmetic operation.
+// (Use emitCompare() for comparisons and Builder.logicalBinop() for
+// non-eager operations.)
+//
+func emitArith(f *Function, op token.Token, x, y Value, t types.Type, pos token.Pos) Value {
+	switch op {
+	case token.SHL, token.SHR:
+		x = emitConv(f, x, t)
+		// y may be signed or an 'untyped' constant.
+		// TODO(adonovan): whence signed values?
+		if b, ok := y.Type().Underlying().(*types.Basic); ok && b.Info()&types.IsUnsigned == 0 {
+			y = emitConv(f, y, types.Typ[types.Uint64])
+		}
+
+	case token.ADD, token.SUB, token.MUL, token.QUO, token.REM, token.AND, token.OR, token.XOR, token.AND_NOT:
+		x = emitConv(f, x, t)
+		y = emitConv(f, y, t)
+
+	default:
+		panic("illegal op in emitArith: " + op.String())
+
+	}
+	v := &BinOp{
+		Op: op,
+		X:  x,
+		Y:  y,
+	}
+	v.setPos(pos)
+	v.setType(t)
+	return f.emit(v)
+}
+
+// emitCompare emits to f code compute the boolean result of
+// comparison comparison 'x op y'.
+//
+func emitCompare(f *Function, op token.Token, x, y Value, pos token.Pos) Value {
+	xt := x.Type().Underlying()
+	yt := y.Type().Underlying()
+
+	// Special case to optimise a tagless SwitchStmt so that
+	// these are equivalent
+	//   switch { case e: ...}
+	//   switch true { case e: ... }
+	//   if e==true { ... }
+	// even in the case when e's type is an interface.
+	// TODO(adonovan): opt: generalise to x==true, false!=y, etc.
+	if x == vTrue && op == token.EQL {
+		if yt, ok := yt.(*types.Basic); ok && yt.Info()&types.IsBoolean != 0 {
+			return y
+		}
+	}
+
+	if types.Identical(xt, yt) {
+		// no conversion necessary
+	} else if _, ok := xt.(*types.Interface); ok {
+		y = emitConv(f, y, x.Type())
+	} else if _, ok := yt.(*types.Interface); ok {
+		x = emitConv(f, x, y.Type())
+	} else if _, ok := x.(*Const); ok {
+		x = emitConv(f, x, y.Type())
+	} else if _, ok := y.(*Const); ok {
+		y = emitConv(f, y, x.Type())
+	} else {
+		// other cases, e.g. channels.  No-op.
+	}
+
+	v := &BinOp{
+		Op: op,
+		X:  x,
+		Y:  y,
+	}
+	v.setPos(pos)
+	v.setType(tBool)
+	return f.emit(v)
+}
+
+// isValuePreserving returns true if a conversion from ut_src to
+// ut_dst is value-preserving, i.e. just a change of type.
+// Precondition: neither argument is a named type.
+//
+func isValuePreserving(ut_src, ut_dst types.Type) bool {
+	// Identical underlying types?
+	if structTypesIdentical(ut_dst, ut_src) {
+		return true
+	}
+
+	switch ut_dst.(type) {
+	case *types.Chan:
+		// Conversion between channel types?
+		_, ok := ut_src.(*types.Chan)
+		return ok
+
+	case *types.Pointer:
+		// Conversion between pointers with identical base types?
+		_, ok := ut_src.(*types.Pointer)
+		return ok
+	}
+	return false
+}
+
+// emitConv emits to f code to convert Value val to exactly type typ,
+// and returns the converted value.  Implicit conversions are required
+// by language assignability rules in assignments, parameter passing,
+// etc.  Conversions cannot fail dynamically.
+//
+func emitConv(f *Function, val Value, typ types.Type) Value {
+	t_src := val.Type()
+
+	// Identical types?  Conversion is a no-op.
+	if types.Identical(t_src, typ) {
+		return val
+	}
+
+	ut_dst := typ.Underlying()
+	ut_src := t_src.Underlying()
+
+	// Just a change of type, but not value or representation?
+	if isValuePreserving(ut_src, ut_dst) {
+		c := &ChangeType{X: val}
+		c.setType(typ)
+		return f.emit(c)
+	}
+
+	// Conversion to, or construction of a value of, an interface type?
+	if _, ok := ut_dst.(*types.Interface); ok {
+		// Assignment from one interface type to another?
+		if _, ok := ut_src.(*types.Interface); ok {
+			c := &ChangeInterface{X: val}
+			c.setType(typ)
+			return f.emit(c)
+		}
+
+		// Untyped nil constant?  Return interface-typed nil constant.
+		if ut_src == tUntypedNil {
+			return nilConst(typ)
+		}
+
+		// Convert (non-nil) "untyped" literals to their default type.
+		if t, ok := ut_src.(*types.Basic); ok && t.Info()&types.IsUntyped != 0 {
+			val = emitConv(f, val, DefaultType(ut_src))
+		}
+
+		f.Pkg.Prog.needMethodsOf(val.Type())
+		mi := &MakeInterface{X: val}
+		mi.setType(typ)
+		return f.emit(mi)
+	}
+
+	// Conversion of a compile-time constant value?
+	if c, ok := val.(*Const); ok {
+		if _, ok := ut_dst.(*types.Basic); ok || c.IsNil() {
+			// Conversion of a compile-time constant to
+			// another constant type results in a new
+			// constant of the destination type and
+			// (initially) the same abstract value.
+			// We don't truncate the value yet.
+			return NewConst(c.Value, typ)
+		}
+
+		// We're converting from constant to non-constant type,
+		// e.g. string -> []byte/[]rune.
+	}
+
+	// A representation-changing conversion?
+	// At least one of {ut_src,ut_dst} must be *Basic.
+	// (The other may be []byte or []rune.)
+	_, ok1 := ut_src.(*types.Basic)
+	_, ok2 := ut_dst.(*types.Basic)
+	if ok1 || ok2 {
+		c := &Convert{X: val}
+		c.setType(typ)
+		return f.emit(c)
+	}
+
+	panic(fmt.Sprintf("in %s: cannot convert %s (%s) to %s", f, val, val.Type(), typ))
+}
+
+// emitStore emits to f an instruction to store value val at location
+// addr, applying implicit conversions as required by assignability rules.
+//
+func emitStore(f *Function, addr, val Value, pos token.Pos) *Store {
+	s := &Store{
+		Addr: addr,
+		Val:  emitConv(f, val, deref(addr.Type())),
+		pos:  pos,
+	}
+	f.emit(s)
+	return s
+}
+
+// emitJump emits to f a jump to target, and updates the control-flow graph.
+// Postcondition: f.currentBlock is nil.
+//
+func emitJump(f *Function, target *BasicBlock) {
+	b := f.currentBlock
+	b.emit(new(Jump))
+	addEdge(b, target)
+	f.currentBlock = nil
+}
+
+// emitIf emits to f a conditional jump to tblock or fblock based on
+// cond, and updates the control-flow graph.
+// Postcondition: f.currentBlock is nil.
+//
+func emitIf(f *Function, cond Value, tblock, fblock *BasicBlock) {
+	b := f.currentBlock
+	b.emit(&If{Cond: cond})
+	addEdge(b, tblock)
+	addEdge(b, fblock)
+	f.currentBlock = nil
+}
+
+// emitExtract emits to f an instruction to extract the index'th
+// component of tuple.  It returns the extracted value.
+//
+func emitExtract(f *Function, tuple Value, index int) Value {
+	e := &Extract{Tuple: tuple, Index: index}
+	e.setType(tuple.Type().(*types.Tuple).At(index).Type())
+	return f.emit(e)
+}
+
+// emitTypeAssert emits to f a type assertion value := x.(t) and
+// returns the value.  x.Type() must be an interface.
+//
+func emitTypeAssert(f *Function, x Value, t types.Type, pos token.Pos) Value {
+	a := &TypeAssert{X: x, AssertedType: t}
+	a.setPos(pos)
+	a.setType(t)
+	return f.emit(a)
+}
+
+// emitTypeTest emits to f a type test value,ok := x.(t) and returns
+// a (value, ok) tuple.  x.Type() must be an interface.
+//
+func emitTypeTest(f *Function, x Value, t types.Type, pos token.Pos) Value {
+	a := &TypeAssert{
+		X:            x,
+		AssertedType: t,
+		CommaOk:      true,
+	}
+	a.setPos(pos)
+	a.setType(types.NewTuple(
+		newVar("value", t),
+		varOk,
+	))
+	return f.emit(a)
+}
+
+// emitTailCall emits to f a function call in tail position.  The
+// caller is responsible for all fields of 'call' except its type.
+// Intended for wrapper methods.
+// Precondition: f does/will not use deferred procedure calls.
+// Postcondition: f.currentBlock is nil.
+//
+func emitTailCall(f *Function, call *Call) {
+	tresults := f.Signature.Results()
+	nr := tresults.Len()
+	if nr == 1 {
+		call.typ = tresults.At(0).Type()
+	} else {
+		call.typ = tresults
+	}
+	tuple := f.emit(call)
+	var ret Return
+	switch nr {
+	case 0:
+		// no-op
+	case 1:
+		ret.Results = []Value{tuple}
+	default:
+		for i := 0; i < nr; i++ {
+			v := emitExtract(f, tuple, i)
+			// TODO(adonovan): in principle, this is required:
+			//   v = emitConv(f, o.Type, f.Signature.Results[i].Type)
+			// but in practice emitTailCall is only used when
+			// the types exactly match.
+			ret.Results = append(ret.Results, v)
+		}
+	}
+	f.emit(&ret)
+	f.currentBlock = nil
+}
+
+// emitImplicitSelections emits to f code to apply the sequence of
+// implicit field selections specified by indices to base value v, and
+// returns the selected value.
+//
+// If v is the address of a struct, the result will be the address of
+// a field; if it is the value of a struct, the result will be the
+// value of a field.
+//
+func emitImplicitSelections(f *Function, v Value, indices []int) Value {
+	for _, index := range indices {
+		fld := deref(v.Type()).Underlying().(*types.Struct).Field(index)
+
+		if isPointer(v.Type()) {
+			instr := &FieldAddr{
+				X:     v,
+				Field: index,
+			}
+			instr.setType(types.NewPointer(fld.Type()))
+			v = f.emit(instr)
+			// Load the field's value iff indirectly embedded.
+			if isPointer(fld.Type()) {
+				v = emitLoad(f, v)
+			}
+		} else {
+			instr := &Field{
+				X:     v,
+				Field: index,
+			}
+			instr.setType(fld.Type())
+			v = f.emit(instr)
+		}
+	}
+	return v
+}
+
+// emitFieldSelection emits to f code to select the index'th field of v.
+//
+// If wantAddr, the input must be a pointer-to-struct and the result
+// will be the field's address; otherwise the result will be the
+// field's value.
+// Ident id is used for position and debug info.
+//
+func emitFieldSelection(f *Function, v Value, index int, wantAddr bool, id *ast.Ident) Value {
+	fld := deref(v.Type()).Underlying().(*types.Struct).Field(index)
+	if isPointer(v.Type()) {
+		instr := &FieldAddr{
+			X:     v,
+			Field: index,
+		}
+		instr.setPos(id.Pos())
+		instr.setType(types.NewPointer(fld.Type()))
+		v = f.emit(instr)
+		// Load the field's value iff we don't want its address.
+		if !wantAddr {
+			v = emitLoad(f, v)
+		}
+	} else {
+		instr := &Field{
+			X:     v,
+			Field: index,
+		}
+		instr.setPos(id.Pos())
+		instr.setType(fld.Type())
+		v = f.emit(instr)
+	}
+	emitDebugRef(f, id, v, wantAddr)
+	return v
+}
+
+// zeroValue emits to f code to produce a zero value of type t,
+// and returns it.
+//
+func zeroValue(f *Function, t types.Type) Value {
+	switch t.Underlying().(type) {
+	case *types.Struct, *types.Array:
+		return emitLoad(f, f.addLocal(t, token.NoPos))
+	default:
+		return zeroConst(t)
+	}
+}
+
+// createRecoverBlock emits to f a block of code to return after a
+// recovered panic, and sets f.Recover to it.
+//
+// If f's result parameters are named, the code loads and returns
+// their current values, otherwise it returns the zero values of their
+// type.
+//
+// Idempotent.
+//
+func createRecoverBlock(f *Function) {
+	if f.Recover != nil {
+		return // already created
+	}
+	saved := f.currentBlock
+
+	f.Recover = f.newBasicBlock("recover")
+	f.currentBlock = f.Recover
+
+	var results []Value
+	if f.namedResults != nil {
+		// Reload NRPs to form value tuple.
+		for _, r := range f.namedResults {
+			results = append(results, emitLoad(f, r))
+		}
+	} else {
+		R := f.Signature.Results()
+		for i, n := 0, R.Len(); i < n; i++ {
+			T := R.At(i).Type()
+
+			// Return zero value of each result type.
+			results = append(results, zeroValue(f, T))
+		}
+	}
+	f.emit(&Return{Results: results})
+
+	f.currentBlock = saved
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/func.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/func.go
new file mode 100644
index 00000000..b21ff4e5
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/func.go
@@ -0,0 +1,689 @@
+// 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 ssa
+
+// This file implements the Function and BasicBlock types.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"strings"
+)
+
+// addEdge adds a control-flow graph edge from from to to.
+func addEdge(from, to *BasicBlock) {
+	from.Succs = append(from.Succs, to)
+	to.Preds = append(to.Preds, from)
+}
+
+// Parent returns the function that contains block b.
+func (b *BasicBlock) Parent() *Function { return b.parent }
+
+// String returns a human-readable label of this block.
+// It is not guaranteed unique within the function.
+//
+func (b *BasicBlock) String() string {
+	return fmt.Sprintf("%d", b.Index)
+}
+
+// emit appends an instruction to the current basic block.
+// If the instruction defines a Value, it is returned.
+//
+func (b *BasicBlock) emit(i Instruction) Value {
+	i.setBlock(b)
+	b.Instrs = append(b.Instrs, i)
+	v, _ := i.(Value)
+	return v
+}
+
+// predIndex returns the i such that b.Preds[i] == c or panics if
+// there is none.
+func (b *BasicBlock) predIndex(c *BasicBlock) int {
+	for i, pred := range b.Preds {
+		if pred == c {
+			return i
+		}
+	}
+	panic(fmt.Sprintf("no edge %s -> %s", c, b))
+}
+
+// hasPhi returns true if b.Instrs contains φ-nodes.
+func (b *BasicBlock) hasPhi() bool {
+	_, ok := b.Instrs[0].(*Phi)
+	return ok
+}
+
+// phis returns the prefix of b.Instrs containing all the block's φ-nodes.
+func (b *BasicBlock) phis() []Instruction {
+	for i, instr := range b.Instrs {
+		if _, ok := instr.(*Phi); !ok {
+			return b.Instrs[:i]
+		}
+	}
+	return nil // unreachable in well-formed blocks
+}
+
+// replacePred replaces all occurrences of p in b's predecessor list with q.
+// Ordinarily there should be at most one.
+//
+func (b *BasicBlock) replacePred(p, q *BasicBlock) {
+	for i, pred := range b.Preds {
+		if pred == p {
+			b.Preds[i] = q
+		}
+	}
+}
+
+// replaceSucc replaces all occurrences of p in b's successor list with q.
+// Ordinarily there should be at most one.
+//
+func (b *BasicBlock) replaceSucc(p, q *BasicBlock) {
+	for i, succ := range b.Succs {
+		if succ == p {
+			b.Succs[i] = q
+		}
+	}
+}
+
+// removePred removes all occurrences of p in b's
+// predecessor list and φ-nodes.
+// Ordinarily there should be at most one.
+//
+func (b *BasicBlock) removePred(p *BasicBlock) {
+	phis := b.phis()
+
+	// We must preserve edge order for φ-nodes.
+	j := 0
+	for i, pred := range b.Preds {
+		if pred != p {
+			b.Preds[j] = b.Preds[i]
+			// Strike out φ-edge too.
+			for _, instr := range phis {
+				phi := instr.(*Phi)
+				phi.Edges[j] = phi.Edges[i]
+			}
+			j++
+		}
+	}
+	// Nil out b.Preds[j:] and φ-edges[j:] to aid GC.
+	for i := j; i < len(b.Preds); i++ {
+		b.Preds[i] = nil
+		for _, instr := range phis {
+			instr.(*Phi).Edges[i] = nil
+		}
+	}
+	b.Preds = b.Preds[:j]
+	for _, instr := range phis {
+		phi := instr.(*Phi)
+		phi.Edges = phi.Edges[:j]
+	}
+}
+
+// Destinations associated with unlabelled for/switch/select stmts.
+// We push/pop one of these as we enter/leave each construct and for
+// each BranchStmt we scan for the innermost target of the right type.
+//
+type targets struct {
+	tail         *targets // rest of stack
+	_break       *BasicBlock
+	_continue    *BasicBlock
+	_fallthrough *BasicBlock
+}
+
+// Destinations associated with a labelled block.
+// We populate these as labels are encountered in forward gotos or
+// labelled statements.
+//
+type lblock struct {
+	_goto     *BasicBlock
+	_break    *BasicBlock
+	_continue *BasicBlock
+}
+
+// labelledBlock returns the branch target associated with the
+// specified label, creating it if needed.
+//
+func (f *Function) labelledBlock(label *ast.Ident) *lblock {
+	lb := f.lblocks[label.Obj]
+	if lb == nil {
+		lb = &lblock{_goto: f.newBasicBlock(label.Name)}
+		if f.lblocks == nil {
+			f.lblocks = make(map[*ast.Object]*lblock)
+		}
+		f.lblocks[label.Obj] = lb
+	}
+	return lb
+}
+
+// addParam adds a (non-escaping) parameter to f.Params of the
+// specified name, type and source position.
+//
+func (f *Function) addParam(name string, typ types.Type, pos token.Pos) *Parameter {
+	v := &Parameter{
+		name:   name,
+		typ:    typ,
+		pos:    pos,
+		parent: f,
+	}
+	f.Params = append(f.Params, v)
+	return v
+}
+
+func (f *Function) addParamObj(obj types.Object) *Parameter {
+	name := obj.Name()
+	if name == "" {
+		name = fmt.Sprintf("arg%d", len(f.Params))
+	}
+	param := f.addParam(name, obj.Type(), obj.Pos())
+	param.object = obj
+	return param
+}
+
+// addSpilledParam declares a parameter that is pre-spilled to the
+// stack; the function body will load/store the spilled location.
+// Subsequent lifting will eliminate spills where possible.
+//
+func (f *Function) addSpilledParam(obj types.Object) {
+	param := f.addParamObj(obj)
+	spill := &Alloc{Comment: obj.Name()}
+	spill.setType(types.NewPointer(obj.Type()))
+	spill.setPos(obj.Pos())
+	f.objects[obj] = spill
+	f.Locals = append(f.Locals, spill)
+	f.emit(spill)
+	f.emit(&Store{Addr: spill, Val: param})
+}
+
+// startBody initializes the function prior to generating SSA code for its body.
+// Precondition: f.Type() already set.
+//
+func (f *Function) startBody() {
+	f.currentBlock = f.newBasicBlock("entry")
+	f.objects = make(map[types.Object]Value) // needed for some synthetics, e.g. init
+}
+
+// createSyntacticParams populates f.Params and generates code (spills
+// and named result locals) for all the parameters declared in the
+// syntax.  In addition it populates the f.objects mapping.
+//
+// Preconditions:
+// f.startBody() was called.
+// Postcondition:
+// len(f.Params) == len(f.Signature.Params) + (f.Signature.Recv() ? 1 : 0)
+//
+func (f *Function) createSyntacticParams(recv *ast.FieldList, functype *ast.FuncType) {
+	// Receiver (at most one inner iteration).
+	if recv != nil {
+		for _, field := range recv.List {
+			for _, n := range field.Names {
+				f.addSpilledParam(f.Pkg.info.Defs[n])
+			}
+			// Anonymous receiver?  No need to spill.
+			if field.Names == nil {
+				f.addParamObj(f.Signature.Recv())
+			}
+		}
+	}
+
+	// Parameters.
+	if functype.Params != nil {
+		n := len(f.Params) // 1 if has recv, 0 otherwise
+		for _, field := range functype.Params.List {
+			for _, n := range field.Names {
+				f.addSpilledParam(f.Pkg.info.Defs[n])
+			}
+			// Anonymous parameter?  No need to spill.
+			if field.Names == nil {
+				f.addParamObj(f.Signature.Params().At(len(f.Params) - n))
+			}
+		}
+	}
+
+	// Named results.
+	if functype.Results != nil {
+		for _, field := range functype.Results.List {
+			// Implicit "var" decl of locals for named results.
+			for _, n := range field.Names {
+				f.namedResults = append(f.namedResults, f.addLocalForIdent(n))
+			}
+		}
+	}
+}
+
+// numberRegisters assigns numbers to all SSA registers
+// (value-defining Instructions) in f, to aid debugging.
+// (Non-Instruction Values are named at construction.)
+//
+func numberRegisters(f *Function) {
+	v := 0
+	for _, b := range f.Blocks {
+		for _, instr := range b.Instrs {
+			switch instr.(type) {
+			case Value:
+				instr.(interface {
+					setNum(int)
+				}).setNum(v)
+				v++
+			}
+		}
+	}
+}
+
+// buildReferrers populates the def/use information in all non-nil
+// Value.Referrers slice.
+// Precondition: all such slices are initially empty.
+func buildReferrers(f *Function) {
+	var rands []*Value
+	for _, b := range f.Blocks {
+		for _, instr := range b.Instrs {
+			rands = instr.Operands(rands[:0]) // recycle storage
+			for _, rand := range rands {
+				if r := *rand; r != nil {
+					if ref := r.Referrers(); ref != nil {
+						*ref = append(*ref, instr)
+					}
+				}
+			}
+		}
+	}
+}
+
+// finishBody() finalizes the function after SSA code generation of its body.
+func (f *Function) finishBody() {
+	f.objects = nil
+	f.currentBlock = nil
+	f.lblocks = nil
+
+	// Don't pin the AST in memory (except in debug mode).
+	if n := f.syntax; n != nil && !f.debugInfo() {
+		f.syntax = extentNode{n.Pos(), n.End()}
+	}
+
+	// Remove from f.Locals any Allocs that escape to the heap.
+	j := 0
+	for _, l := range f.Locals {
+		if !l.Heap {
+			f.Locals[j] = l
+			j++
+		}
+	}
+	// Nil out f.Locals[j:] to aid GC.
+	for i := j; i < len(f.Locals); i++ {
+		f.Locals[i] = nil
+	}
+	f.Locals = f.Locals[:j]
+
+	optimizeBlocks(f)
+
+	buildReferrers(f)
+
+	buildDomTree(f)
+
+	if f.Prog.mode&NaiveForm == 0 {
+		// For debugging pre-state of lifting pass:
+		// numberRegisters(f)
+		// f.WriteTo(os.Stderr)
+		lift(f)
+	}
+
+	f.namedResults = nil // (used by lifting)
+
+	numberRegisters(f)
+
+	if f.Prog.mode&PrintFunctions != 0 {
+		printMu.Lock()
+		f.WriteTo(os.Stdout)
+		printMu.Unlock()
+	}
+
+	if f.Prog.mode&SanityCheckFunctions != 0 {
+		mustSanityCheck(f, nil)
+	}
+}
+
+// removeNilBlocks eliminates nils from f.Blocks and updates each
+// BasicBlock.Index.  Use this after any pass that may delete blocks.
+//
+func (f *Function) removeNilBlocks() {
+	j := 0
+	for _, b := range f.Blocks {
+		if b != nil {
+			b.Index = j
+			f.Blocks[j] = b
+			j++
+		}
+	}
+	// Nil out f.Blocks[j:] to aid GC.
+	for i := j; i < len(f.Blocks); i++ {
+		f.Blocks[i] = nil
+	}
+	f.Blocks = f.Blocks[:j]
+}
+
+// SetDebugMode sets the debug mode for package pkg.  If true, all its
+// functions will include full debug info.  This greatly increases the
+// size of the instruction stream, and causes Functions to depend upon
+// the ASTs, potentially keeping them live in memory for longer.
+//
+func (pkg *Package) SetDebugMode(debug bool) {
+	// TODO(adonovan): do we want ast.File granularity?
+	pkg.debug = debug
+}
+
+// debugInfo reports whether debug info is wanted for this function.
+func (f *Function) debugInfo() bool {
+	return f.Pkg != nil && f.Pkg.debug
+}
+
+// addNamedLocal creates a local variable, adds it to function f and
+// returns it.  Its name and type are taken from obj.  Subsequent
+// calls to f.lookup(obj) will return the same local.
+//
+func (f *Function) addNamedLocal(obj types.Object) *Alloc {
+	l := f.addLocal(obj.Type(), obj.Pos())
+	l.Comment = obj.Name()
+	f.objects[obj] = l
+	return l
+}
+
+func (f *Function) addLocalForIdent(id *ast.Ident) *Alloc {
+	return f.addNamedLocal(f.Pkg.info.Defs[id])
+}
+
+// addLocal creates an anonymous local variable of type typ, adds it
+// to function f and returns it.  pos is the optional source location.
+//
+func (f *Function) addLocal(typ types.Type, pos token.Pos) *Alloc {
+	v := &Alloc{}
+	v.setType(types.NewPointer(typ))
+	v.setPos(pos)
+	f.Locals = append(f.Locals, v)
+	f.emit(v)
+	return v
+}
+
+// lookup returns the address of the named variable identified by obj
+// that is local to function f or one of its enclosing functions.
+// If escaping, the reference comes from a potentially escaping pointer
+// expression and the referent must be heap-allocated.
+//
+func (f *Function) lookup(obj types.Object, escaping bool) Value {
+	if v, ok := f.objects[obj]; ok {
+		if alloc, ok := v.(*Alloc); ok && escaping {
+			alloc.Heap = true
+		}
+		return v // function-local var (address)
+	}
+
+	// Definition must be in an enclosing function;
+	// plumb it through intervening closures.
+	if f.parent == nil {
+		panic("no ssa.Value for " + obj.String())
+	}
+	outer := f.parent.lookup(obj, true) // escaping
+	v := &FreeVar{
+		name:   obj.Name(),
+		typ:    outer.Type(),
+		pos:    outer.Pos(),
+		outer:  outer,
+		parent: f,
+	}
+	f.objects[obj] = v
+	f.FreeVars = append(f.FreeVars, v)
+	return v
+}
+
+// emit emits the specified instruction to function f.
+func (f *Function) emit(instr Instruction) Value {
+	return f.currentBlock.emit(instr)
+}
+
+// RelString returns the full name of this function, qualified by
+// package name, receiver type, etc.
+//
+// The specific formatting rules are not guaranteed and may change.
+//
+// Examples:
+//      "math.IsNaN"                  // a package-level function
+//      "(*bytes.Buffer).Bytes"       // a declared method or a wrapper
+//      "(*bytes.Buffer).Bytes$thunk" // thunk (func wrapping method; receiver is param 0)
+//      "(*bytes.Buffer).Bytes$bound" // bound (func wrapping method; receiver supplied by closure)
+//      "main.main$1"                 // an anonymous function in main
+//      "main.init#1"                 // a declared init function
+//      "main.init"                   // the synthesized package initializer
+//
+// When these functions are referred to from within the same package
+// (i.e. from == f.Pkg.Object), they are rendered without the package path.
+// For example: "IsNaN", "(*Buffer).Bytes", etc.
+//
+// All non-synthetic functions have distinct package-qualified names.
+// (But two methods may have the same name "(T).f" if one is a synthetic
+// wrapper promoting a non-exported method "f" from another package; in
+// that case, the strings are equal but the identifiers "f" are distinct.)
+//
+func (f *Function) RelString(from *types.Package) string {
+	// Anonymous?
+	if f.parent != nil {
+		// An anonymous function's Name() looks like "parentName$1",
+		// but its String() should include the type/package/etc.
+		parent := f.parent.RelString(from)
+		for i, anon := range f.parent.AnonFuncs {
+			if anon == f {
+				return fmt.Sprintf("%s$%d", parent, 1+i)
+			}
+		}
+
+		return f.name // should never happen
+	}
+
+	// Method (declared or wrapper)?
+	if recv := f.Signature.Recv(); recv != nil {
+		return f.relMethod(from, recv.Type())
+	}
+
+	// Thunk?
+	if f.method != nil {
+		return f.relMethod(from, f.method.Recv())
+	}
+
+	// Bound?
+	if len(f.FreeVars) == 1 && strings.HasSuffix(f.name, "$bound") {
+		return f.relMethod(from, f.FreeVars[0].Type())
+	}
+
+	// Package-level function?
+	// Prefix with package name for cross-package references only.
+	if p := f.pkg(); p != nil && p != from {
+		return fmt.Sprintf("%s.%s", p.Path(), f.name)
+	}
+
+	// Unknown.
+	return f.name
+}
+
+func (f *Function) relMethod(from *types.Package, recv types.Type) string {
+	return fmt.Sprintf("(%s).%s", relType(recv, from), f.name)
+}
+
+// writeSignature writes to buf the signature sig in declaration syntax.
+func writeSignature(buf *bytes.Buffer, from *types.Package, name string, sig *types.Signature, params []*Parameter) {
+	buf.WriteString("func ")
+	if recv := sig.Recv(); recv != nil {
+		buf.WriteString("(")
+		if n := params[0].Name(); n != "" {
+			buf.WriteString(n)
+			buf.WriteString(" ")
+		}
+		types.WriteType(buf, params[0].Type(), types.RelativeTo(from))
+		buf.WriteString(") ")
+	}
+	buf.WriteString(name)
+	types.WriteSignature(buf, sig, types.RelativeTo(from))
+}
+
+func (f *Function) pkg() *types.Package {
+	if f.Pkg != nil {
+		return f.Pkg.Pkg
+	}
+	return nil
+}
+
+var _ io.WriterTo = (*Function)(nil) // *Function implements io.Writer
+
+func (f *Function) WriteTo(w io.Writer) (int64, error) {
+	var buf bytes.Buffer
+	WriteFunction(&buf, f)
+	n, err := w.Write(buf.Bytes())
+	return int64(n), err
+}
+
+// WriteFunction writes to buf a human-readable "disassembly" of f.
+func WriteFunction(buf *bytes.Buffer, f *Function) {
+	fmt.Fprintf(buf, "# Name: %s\n", f.String())
+	if f.Pkg != nil {
+		fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Pkg.Path())
+	}
+	if syn := f.Synthetic; syn != "" {
+		fmt.Fprintln(buf, "# Synthetic:", syn)
+	}
+	if pos := f.Pos(); pos.IsValid() {
+		fmt.Fprintf(buf, "# Location: %s\n", f.Prog.Fset.Position(pos))
+	}
+
+	if f.parent != nil {
+		fmt.Fprintf(buf, "# Parent: %s\n", f.parent.Name())
+	}
+
+	if f.Recover != nil {
+		fmt.Fprintf(buf, "# Recover: %s\n", f.Recover)
+	}
+
+	from := f.pkg()
+
+	if f.FreeVars != nil {
+		buf.WriteString("# Free variables:\n")
+		for i, fv := range f.FreeVars {
+			fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, fv.Name(), relType(fv.Type(), from))
+		}
+	}
+
+	if len(f.Locals) > 0 {
+		buf.WriteString("# Locals:\n")
+		for i, l := range f.Locals {
+			fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, l.Name(), relType(deref(l.Type()), from))
+		}
+	}
+	writeSignature(buf, from, f.Name(), f.Signature, f.Params)
+	buf.WriteString(":\n")
+
+	if f.Blocks == nil {
+		buf.WriteString("\t(external)\n")
+	}
+
+	// NB. column calculations are confused by non-ASCII
+	// characters and assume 8-space tabs.
+	const punchcard = 80 // for old time's sake.
+	const tabwidth = 8
+	for _, b := range f.Blocks {
+		if b == nil {
+			// Corrupt CFG.
+			fmt.Fprintf(buf, ".nil:\n")
+			continue
+		}
+		n, _ := fmt.Fprintf(buf, "%d:", b.Index)
+		bmsg := fmt.Sprintf("%s P:%d S:%d", b.Comment, len(b.Preds), len(b.Succs))
+		fmt.Fprintf(buf, "%*s%s\n", punchcard-1-n-len(bmsg), "", bmsg)
+
+		if false { // CFG debugging
+			fmt.Fprintf(buf, "\t# CFG: %s --> %s --> %s\n", b.Preds, b, b.Succs)
+		}
+		for _, instr := range b.Instrs {
+			buf.WriteString("\t")
+			switch v := instr.(type) {
+			case Value:
+				l := punchcard - tabwidth
+				// Left-align the instruction.
+				if name := v.Name(); name != "" {
+					n, _ := fmt.Fprintf(buf, "%s = ", name)
+					l -= n
+				}
+				n, _ := buf.WriteString(instr.String())
+				l -= n
+				// Right-align the type if there's space.
+				if t := v.Type(); t != nil {
+					buf.WriteByte(' ')
+					ts := relType(t, from)
+					l -= len(ts) + len("  ") // (spaces before and after type)
+					if l > 0 {
+						fmt.Fprintf(buf, "%*s", l, "")
+					}
+					buf.WriteString(ts)
+				}
+			case nil:
+				// Be robust against bad transforms.
+				buf.WriteString("<deleted>")
+			default:
+				buf.WriteString(instr.String())
+			}
+			buf.WriteString("\n")
+		}
+	}
+	fmt.Fprintf(buf, "\n")
+}
+
+// newBasicBlock adds to f a new basic block and returns it.  It does
+// not automatically become the current block for subsequent calls to emit.
+// comment is an optional string for more readable debugging output.
+//
+func (f *Function) newBasicBlock(comment string) *BasicBlock {
+	b := &BasicBlock{
+		Index:   len(f.Blocks),
+		Comment: comment,
+		parent:  f,
+	}
+	b.Succs = b.succs2[:0]
+	f.Blocks = append(f.Blocks, b)
+	return b
+}
+
+// NewFunction returns a new synthetic Function instance belonging to
+// prog, with its name and signature fields set as specified.
+//
+// The caller is responsible for initializing the remaining fields of
+// the function object, e.g. Pkg, Params, Blocks.
+//
+// It is practically impossible for clients to construct well-formed
+// SSA functions/packages/programs directly, so we assume this is the
+// job of the Builder alone.  NewFunction exists to provide clients a
+// little flexibility.  For example, analysis tools may wish to
+// construct fake Functions for the root of the callgraph, a fake
+// "reflect" package, etc.
+//
+// TODO(adonovan): think harder about the API here.
+//
+func (prog *Program) NewFunction(name string, sig *types.Signature, provenance string) *Function {
+	return &Function{Prog: prog, name: name, Signature: sig, Synthetic: provenance}
+}
+
+type extentNode [2]token.Pos
+
+func (n extentNode) Pos() token.Pos { return n[0] }
+func (n extentNode) End() token.Pos { return n[1] }
+
+// Syntax returns an ast.Node whose Pos/End methods provide the
+// lexical extent of the function if it was defined by Go source code
+// (f.Synthetic==""), or nil otherwise.
+//
+// If f was built with debug information (see Package.SetDebugRef),
+// the result is the *ast.FuncDecl or *ast.FuncLit that declared the
+// function.  Otherwise, it is an opaque Node providing only position
+// information; this avoids pinning the AST in memory.
+//
+func (f *Function) Syntax() ast.Node { return f.syntax }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical.go
new file mode 100644
index 00000000..53cbee10
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical.go
@@ -0,0 +1,7 @@
+// +build go1.8
+
+package ssa
+
+import "go/types"
+
+var structTypesIdentical = types.IdenticalIgnoreTags
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical_17.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical_17.go
new file mode 100644
index 00000000..da89d333
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/identical_17.go
@@ -0,0 +1,7 @@
+// +build !go1.8
+
+package ssa
+
+import "go/types"
+
+var structTypesIdentical = types.Identical
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lift.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lift.go
new file mode 100644
index 00000000..048e9b03
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lift.go
@@ -0,0 +1,653 @@
+// 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 ssa
+
+// This file defines the lifting pass which tries to "lift" Alloc
+// cells (new/local variables) into SSA registers, replacing loads
+// with the dominating stored value, eliminating loads and stores, and
+// inserting φ-nodes as needed.
+
+// Cited papers and resources:
+//
+// Ron Cytron et al. 1991. Efficiently computing SSA form...
+// http://doi.acm.org/10.1145/115372.115320
+//
+// Cooper, Harvey, Kennedy.  2001.  A Simple, Fast Dominance Algorithm.
+// Software Practice and Experience 2001, 4:1-10.
+// http://www.hipersoft.rice.edu/grads/publications/dom14.pdf
+//
+// Daniel Berlin, llvmdev mailing list, 2012.
+// http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-January/046638.html
+// (Be sure to expand the whole thread.)
+
+// TODO(adonovan): opt: there are many optimizations worth evaluating, and
+// the conventional wisdom for SSA construction is that a simple
+// algorithm well engineered often beats those of better asymptotic
+// complexity on all but the most egregious inputs.
+//
+// Danny Berlin suggests that the Cooper et al. algorithm for
+// computing the dominance frontier is superior to Cytron et al.
+// Furthermore he recommends that rather than computing the DF for the
+// whole function then renaming all alloc cells, it may be cheaper to
+// compute the DF for each alloc cell separately and throw it away.
+//
+// Consider exploiting liveness information to avoid creating dead
+// φ-nodes which we then immediately remove.
+//
+// Also see many other "TODO: opt" suggestions in the code.
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"math/big"
+	"os"
+)
+
+// If true, show diagnostic information at each step of lifting.
+// Very verbose.
+const debugLifting = false
+
+// domFrontier maps each block to the set of blocks in its dominance
+// frontier.  The outer slice is conceptually a map keyed by
+// Block.Index.  The inner slice is conceptually a set, possibly
+// containing duplicates.
+//
+// TODO(adonovan): opt: measure impact of dups; consider a packed bit
+// representation, e.g. big.Int, and bitwise parallel operations for
+// the union step in the Children loop.
+//
+// domFrontier's methods mutate the slice's elements but not its
+// length, so their receivers needn't be pointers.
+//
+type domFrontier [][]*BasicBlock
+
+func (df domFrontier) add(u, v *BasicBlock) {
+	p := &df[u.Index]
+	*p = append(*p, v)
+}
+
+// build builds the dominance frontier df for the dominator (sub)tree
+// rooted at u, using the Cytron et al. algorithm.
+//
+// TODO(adonovan): opt: consider Berlin approach, computing pruned SSA
+// by pruning the entire IDF computation, rather than merely pruning
+// the DF -> IDF step.
+func (df domFrontier) build(u *BasicBlock) {
+	// Encounter each node u in postorder of dom tree.
+	for _, child := range u.dom.children {
+		df.build(child)
+	}
+	for _, vb := range u.Succs {
+		if v := vb.dom; v.idom != u {
+			df.add(u, vb)
+		}
+	}
+	for _, w := range u.dom.children {
+		for _, vb := range df[w.Index] {
+			// TODO(adonovan): opt: use word-parallel bitwise union.
+			if v := vb.dom; v.idom != u {
+				df.add(u, vb)
+			}
+		}
+	}
+}
+
+func buildDomFrontier(fn *Function) domFrontier {
+	df := make(domFrontier, len(fn.Blocks))
+	df.build(fn.Blocks[0])
+	if fn.Recover != nil {
+		df.build(fn.Recover)
+	}
+	return df
+}
+
+func removeInstr(refs []Instruction, instr Instruction) []Instruction {
+	i := 0
+	for _, ref := range refs {
+		if ref == instr {
+			continue
+		}
+		refs[i] = ref
+		i++
+	}
+	for j := i; j != len(refs); j++ {
+		refs[j] = nil // aid GC
+	}
+	return refs[:i]
+}
+
+// lift replaces local and new Allocs accessed only with
+// load/store by SSA registers, inserting φ-nodes where necessary.
+// The result is a program in classical pruned SSA form.
+//
+// Preconditions:
+// - fn has no dead blocks (blockopt has run).
+// - Def/use info (Operands and Referrers) is up-to-date.
+// - The dominator tree is up-to-date.
+//
+func lift(fn *Function) {
+	// TODO(adonovan): opt: lots of little optimizations may be
+	// worthwhile here, especially if they cause us to avoid
+	// buildDomFrontier.  For example:
+	//
+	// - Alloc never loaded?  Eliminate.
+	// - Alloc never stored?  Replace all loads with a zero constant.
+	// - Alloc stored once?  Replace loads with dominating store;
+	//   don't forget that an Alloc is itself an effective store
+	//   of zero.
+	// - Alloc used only within a single block?
+	//   Use degenerate algorithm avoiding φ-nodes.
+	// - Consider synergy with scalar replacement of aggregates (SRA).
+	//   e.g. *(&x.f) where x is an Alloc.
+	//   Perhaps we'd get better results if we generated this as x.f
+	//   i.e. Field(x, .f) instead of Load(FieldIndex(x, .f)).
+	//   Unclear.
+	//
+	// But we will start with the simplest correct code.
+	df := buildDomFrontier(fn)
+
+	if debugLifting {
+		title := false
+		for i, blocks := range df {
+			if blocks != nil {
+				if !title {
+					fmt.Fprintf(os.Stderr, "Dominance frontier of %s:\n", fn)
+					title = true
+				}
+				fmt.Fprintf(os.Stderr, "\t%s: %s\n", fn.Blocks[i], blocks)
+			}
+		}
+	}
+
+	newPhis := make(newPhiMap)
+
+	// During this pass we will replace some BasicBlock.Instrs
+	// (allocs, loads and stores) with nil, keeping a count in
+	// BasicBlock.gaps.  At the end we will reset Instrs to the
+	// concatenation of all non-dead newPhis and non-nil Instrs
+	// for the block, reusing the original array if space permits.
+
+	// While we're here, we also eliminate 'rundefers'
+	// instructions in functions that contain no 'defer'
+	// instructions.
+	usesDefer := false
+
+	// A counter used to generate ~unique ids for Phi nodes, as an
+	// aid to debugging.  We use large numbers to make them highly
+	// visible.  All nodes are renumbered later.
+	fresh := 1000
+
+	// Determine which allocs we can lift and number them densely.
+	// The renaming phase uses this numbering for compact maps.
+	numAllocs := 0
+	for _, b := range fn.Blocks {
+		b.gaps = 0
+		b.rundefers = 0
+		for _, instr := range b.Instrs {
+			switch instr := instr.(type) {
+			case *Alloc:
+				index := -1
+				if liftAlloc(df, instr, newPhis, &fresh) {
+					index = numAllocs
+					numAllocs++
+				}
+				instr.index = index
+			case *Defer:
+				usesDefer = true
+			case *RunDefers:
+				b.rundefers++
+			}
+		}
+	}
+
+	// renaming maps an alloc (keyed by index) to its replacement
+	// value.  Initially the renaming contains nil, signifying the
+	// zero constant of the appropriate type; we construct the
+	// Const lazily at most once on each path through the domtree.
+	// TODO(adonovan): opt: cache per-function not per subtree.
+	renaming := make([]Value, numAllocs)
+
+	// Renaming.
+	rename(fn.Blocks[0], renaming, newPhis)
+
+	// Eliminate dead φ-nodes.
+	removeDeadPhis(fn.Blocks, newPhis)
+
+	// Prepend remaining live φ-nodes to each block.
+	for _, b := range fn.Blocks {
+		nps := newPhis[b]
+		j := len(nps)
+
+		rundefersToKill := b.rundefers
+		if usesDefer {
+			rundefersToKill = 0
+		}
+
+		if j+b.gaps+rundefersToKill == 0 {
+			continue // fast path: no new phis or gaps
+		}
+
+		// Compact nps + non-nil Instrs into a new slice.
+		// TODO(adonovan): opt: compact in situ (rightwards)
+		// if Instrs has sufficient space or slack.
+		dst := make([]Instruction, len(b.Instrs)+j-b.gaps-rundefersToKill)
+		for i, np := range nps {
+			dst[i] = np.phi
+		}
+		for _, instr := range b.Instrs {
+			if instr == nil {
+				continue
+			}
+			if !usesDefer {
+				if _, ok := instr.(*RunDefers); ok {
+					continue
+				}
+			}
+			dst[j] = instr
+			j++
+		}
+		b.Instrs = dst
+	}
+
+	// Remove any fn.Locals that were lifted.
+	j := 0
+	for _, l := range fn.Locals {
+		if l.index < 0 {
+			fn.Locals[j] = l
+			j++
+		}
+	}
+	// Nil out fn.Locals[j:] to aid GC.
+	for i := j; i < len(fn.Locals); i++ {
+		fn.Locals[i] = nil
+	}
+	fn.Locals = fn.Locals[:j]
+}
+
+// removeDeadPhis removes φ-nodes not transitively needed by a
+// non-Phi, non-DebugRef instruction.
+func removeDeadPhis(blocks []*BasicBlock, newPhis newPhiMap) {
+	// First pass: find the set of "live" φ-nodes: those reachable
+	// from some non-Phi instruction.
+	//
+	// We compute reachability in reverse, starting from each φ,
+	// rather than forwards, starting from each live non-Phi
+	// instruction, because this way visits much less of the
+	// Value graph.
+	livePhis := make(map[*Phi]bool)
+	for _, npList := range newPhis {
+		for _, np := range npList {
+			phi := np.phi
+			if !livePhis[phi] && phiHasDirectReferrer(phi) {
+				markLivePhi(livePhis, phi)
+			}
+		}
+	}
+
+	// Existing φ-nodes due to && and || operators
+	// are all considered live (see Go issue 19622).
+	for _, b := range blocks {
+		for _, phi := range b.phis() {
+			markLivePhi(livePhis, phi.(*Phi))
+		}
+	}
+
+	// Second pass: eliminate unused phis from newPhis.
+	for block, npList := range newPhis {
+		j := 0
+		for _, np := range npList {
+			if livePhis[np.phi] {
+				npList[j] = np
+				j++
+			} else {
+				// discard it, first removing it from referrers
+				for _, val := range np.phi.Edges {
+					if refs := val.Referrers(); refs != nil {
+						*refs = removeInstr(*refs, np.phi)
+					}
+				}
+				np.phi.block = nil
+			}
+		}
+		newPhis[block] = npList[:j]
+	}
+}
+
+// markLivePhi marks phi, and all φ-nodes transitively reachable via
+// its Operands, live.
+func markLivePhi(livePhis map[*Phi]bool, phi *Phi) {
+	livePhis[phi] = true
+	for _, rand := range phi.Operands(nil) {
+		if q, ok := (*rand).(*Phi); ok {
+			if !livePhis[q] {
+				markLivePhi(livePhis, q)
+			}
+		}
+	}
+}
+
+// phiHasDirectReferrer reports whether phi is directly referred to by
+// a non-Phi instruction.  Such instructions are the
+// roots of the liveness traversal.
+func phiHasDirectReferrer(phi *Phi) bool {
+	for _, instr := range *phi.Referrers() {
+		if _, ok := instr.(*Phi); !ok {
+			return true
+		}
+	}
+	return false
+}
+
+type blockSet struct{ big.Int } // (inherit methods from Int)
+
+// add adds b to the set and returns true if the set changed.
+func (s *blockSet) add(b *BasicBlock) bool {
+	i := b.Index
+	if s.Bit(i) != 0 {
+		return false
+	}
+	s.SetBit(&s.Int, i, 1)
+	return true
+}
+
+// take removes an arbitrary element from a set s and
+// returns its index, or returns -1 if empty.
+func (s *blockSet) take() int {
+	l := s.BitLen()
+	for i := 0; i < l; i++ {
+		if s.Bit(i) == 1 {
+			s.SetBit(&s.Int, i, 0)
+			return i
+		}
+	}
+	return -1
+}
+
+// newPhi is a pair of a newly introduced φ-node and the lifted Alloc
+// it replaces.
+type newPhi struct {
+	phi   *Phi
+	alloc *Alloc
+}
+
+// newPhiMap records for each basic block, the set of newPhis that
+// must be prepended to the block.
+type newPhiMap map[*BasicBlock][]newPhi
+
+// liftAlloc determines whether alloc can be lifted into registers,
+// and if so, it populates newPhis with all the φ-nodes it may require
+// and returns true.
+//
+// fresh is a source of fresh ids for phi nodes.
+//
+func liftAlloc(df domFrontier, alloc *Alloc, newPhis newPhiMap, fresh *int) bool {
+	// Don't lift aggregates into registers, because we don't have
+	// a way to express their zero-constants.
+	switch deref(alloc.Type()).Underlying().(type) {
+	case *types.Array, *types.Struct:
+		return false
+	}
+
+	// Don't lift named return values in functions that defer
+	// calls that may recover from panic.
+	if fn := alloc.Parent(); fn.Recover != nil {
+		for _, nr := range fn.namedResults {
+			if nr == alloc {
+				return false
+			}
+		}
+	}
+
+	// Compute defblocks, the set of blocks containing a
+	// definition of the alloc cell.
+	var defblocks blockSet
+	for _, instr := range *alloc.Referrers() {
+		// Bail out if we discover the alloc is not liftable;
+		// the only operations permitted to use the alloc are
+		// loads/stores into the cell, and DebugRef.
+		switch instr := instr.(type) {
+		case *Store:
+			if instr.Val == alloc {
+				return false // address used as value
+			}
+			if instr.Addr != alloc {
+				panic("Alloc.Referrers is inconsistent")
+			}
+			defblocks.add(instr.Block())
+		case *UnOp:
+			if instr.Op != token.MUL {
+				return false // not a load
+			}
+			if instr.X != alloc {
+				panic("Alloc.Referrers is inconsistent")
+			}
+		case *DebugRef:
+			// ok
+		default:
+			return false // some other instruction
+		}
+	}
+	// The Alloc itself counts as a (zero) definition of the cell.
+	defblocks.add(alloc.Block())
+
+	if debugLifting {
+		fmt.Fprintln(os.Stderr, "\tlifting ", alloc, alloc.Name())
+	}
+
+	fn := alloc.Parent()
+
+	// Φ-insertion.
+	//
+	// What follows is the body of the main loop of the insert-φ
+	// function described by Cytron et al, but instead of using
+	// counter tricks, we just reset the 'hasAlready' and 'work'
+	// sets each iteration.  These are bitmaps so it's pretty cheap.
+	//
+	// TODO(adonovan): opt: recycle slice storage for W,
+	// hasAlready, defBlocks across liftAlloc calls.
+	var hasAlready blockSet
+
+	// Initialize W and work to defblocks.
+	var work blockSet = defblocks // blocks seen
+	var W blockSet                // blocks to do
+	W.Set(&defblocks.Int)
+
+	// Traverse iterated dominance frontier, inserting φ-nodes.
+	for i := W.take(); i != -1; i = W.take() {
+		u := fn.Blocks[i]
+		for _, v := range df[u.Index] {
+			if hasAlready.add(v) {
+				// Create φ-node.
+				// It will be prepended to v.Instrs later, if needed.
+				phi := &Phi{
+					Edges:   make([]Value, len(v.Preds)),
+					Comment: alloc.Comment,
+				}
+				// This is merely a debugging aid:
+				phi.setNum(*fresh)
+				*fresh++
+
+				phi.pos = alloc.Pos()
+				phi.setType(deref(alloc.Type()))
+				phi.block = v
+				if debugLifting {
+					fmt.Fprintf(os.Stderr, "\tplace %s = %s at block %s\n", phi.Name(), phi, v)
+				}
+				newPhis[v] = append(newPhis[v], newPhi{phi, alloc})
+
+				if work.add(v) {
+					W.add(v)
+				}
+			}
+		}
+	}
+
+	return true
+}
+
+// replaceAll replaces all intraprocedural uses of x with y,
+// updating x.Referrers and y.Referrers.
+// Precondition: x.Referrers() != nil, i.e. x must be local to some function.
+//
+func replaceAll(x, y Value) {
+	var rands []*Value
+	pxrefs := x.Referrers()
+	pyrefs := y.Referrers()
+	for _, instr := range *pxrefs {
+		rands = instr.Operands(rands[:0]) // recycle storage
+		for _, rand := range rands {
+			if *rand != nil {
+				if *rand == x {
+					*rand = y
+				}
+			}
+		}
+		if pyrefs != nil {
+			*pyrefs = append(*pyrefs, instr) // dups ok
+		}
+	}
+	*pxrefs = nil // x is now unreferenced
+}
+
+// renamed returns the value to which alloc is being renamed,
+// constructing it lazily if it's the implicit zero initialization.
+//
+func renamed(renaming []Value, alloc *Alloc) Value {
+	v := renaming[alloc.index]
+	if v == nil {
+		v = zeroConst(deref(alloc.Type()))
+		renaming[alloc.index] = v
+	}
+	return v
+}
+
+// rename implements the (Cytron et al) SSA renaming algorithm, a
+// preorder traversal of the dominator tree replacing all loads of
+// Alloc cells with the value stored to that cell by the dominating
+// store instruction.  For lifting, we need only consider loads,
+// stores and φ-nodes.
+//
+// renaming is a map from *Alloc (keyed by index number) to its
+// dominating stored value; newPhis[x] is the set of new φ-nodes to be
+// prepended to block x.
+//
+func rename(u *BasicBlock, renaming []Value, newPhis newPhiMap) {
+	// Each φ-node becomes the new name for its associated Alloc.
+	for _, np := range newPhis[u] {
+		phi := np.phi
+		alloc := np.alloc
+		renaming[alloc.index] = phi
+	}
+
+	// Rename loads and stores of allocs.
+	for i, instr := range u.Instrs {
+		switch instr := instr.(type) {
+		case *Alloc:
+			if instr.index >= 0 { // store of zero to Alloc cell
+				// Replace dominated loads by the zero value.
+				renaming[instr.index] = nil
+				if debugLifting {
+					fmt.Fprintf(os.Stderr, "\tkill alloc %s\n", instr)
+				}
+				// Delete the Alloc.
+				u.Instrs[i] = nil
+				u.gaps++
+			}
+
+		case *Store:
+			if alloc, ok := instr.Addr.(*Alloc); ok && alloc.index >= 0 { // store to Alloc cell
+				// Replace dominated loads by the stored value.
+				renaming[alloc.index] = instr.Val
+				if debugLifting {
+					fmt.Fprintf(os.Stderr, "\tkill store %s; new value: %s\n",
+						instr, instr.Val.Name())
+				}
+				// Remove the store from the referrer list of the stored value.
+				if refs := instr.Val.Referrers(); refs != nil {
+					*refs = removeInstr(*refs, instr)
+				}
+				// Delete the Store.
+				u.Instrs[i] = nil
+				u.gaps++
+			}
+
+		case *UnOp:
+			if instr.Op == token.MUL {
+				if alloc, ok := instr.X.(*Alloc); ok && alloc.index >= 0 { // load of Alloc cell
+					newval := renamed(renaming, alloc)
+					if debugLifting {
+						fmt.Fprintf(os.Stderr, "\tupdate load %s = %s with %s\n",
+							instr.Name(), instr, newval.Name())
+					}
+					// Replace all references to
+					// the loaded value by the
+					// dominating stored value.
+					replaceAll(instr, newval)
+					// Delete the Load.
+					u.Instrs[i] = nil
+					u.gaps++
+				}
+			}
+
+		case *DebugRef:
+			if alloc, ok := instr.X.(*Alloc); ok && alloc.index >= 0 { // ref of Alloc cell
+				if instr.IsAddr {
+					instr.X = renamed(renaming, alloc)
+					instr.IsAddr = false
+
+					// Add DebugRef to instr.X's referrers.
+					if refs := instr.X.Referrers(); refs != nil {
+						*refs = append(*refs, instr)
+					}
+				} else {
+					// A source expression denotes the address
+					// of an Alloc that was optimized away.
+					instr.X = nil
+
+					// Delete the DebugRef.
+					u.Instrs[i] = nil
+					u.gaps++
+				}
+			}
+		}
+	}
+
+	// For each φ-node in a CFG successor, rename the edge.
+	for _, v := range u.Succs {
+		phis := newPhis[v]
+		if len(phis) == 0 {
+			continue
+		}
+		i := v.predIndex(u)
+		for _, np := range phis {
+			phi := np.phi
+			alloc := np.alloc
+			newval := renamed(renaming, alloc)
+			if debugLifting {
+				fmt.Fprintf(os.Stderr, "\tsetphi %s edge %s -> %s (#%d) (alloc=%s) := %s\n",
+					phi.Name(), u, v, i, alloc.Name(), newval.Name())
+			}
+			phi.Edges[i] = newval
+			if prefs := newval.Referrers(); prefs != nil {
+				*prefs = append(*prefs, phi)
+			}
+		}
+	}
+
+	// Continue depth-first recursion over domtree, pushing a
+	// fresh copy of the renaming map for each subtree.
+	for i, v := range u.dom.children {
+		r := renaming
+		if i < len(u.dom.children)-1 {
+			// On all but the final iteration, we must make
+			// a copy to avoid destructive update.
+			r = make([]Value, len(renaming))
+			copy(r, renaming)
+		}
+		rename(v, r, newPhis)
+	}
+
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lvalue.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lvalue.go
new file mode 100644
index 00000000..4d85be3e
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/lvalue.go
@@ -0,0 +1,120 @@
+// 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 ssa
+
+// lvalues are the union of addressable expressions and map-index
+// expressions.
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// An lvalue represents an assignable location that may appear on the
+// left-hand side of an assignment.  This is a generalization of a
+// pointer to permit updates to elements of maps.
+//
+type lvalue interface {
+	store(fn *Function, v Value) // stores v into the location
+	load(fn *Function) Value     // loads the contents of the location
+	address(fn *Function) Value  // address of the location
+	typ() types.Type             // returns the type of the location
+}
+
+// An address is an lvalue represented by a true pointer.
+type address struct {
+	addr Value
+	pos  token.Pos // source position
+	expr ast.Expr  // source syntax of the value (not address) [debug mode]
+}
+
+func (a *address) load(fn *Function) Value {
+	load := emitLoad(fn, a.addr)
+	load.pos = a.pos
+	return load
+}
+
+func (a *address) store(fn *Function, v Value) {
+	store := emitStore(fn, a.addr, v, a.pos)
+	if a.expr != nil {
+		// store.Val is v, converted for assignability.
+		emitDebugRef(fn, a.expr, store.Val, false)
+	}
+}
+
+func (a *address) address(fn *Function) Value {
+	if a.expr != nil {
+		emitDebugRef(fn, a.expr, a.addr, true)
+	}
+	return a.addr
+}
+
+func (a *address) typ() types.Type {
+	return deref(a.addr.Type())
+}
+
+// An element is an lvalue represented by m[k], the location of an
+// element of a map or string.  These locations are not addressable
+// since pointers cannot be formed from them, but they do support
+// load(), and in the case of maps, store().
+//
+type element struct {
+	m, k Value      // map or string
+	t    types.Type // map element type or string byte type
+	pos  token.Pos  // source position of colon ({k:v}) or lbrack (m[k]=v)
+}
+
+func (e *element) load(fn *Function) Value {
+	l := &Lookup{
+		X:     e.m,
+		Index: e.k,
+	}
+	l.setPos(e.pos)
+	l.setType(e.t)
+	return fn.emit(l)
+}
+
+func (e *element) store(fn *Function, v Value) {
+	up := &MapUpdate{
+		Map:   e.m,
+		Key:   e.k,
+		Value: emitConv(fn, v, e.t),
+	}
+	up.pos = e.pos
+	fn.emit(up)
+}
+
+func (e *element) address(fn *Function) Value {
+	panic("map/string elements are not addressable")
+}
+
+func (e *element) typ() types.Type {
+	return e.t
+}
+
+// A blank is a dummy variable whose name is "_".
+// It is not reified: loads are illegal and stores are ignored.
+//
+type blank struct{}
+
+func (bl blank) load(fn *Function) Value {
+	panic("blank.load is illegal")
+}
+
+func (bl blank) store(fn *Function, v Value) {
+	// no-op
+}
+
+func (bl blank) address(fn *Function) Value {
+	panic("blank var is not addressable")
+}
+
+func (bl blank) typ() types.Type {
+	// This should be the type of the blank Ident; the typechecker
+	// doesn't provide this yet, but fortunately, we don't need it
+	// yet either.
+	panic("blank.typ is unimplemented")
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/methods.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/methods.go
new file mode 100644
index 00000000..080dca96
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/methods.go
@@ -0,0 +1,239 @@
+// 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 ssa
+
+// This file defines utilities for population of method sets.
+
+import (
+	"fmt"
+	"go/types"
+)
+
+// MethodValue returns the Function implementing method sel, building
+// wrapper methods on demand.  It returns nil if sel denotes an
+// abstract (interface) method.
+//
+// Precondition: sel.Kind() == MethodVal.
+//
+// Thread-safe.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
+//
+func (prog *Program) MethodValue(sel *types.Selection) *Function {
+	if sel.Kind() != types.MethodVal {
+		panic(fmt.Sprintf("Method(%s) kind != MethodVal", sel))
+	}
+	T := sel.Recv()
+	if isInterface(T) {
+		return nil // abstract method
+	}
+	if prog.mode&LogSource != 0 {
+		defer logStack("Method %s %v", T, sel)()
+	}
+
+	prog.methodsMu.Lock()
+	defer prog.methodsMu.Unlock()
+
+	return prog.addMethod(prog.createMethodSet(T), sel)
+}
+
+// LookupMethod returns the implementation of the method of type T
+// identified by (pkg, name).  It returns nil if the method exists but
+// is abstract, and panics if T has no such method.
+//
+func (prog *Program) LookupMethod(T types.Type, pkg *types.Package, name string) *Function {
+	sel := prog.MethodSets.MethodSet(T).Lookup(pkg, name)
+	if sel == nil {
+		panic(fmt.Sprintf("%s has no method %s", T, types.Id(pkg, name)))
+	}
+	return prog.MethodValue(sel)
+}
+
+// methodSet contains the (concrete) methods of a non-interface type.
+type methodSet struct {
+	mapping  map[string]*Function // populated lazily
+	complete bool                 // mapping contains all methods
+}
+
+// Precondition: !isInterface(T).
+// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
+func (prog *Program) createMethodSet(T types.Type) *methodSet {
+	mset, ok := prog.methodSets.At(T).(*methodSet)
+	if !ok {
+		mset = &methodSet{mapping: make(map[string]*Function)}
+		prog.methodSets.Set(T, mset)
+	}
+	return mset
+}
+
+// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
+func (prog *Program) addMethod(mset *methodSet, sel *types.Selection) *Function {
+	if sel.Kind() == types.MethodExpr {
+		panic(sel)
+	}
+	id := sel.Obj().Id()
+	fn := mset.mapping[id]
+	if fn == nil {
+		obj := sel.Obj().(*types.Func)
+
+		needsPromotion := len(sel.Index()) > 1
+		needsIndirection := !isPointer(recvType(obj)) && isPointer(sel.Recv())
+		if needsPromotion || needsIndirection {
+			fn = makeWrapper(prog, sel)
+		} else {
+			fn = prog.declaredFunc(obj)
+		}
+		if fn.Signature.Recv() == nil {
+			panic(fn) // missing receiver
+		}
+		mset.mapping[id] = fn
+	}
+	return fn
+}
+
+// RuntimeTypes returns a new unordered slice containing all
+// concrete types in the program for which a complete (non-empty)
+// method set is required at run-time.
+//
+// Thread-safe.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
+//
+func (prog *Program) RuntimeTypes() []types.Type {
+	prog.methodsMu.Lock()
+	defer prog.methodsMu.Unlock()
+
+	var res []types.Type
+	prog.methodSets.Iterate(func(T types.Type, v interface{}) {
+		if v.(*methodSet).complete {
+			res = append(res, T)
+		}
+	})
+	return res
+}
+
+// declaredFunc returns the concrete function/method denoted by obj.
+// Panic ensues if there is none.
+//
+func (prog *Program) declaredFunc(obj *types.Func) *Function {
+	if v := prog.packageLevelValue(obj); v != nil {
+		return v.(*Function)
+	}
+	panic("no concrete method: " + obj.String())
+}
+
+// needMethodsOf ensures that runtime type information (including the
+// complete method set) is available for the specified type T and all
+// its subcomponents.
+//
+// needMethodsOf must be called for at least every type that is an
+// operand of some MakeInterface instruction, and for the type of
+// every exported package member.
+//
+// Precondition: T is not a method signature (*Signature with Recv()!=nil).
+//
+// Thread-safe.  (Called via emitConv from multiple builder goroutines.)
+//
+// TODO(adonovan): make this faster.  It accounts for 20% of SSA build time.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
+//
+func (prog *Program) needMethodsOf(T types.Type) {
+	prog.methodsMu.Lock()
+	prog.needMethods(T, false)
+	prog.methodsMu.Unlock()
+}
+
+// Precondition: T is not a method signature (*Signature with Recv()!=nil).
+// Recursive case: skip => don't create methods for T.
+//
+// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
+//
+func (prog *Program) needMethods(T types.Type, skip bool) {
+	// Each package maintains its own set of types it has visited.
+	if prevSkip, ok := prog.runtimeTypes.At(T).(bool); ok {
+		// needMethods(T) was previously called
+		if !prevSkip || skip {
+			return // already seen, with same or false 'skip' value
+		}
+	}
+	prog.runtimeTypes.Set(T, skip)
+
+	tmset := prog.MethodSets.MethodSet(T)
+
+	if !skip && !isInterface(T) && tmset.Len() > 0 {
+		// Create methods of T.
+		mset := prog.createMethodSet(T)
+		if !mset.complete {
+			mset.complete = true
+			n := tmset.Len()
+			for i := 0; i < n; i++ {
+				prog.addMethod(mset, tmset.At(i))
+			}
+		}
+	}
+
+	// Recursion over signatures of each method.
+	for i := 0; i < tmset.Len(); i++ {
+		sig := tmset.At(i).Type().(*types.Signature)
+		prog.needMethods(sig.Params(), false)
+		prog.needMethods(sig.Results(), false)
+	}
+
+	switch t := T.(type) {
+	case *types.Basic:
+		// nop
+
+	case *types.Interface:
+		// nop---handled by recursion over method set.
+
+	case *types.Pointer:
+		prog.needMethods(t.Elem(), false)
+
+	case *types.Slice:
+		prog.needMethods(t.Elem(), false)
+
+	case *types.Chan:
+		prog.needMethods(t.Elem(), false)
+
+	case *types.Map:
+		prog.needMethods(t.Key(), false)
+		prog.needMethods(t.Elem(), false)
+
+	case *types.Signature:
+		if t.Recv() != nil {
+			panic(fmt.Sprintf("Signature %s has Recv %s", t, t.Recv()))
+		}
+		prog.needMethods(t.Params(), false)
+		prog.needMethods(t.Results(), false)
+
+	case *types.Named:
+		// A pointer-to-named type can be derived from a named
+		// type via reflection.  It may have methods too.
+		prog.needMethods(types.NewPointer(T), false)
+
+		// Consider 'type T struct{S}' where S has methods.
+		// Reflection provides no way to get from T to struct{S},
+		// only to S, so the method set of struct{S} is unwanted,
+		// so set 'skip' flag during recursion.
+		prog.needMethods(t.Underlying(), true)
+
+	case *types.Array:
+		prog.needMethods(t.Elem(), false)
+
+	case *types.Struct:
+		for i, n := 0, t.NumFields(); i < n; i++ {
+			prog.needMethods(t.Field(i).Type(), false)
+		}
+
+	case *types.Tuple:
+		for i, n := 0, t.Len(); i < n; i++ {
+			prog.needMethods(t.At(i).Type(), false)
+		}
+
+	default:
+		panic(T)
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/mode.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/mode.go
new file mode 100644
index 00000000..d2a26989
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/mode.go
@@ -0,0 +1,100 @@
+// 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.
+
+package ssa
+
+// This file defines the BuilderMode type and its command-line flag.
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// BuilderMode is a bitmask of options for diagnostics and checking.
+//
+// *BuilderMode satisfies the flag.Value interface.  Example:
+//
+// 	var mode = ssa.BuilderMode(0)
+// 	func init() { flag.Var(&mode, "build", ssa.BuilderModeDoc) }
+//
+type BuilderMode uint
+
+const (
+	PrintPackages        BuilderMode = 1 << iota // Print package inventory to stdout
+	PrintFunctions                               // Print function SSA code to stdout
+	LogSource                                    // Log source locations as SSA builder progresses
+	SanityCheckFunctions                         // Perform sanity checking of function bodies
+	NaiveForm                                    // Build naïve SSA form: don't replace local loads/stores with registers
+	BuildSerially                                // Build packages serially, not in parallel.
+	GlobalDebug                                  // Enable debug info for all packages
+	BareInits                                    // Build init functions without guards or calls to dependent inits
+)
+
+const BuilderModeDoc = `Options controlling the SSA builder.
+The value is a sequence of zero or more of these letters:
+C	perform sanity [C]hecking of the SSA form.
+D	include [D]ebug info for every function.
+P	print [P]ackage inventory.
+F	print [F]unction SSA code.
+S	log [S]ource locations as SSA builder progresses.
+L	build distinct packages seria[L]ly instead of in parallel.
+N	build [N]aive SSA form: don't replace local loads/stores with registers.
+I	build bare [I]nit functions: no init guards or calls to dependent inits.
+`
+
+func (m BuilderMode) String() string {
+	var buf bytes.Buffer
+	if m&GlobalDebug != 0 {
+		buf.WriteByte('D')
+	}
+	if m&PrintPackages != 0 {
+		buf.WriteByte('P')
+	}
+	if m&PrintFunctions != 0 {
+		buf.WriteByte('F')
+	}
+	if m&LogSource != 0 {
+		buf.WriteByte('S')
+	}
+	if m&SanityCheckFunctions != 0 {
+		buf.WriteByte('C')
+	}
+	if m&NaiveForm != 0 {
+		buf.WriteByte('N')
+	}
+	if m&BuildSerially != 0 {
+		buf.WriteByte('L')
+	}
+	return buf.String()
+}
+
+// Set parses the flag characters in s and updates *m.
+func (m *BuilderMode) Set(s string) error {
+	var mode BuilderMode
+	for _, c := range s {
+		switch c {
+		case 'D':
+			mode |= GlobalDebug
+		case 'P':
+			mode |= PrintPackages
+		case 'F':
+			mode |= PrintFunctions
+		case 'S':
+			mode |= LogSource | BuildSerially
+		case 'C':
+			mode |= SanityCheckFunctions
+		case 'N':
+			mode |= NaiveForm
+		case 'L':
+			mode |= BuildSerially
+		default:
+			return fmt.Errorf("unknown BuilderMode option: %q", c)
+		}
+	}
+	*m = mode
+	return nil
+}
+
+// Get returns m.
+func (m BuilderMode) Get() interface{} { return m }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/print.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/print.go
new file mode 100644
index 00000000..3333ba41
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/print.go
@@ -0,0 +1,431 @@
+// 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 ssa
+
+// This file implements the String() methods for all Value and
+// Instruction types.
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"io"
+	"reflect"
+	"sort"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// relName returns the name of v relative to i.
+// In most cases, this is identical to v.Name(), but references to
+// Functions (including methods) and Globals use RelString and
+// all types are displayed with relType, so that only cross-package
+// references are package-qualified.
+//
+func relName(v Value, i Instruction) string {
+	var from *types.Package
+	if i != nil {
+		from = i.Parent().pkg()
+	}
+	switch v := v.(type) {
+	case Member: // *Function or *Global
+		return v.RelString(from)
+	case *Const:
+		return v.RelString(from)
+	}
+	return v.Name()
+}
+
+func relType(t types.Type, from *types.Package) string {
+	return types.TypeString(t, types.RelativeTo(from))
+}
+
+func relString(m Member, from *types.Package) string {
+	// NB: not all globals have an Object (e.g. init$guard),
+	// so use Package().Object not Object.Package().
+	if pkg := m.Package().Pkg; pkg != nil && pkg != from {
+		return fmt.Sprintf("%s.%s", pkg.Path(), m.Name())
+	}
+	return m.Name()
+}
+
+// Value.String()
+//
+// This method is provided only for debugging.
+// It never appears in disassembly, which uses Value.Name().
+
+func (v *Parameter) String() string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("parameter %s : %s", v.Name(), relType(v.Type(), from))
+}
+
+func (v *FreeVar) String() string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("freevar %s : %s", v.Name(), relType(v.Type(), from))
+}
+
+func (v *Builtin) String() string {
+	return fmt.Sprintf("builtin %s", v.Name())
+}
+
+// Instruction.String()
+
+func (v *Alloc) String() string {
+	op := "local"
+	if v.Heap {
+		op = "new"
+	}
+	from := v.Parent().pkg()
+	return fmt.Sprintf("%s %s (%s)", op, relType(deref(v.Type()), from), v.Comment)
+}
+
+func (v *Phi) String() string {
+	var b bytes.Buffer
+	b.WriteString("phi [")
+	for i, edge := range v.Edges {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		// Be robust against malformed CFG.
+		if v.block == nil {
+			b.WriteString("??")
+			continue
+		}
+		block := -1
+		if i < len(v.block.Preds) {
+			block = v.block.Preds[i].Index
+		}
+		fmt.Fprintf(&b, "%d: ", block)
+		edgeVal := "<nil>" // be robust
+		if edge != nil {
+			edgeVal = relName(edge, v)
+		}
+		b.WriteString(edgeVal)
+	}
+	b.WriteString("]")
+	if v.Comment != "" {
+		b.WriteString(" #")
+		b.WriteString(v.Comment)
+	}
+	return b.String()
+}
+
+func printCall(v *CallCommon, prefix string, instr Instruction) string {
+	var b bytes.Buffer
+	b.WriteString(prefix)
+	if !v.IsInvoke() {
+		b.WriteString(relName(v.Value, instr))
+	} else {
+		fmt.Fprintf(&b, "invoke %s.%s", relName(v.Value, instr), v.Method.Name())
+	}
+	b.WriteString("(")
+	for i, arg := range v.Args {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(relName(arg, instr))
+	}
+	if v.Signature().Variadic() {
+		b.WriteString("...")
+	}
+	b.WriteString(")")
+	return b.String()
+}
+
+func (c *CallCommon) String() string {
+	return printCall(c, "", nil)
+}
+
+func (v *Call) String() string {
+	return printCall(&v.Call, "", v)
+}
+
+func (v *BinOp) String() string {
+	return fmt.Sprintf("%s %s %s", relName(v.X, v), v.Op.String(), relName(v.Y, v))
+}
+
+func (v *UnOp) String() string {
+	return fmt.Sprintf("%s%s%s", v.Op, relName(v.X, v), commaOk(v.CommaOk))
+}
+
+func printConv(prefix string, v, x Value) string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("%s %s <- %s (%s)",
+		prefix,
+		relType(v.Type(), from),
+		relType(x.Type(), from),
+		relName(x, v.(Instruction)))
+}
+
+func (v *ChangeType) String() string      { return printConv("changetype", v, v.X) }
+func (v *Convert) String() string         { return printConv("convert", v, v.X) }
+func (v *ChangeInterface) String() string { return printConv("change interface", v, v.X) }
+func (v *MakeInterface) String() string   { return printConv("make", v, v.X) }
+
+func (v *MakeClosure) String() string {
+	var b bytes.Buffer
+	fmt.Fprintf(&b, "make closure %s", relName(v.Fn, v))
+	if v.Bindings != nil {
+		b.WriteString(" [")
+		for i, c := range v.Bindings {
+			if i > 0 {
+				b.WriteString(", ")
+			}
+			b.WriteString(relName(c, v))
+		}
+		b.WriteString("]")
+	}
+	return b.String()
+}
+
+func (v *MakeSlice) String() string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("make %s %s %s",
+		relType(v.Type(), from),
+		relName(v.Len, v),
+		relName(v.Cap, v))
+}
+
+func (v *Slice) String() string {
+	var b bytes.Buffer
+	b.WriteString("slice ")
+	b.WriteString(relName(v.X, v))
+	b.WriteString("[")
+	if v.Low != nil {
+		b.WriteString(relName(v.Low, v))
+	}
+	b.WriteString(":")
+	if v.High != nil {
+		b.WriteString(relName(v.High, v))
+	}
+	if v.Max != nil {
+		b.WriteString(":")
+		b.WriteString(relName(v.Max, v))
+	}
+	b.WriteString("]")
+	return b.String()
+}
+
+func (v *MakeMap) String() string {
+	res := ""
+	if v.Reserve != nil {
+		res = relName(v.Reserve, v)
+	}
+	from := v.Parent().pkg()
+	return fmt.Sprintf("make %s %s", relType(v.Type(), from), res)
+}
+
+func (v *MakeChan) String() string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("make %s %s", relType(v.Type(), from), relName(v.Size, v))
+}
+
+func (v *FieldAddr) String() string {
+	st := deref(v.X.Type()).Underlying().(*types.Struct)
+	// Be robust against a bad index.
+	name := "?"
+	if 0 <= v.Field && v.Field < st.NumFields() {
+		name = st.Field(v.Field).Name()
+	}
+	return fmt.Sprintf("&%s.%s [#%d]", relName(v.X, v), name, v.Field)
+}
+
+func (v *Field) String() string {
+	st := v.X.Type().Underlying().(*types.Struct)
+	// Be robust against a bad index.
+	name := "?"
+	if 0 <= v.Field && v.Field < st.NumFields() {
+		name = st.Field(v.Field).Name()
+	}
+	return fmt.Sprintf("%s.%s [#%d]", relName(v.X, v), name, v.Field)
+}
+
+func (v *IndexAddr) String() string {
+	return fmt.Sprintf("&%s[%s]", relName(v.X, v), relName(v.Index, v))
+}
+
+func (v *Index) String() string {
+	return fmt.Sprintf("%s[%s]", relName(v.X, v), relName(v.Index, v))
+}
+
+func (v *Lookup) String() string {
+	return fmt.Sprintf("%s[%s]%s", relName(v.X, v), relName(v.Index, v), commaOk(v.CommaOk))
+}
+
+func (v *Range) String() string {
+	return "range " + relName(v.X, v)
+}
+
+func (v *Next) String() string {
+	return "next " + relName(v.Iter, v)
+}
+
+func (v *TypeAssert) String() string {
+	from := v.Parent().pkg()
+	return fmt.Sprintf("typeassert%s %s.(%s)", commaOk(v.CommaOk), relName(v.X, v), relType(v.AssertedType, from))
+}
+
+func (v *Extract) String() string {
+	return fmt.Sprintf("extract %s #%d", relName(v.Tuple, v), v.Index)
+}
+
+func (s *Jump) String() string {
+	// Be robust against malformed CFG.
+	block := -1
+	if s.block != nil && len(s.block.Succs) == 1 {
+		block = s.block.Succs[0].Index
+	}
+	return fmt.Sprintf("jump %d", block)
+}
+
+func (s *If) String() string {
+	// Be robust against malformed CFG.
+	tblock, fblock := -1, -1
+	if s.block != nil && len(s.block.Succs) == 2 {
+		tblock = s.block.Succs[0].Index
+		fblock = s.block.Succs[1].Index
+	}
+	return fmt.Sprintf("if %s goto %d else %d", relName(s.Cond, s), tblock, fblock)
+}
+
+func (s *Go) String() string {
+	return printCall(&s.Call, "go ", s)
+}
+
+func (s *Panic) String() string {
+	return "panic " + relName(s.X, s)
+}
+
+func (s *Return) String() string {
+	var b bytes.Buffer
+	b.WriteString("return")
+	for i, r := range s.Results {
+		if i == 0 {
+			b.WriteString(" ")
+		} else {
+			b.WriteString(", ")
+		}
+		b.WriteString(relName(r, s))
+	}
+	return b.String()
+}
+
+func (*RunDefers) String() string {
+	return "rundefers"
+}
+
+func (s *Send) String() string {
+	return fmt.Sprintf("send %s <- %s", relName(s.Chan, s), relName(s.X, s))
+}
+
+func (s *Defer) String() string {
+	return printCall(&s.Call, "defer ", s)
+}
+
+func (s *Select) String() string {
+	var b bytes.Buffer
+	for i, st := range s.States {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		if st.Dir == types.RecvOnly {
+			b.WriteString("<-")
+			b.WriteString(relName(st.Chan, s))
+		} else {
+			b.WriteString(relName(st.Chan, s))
+			b.WriteString("<-")
+			b.WriteString(relName(st.Send, s))
+		}
+	}
+	non := ""
+	if !s.Blocking {
+		non = "non"
+	}
+	return fmt.Sprintf("select %sblocking [%s]", non, b.String())
+}
+
+func (s *Store) String() string {
+	return fmt.Sprintf("*%s = %s", relName(s.Addr, s), relName(s.Val, s))
+}
+
+func (s *MapUpdate) String() string {
+	return fmt.Sprintf("%s[%s] = %s", relName(s.Map, s), relName(s.Key, s), relName(s.Value, s))
+}
+
+func (s *DebugRef) String() string {
+	p := s.Parent().Prog.Fset.Position(s.Pos())
+	var descr interface{}
+	if s.object != nil {
+		descr = s.object // e.g. "var x int"
+	} else {
+		descr = reflect.TypeOf(s.Expr) // e.g. "*ast.CallExpr"
+	}
+	var addr string
+	if s.IsAddr {
+		addr = "address of "
+	}
+	return fmt.Sprintf("; %s%s @ %d:%d is %s", addr, descr, p.Line, p.Column, s.X.Name())
+}
+
+func (p *Package) String() string {
+	return "package " + p.Pkg.Path()
+}
+
+var _ io.WriterTo = (*Package)(nil) // *Package implements io.Writer
+
+func (p *Package) WriteTo(w io.Writer) (int64, error) {
+	var buf bytes.Buffer
+	WritePackage(&buf, p)
+	n, err := w.Write(buf.Bytes())
+	return int64(n), err
+}
+
+// WritePackage writes to buf a human-readable summary of p.
+func WritePackage(buf *bytes.Buffer, p *Package) {
+	fmt.Fprintf(buf, "%s:\n", p)
+
+	var names []string
+	maxname := 0
+	for name := range p.Members {
+		if l := len(name); l > maxname {
+			maxname = l
+		}
+		names = append(names, name)
+	}
+
+	from := p.Pkg
+	sort.Strings(names)
+	for _, name := range names {
+		switch mem := p.Members[name].(type) {
+		case *NamedConst:
+			fmt.Fprintf(buf, "  const %-*s %s = %s\n",
+				maxname, name, mem.Name(), mem.Value.RelString(from))
+
+		case *Function:
+			fmt.Fprintf(buf, "  func  %-*s %s\n",
+				maxname, name, relType(mem.Type(), from))
+
+		case *Type:
+			fmt.Fprintf(buf, "  type  %-*s %s\n",
+				maxname, name, relType(mem.Type().Underlying(), from))
+			for _, meth := range typeutil.IntuitiveMethodSet(mem.Type(), &p.Prog.MethodSets) {
+				fmt.Fprintf(buf, "    %s\n", types.SelectionString(meth, types.RelativeTo(from)))
+			}
+
+		case *Global:
+			fmt.Fprintf(buf, "  var   %-*s %s\n",
+				maxname, name, relType(mem.Type().(*types.Pointer).Elem(), from))
+		}
+	}
+
+	fmt.Fprintf(buf, "\n")
+}
+
+func commaOk(x bool) string {
+	if x {
+		return ",ok"
+	}
+	return ""
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/sanity.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/sanity.go
new file mode 100644
index 00000000..0d13beb9
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/sanity.go
@@ -0,0 +1,521 @@
+// 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 ssa
+
+// An optional pass for sanity-checking invariants of the SSA representation.
+// Currently it checks CFG invariants but little at the instruction level.
+
+import (
+	"fmt"
+	"go/types"
+	"io"
+	"os"
+	"strings"
+)
+
+type sanity struct {
+	reporter io.Writer
+	fn       *Function
+	block    *BasicBlock
+	instrs   map[Instruction]struct{}
+	insane   bool
+}
+
+// sanityCheck performs integrity checking of the SSA representation
+// of the function fn and returns true if it was valid.  Diagnostics
+// are written to reporter if non-nil, os.Stderr otherwise.  Some
+// diagnostics are only warnings and do not imply a negative result.
+//
+// Sanity-checking is intended to facilitate the debugging of code
+// transformation passes.
+//
+func sanityCheck(fn *Function, reporter io.Writer) bool {
+	if reporter == nil {
+		reporter = os.Stderr
+	}
+	return (&sanity{reporter: reporter}).checkFunction(fn)
+}
+
+// mustSanityCheck is like sanityCheck but panics instead of returning
+// a negative result.
+//
+func mustSanityCheck(fn *Function, reporter io.Writer) {
+	if !sanityCheck(fn, reporter) {
+		fn.WriteTo(os.Stderr)
+		panic("SanityCheck failed")
+	}
+}
+
+func (s *sanity) diagnostic(prefix, format string, args ...interface{}) {
+	fmt.Fprintf(s.reporter, "%s: function %s", prefix, s.fn)
+	if s.block != nil {
+		fmt.Fprintf(s.reporter, ", block %s", s.block)
+	}
+	io.WriteString(s.reporter, ": ")
+	fmt.Fprintf(s.reporter, format, args...)
+	io.WriteString(s.reporter, "\n")
+}
+
+func (s *sanity) errorf(format string, args ...interface{}) {
+	s.insane = true
+	s.diagnostic("Error", format, args...)
+}
+
+func (s *sanity) warnf(format string, args ...interface{}) {
+	s.diagnostic("Warning", format, args...)
+}
+
+// findDuplicate returns an arbitrary basic block that appeared more
+// than once in blocks, or nil if all were unique.
+func findDuplicate(blocks []*BasicBlock) *BasicBlock {
+	if len(blocks) < 2 {
+		return nil
+	}
+	if blocks[0] == blocks[1] {
+		return blocks[0]
+	}
+	// Slow path:
+	m := make(map[*BasicBlock]bool)
+	for _, b := range blocks {
+		if m[b] {
+			return b
+		}
+		m[b] = true
+	}
+	return nil
+}
+
+func (s *sanity) checkInstr(idx int, instr Instruction) {
+	switch instr := instr.(type) {
+	case *If, *Jump, *Return, *Panic:
+		s.errorf("control flow instruction not at end of block")
+	case *Phi:
+		if idx == 0 {
+			// It suffices to apply this check to just the first phi node.
+			if dup := findDuplicate(s.block.Preds); dup != nil {
+				s.errorf("phi node in block with duplicate predecessor %s", dup)
+			}
+		} else {
+			prev := s.block.Instrs[idx-1]
+			if _, ok := prev.(*Phi); !ok {
+				s.errorf("Phi instruction follows a non-Phi: %T", prev)
+			}
+		}
+		if ne, np := len(instr.Edges), len(s.block.Preds); ne != np {
+			s.errorf("phi node has %d edges but %d predecessors", ne, np)
+
+		} else {
+			for i, e := range instr.Edges {
+				if e == nil {
+					s.errorf("phi node '%s' has no value for edge #%d from %s", instr.Comment, i, s.block.Preds[i])
+				}
+			}
+		}
+
+	case *Alloc:
+		if !instr.Heap {
+			found := false
+			for _, l := range s.fn.Locals {
+				if l == instr {
+					found = true
+					break
+				}
+			}
+			if !found {
+				s.errorf("local alloc %s = %s does not appear in Function.Locals", instr.Name(), instr)
+			}
+		}
+
+	case *BinOp:
+	case *Call:
+	case *ChangeInterface:
+	case *ChangeType:
+	case *Convert:
+		if _, ok := instr.X.Type().Underlying().(*types.Basic); !ok {
+			if _, ok := instr.Type().Underlying().(*types.Basic); !ok {
+				s.errorf("convert %s -> %s: at least one type must be basic", instr.X.Type(), instr.Type())
+			}
+		}
+
+	case *Defer:
+	case *Extract:
+	case *Field:
+	case *FieldAddr:
+	case *Go:
+	case *Index:
+	case *IndexAddr:
+	case *Lookup:
+	case *MakeChan:
+	case *MakeClosure:
+		numFree := len(instr.Fn.(*Function).FreeVars)
+		numBind := len(instr.Bindings)
+		if numFree != numBind {
+			s.errorf("MakeClosure has %d Bindings for function %s with %d free vars",
+				numBind, instr.Fn, numFree)
+
+		}
+		if recv := instr.Type().(*types.Signature).Recv(); recv != nil {
+			s.errorf("MakeClosure's type includes receiver %s", recv.Type())
+		}
+
+	case *MakeInterface:
+	case *MakeMap:
+	case *MakeSlice:
+	case *MapUpdate:
+	case *Next:
+	case *Range:
+	case *RunDefers:
+	case *Select:
+	case *Send:
+	case *Slice:
+	case *Store:
+	case *TypeAssert:
+	case *UnOp:
+	case *DebugRef:
+		// TODO(adonovan): implement checks.
+	default:
+		panic(fmt.Sprintf("Unknown instruction type: %T", instr))
+	}
+
+	if call, ok := instr.(CallInstruction); ok {
+		if call.Common().Signature() == nil {
+			s.errorf("nil signature: %s", call)
+		}
+	}
+
+	// Check that value-defining instructions have valid types
+	// and a valid referrer list.
+	if v, ok := instr.(Value); ok {
+		t := v.Type()
+		if t == nil {
+			s.errorf("no type: %s = %s", v.Name(), v)
+		} else if t == tRangeIter {
+			// not a proper type; ignore.
+		} else if b, ok := t.Underlying().(*types.Basic); ok && b.Info()&types.IsUntyped != 0 {
+			s.errorf("instruction has 'untyped' result: %s = %s : %s", v.Name(), v, t)
+		}
+		s.checkReferrerList(v)
+	}
+
+	// Untyped constants are legal as instruction Operands(),
+	// for example:
+	//   _ = "foo"[0]
+	// or:
+	//   if wordsize==64 {...}
+
+	// All other non-Instruction Values can be found via their
+	// enclosing Function or Package.
+}
+
+func (s *sanity) checkFinalInstr(instr Instruction) {
+	switch instr := instr.(type) {
+	case *If:
+		if nsuccs := len(s.block.Succs); nsuccs != 2 {
+			s.errorf("If-terminated block has %d successors; expected 2", nsuccs)
+			return
+		}
+		if s.block.Succs[0] == s.block.Succs[1] {
+			s.errorf("If-instruction has same True, False target blocks: %s", s.block.Succs[0])
+			return
+		}
+
+	case *Jump:
+		if nsuccs := len(s.block.Succs); nsuccs != 1 {
+			s.errorf("Jump-terminated block has %d successors; expected 1", nsuccs)
+			return
+		}
+
+	case *Return:
+		if nsuccs := len(s.block.Succs); nsuccs != 0 {
+			s.errorf("Return-terminated block has %d successors; expected none", nsuccs)
+			return
+		}
+		if na, nf := len(instr.Results), s.fn.Signature.Results().Len(); nf != na {
+			s.errorf("%d-ary return in %d-ary function", na, nf)
+		}
+
+	case *Panic:
+		if nsuccs := len(s.block.Succs); nsuccs != 0 {
+			s.errorf("Panic-terminated block has %d successors; expected none", nsuccs)
+			return
+		}
+
+	default:
+		s.errorf("non-control flow instruction at end of block")
+	}
+}
+
+func (s *sanity) checkBlock(b *BasicBlock, index int) {
+	s.block = b
+
+	if b.Index != index {
+		s.errorf("block has incorrect Index %d", b.Index)
+	}
+	if b.parent != s.fn {
+		s.errorf("block has incorrect parent %s", b.parent)
+	}
+
+	// Check all blocks are reachable.
+	// (The entry block is always implicitly reachable,
+	// as is the Recover block, if any.)
+	if (index > 0 && b != b.parent.Recover) && len(b.Preds) == 0 {
+		s.warnf("unreachable block")
+		if b.Instrs == nil {
+			// Since this block is about to be pruned,
+			// tolerating transient problems in it
+			// simplifies other optimizations.
+			return
+		}
+	}
+
+	// Check predecessor and successor relations are dual,
+	// and that all blocks in CFG belong to same function.
+	for _, a := range b.Preds {
+		found := false
+		for _, bb := range a.Succs {
+			if bb == b {
+				found = true
+				break
+			}
+		}
+		if !found {
+			s.errorf("expected successor edge in predecessor %s; found only: %s", a, a.Succs)
+		}
+		if a.parent != s.fn {
+			s.errorf("predecessor %s belongs to different function %s", a, a.parent)
+		}
+	}
+	for _, c := range b.Succs {
+		found := false
+		for _, bb := range c.Preds {
+			if bb == b {
+				found = true
+				break
+			}
+		}
+		if !found {
+			s.errorf("expected predecessor edge in successor %s; found only: %s", c, c.Preds)
+		}
+		if c.parent != s.fn {
+			s.errorf("successor %s belongs to different function %s", c, c.parent)
+		}
+	}
+
+	// Check each instruction is sane.
+	n := len(b.Instrs)
+	if n == 0 {
+		s.errorf("basic block contains no instructions")
+	}
+	var rands [10]*Value // reuse storage
+	for j, instr := range b.Instrs {
+		if instr == nil {
+			s.errorf("nil instruction at index %d", j)
+			continue
+		}
+		if b2 := instr.Block(); b2 == nil {
+			s.errorf("nil Block() for instruction at index %d", j)
+			continue
+		} else if b2 != b {
+			s.errorf("wrong Block() (%s) for instruction at index %d ", b2, j)
+			continue
+		}
+		if j < n-1 {
+			s.checkInstr(j, instr)
+		} else {
+			s.checkFinalInstr(instr)
+		}
+
+		// Check Instruction.Operands.
+	operands:
+		for i, op := range instr.Operands(rands[:0]) {
+			if op == nil {
+				s.errorf("nil operand pointer %d of %s", i, instr)
+				continue
+			}
+			val := *op
+			if val == nil {
+				continue // a nil operand is ok
+			}
+
+			// Check that "untyped" types only appear on constant operands.
+			if _, ok := (*op).(*Const); !ok {
+				if basic, ok := (*op).Type().(*types.Basic); ok {
+					if basic.Info()&types.IsUntyped != 0 {
+						s.errorf("operand #%d of %s is untyped: %s", i, instr, basic)
+					}
+				}
+			}
+
+			// Check that Operands that are also Instructions belong to same function.
+			// TODO(adonovan): also check their block dominates block b.
+			if val, ok := val.(Instruction); ok {
+				if val.Block() == nil {
+					s.errorf("operand %d of %s is an instruction (%s) that belongs to no block", i, instr, val)
+				} else if val.Parent() != s.fn {
+					s.errorf("operand %d of %s is an instruction (%s) from function %s", i, instr, val, val.Parent())
+				}
+			}
+
+			// Check that each function-local operand of
+			// instr refers back to instr.  (NB: quadratic)
+			switch val := val.(type) {
+			case *Const, *Global, *Builtin:
+				continue // not local
+			case *Function:
+				if val.parent == nil {
+					continue // only anon functions are local
+				}
+			}
+
+			// TODO(adonovan): check val.Parent() != nil <=> val.Referrers() is defined.
+
+			if refs := val.Referrers(); refs != nil {
+				for _, ref := range *refs {
+					if ref == instr {
+						continue operands
+					}
+				}
+				s.errorf("operand %d of %s (%s) does not refer to us", i, instr, val)
+			} else {
+				s.errorf("operand %d of %s (%s) has no referrers", i, instr, val)
+			}
+		}
+	}
+}
+
+func (s *sanity) checkReferrerList(v Value) {
+	refs := v.Referrers()
+	if refs == nil {
+		s.errorf("%s has missing referrer list", v.Name())
+		return
+	}
+	for i, ref := range *refs {
+		if _, ok := s.instrs[ref]; !ok {
+			s.errorf("%s.Referrers()[%d] = %s is not an instruction belonging to this function", v.Name(), i, ref)
+		}
+	}
+}
+
+func (s *sanity) checkFunction(fn *Function) bool {
+	// TODO(adonovan): check Function invariants:
+	// - check params match signature
+	// - check transient fields are nil
+	// - warn if any fn.Locals do not appear among block instructions.
+	s.fn = fn
+	if fn.Prog == nil {
+		s.errorf("nil Prog")
+	}
+
+	fn.String()            // must not crash
+	fn.RelString(fn.pkg()) // must not crash
+
+	// All functions have a package, except delegates (which are
+	// shared across packages, or duplicated as weak symbols in a
+	// separate-compilation model), and error.Error.
+	if fn.Pkg == nil {
+		if strings.HasPrefix(fn.Synthetic, "wrapper ") ||
+			strings.HasPrefix(fn.Synthetic, "bound ") ||
+			strings.HasPrefix(fn.Synthetic, "thunk ") ||
+			strings.HasSuffix(fn.name, "Error") {
+			// ok
+		} else {
+			s.errorf("nil Pkg")
+		}
+	}
+	if src, syn := fn.Synthetic == "", fn.Syntax() != nil; src != syn {
+		s.errorf("got fromSource=%t, hasSyntax=%t; want same values", src, syn)
+	}
+	for i, l := range fn.Locals {
+		if l.Parent() != fn {
+			s.errorf("Local %s at index %d has wrong parent", l.Name(), i)
+		}
+		if l.Heap {
+			s.errorf("Local %s at index %d has Heap flag set", l.Name(), i)
+		}
+	}
+	// Build the set of valid referrers.
+	s.instrs = make(map[Instruction]struct{})
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			s.instrs[instr] = struct{}{}
+		}
+	}
+	for i, p := range fn.Params {
+		if p.Parent() != fn {
+			s.errorf("Param %s at index %d has wrong parent", p.Name(), i)
+		}
+		s.checkReferrerList(p)
+	}
+	for i, fv := range fn.FreeVars {
+		if fv.Parent() != fn {
+			s.errorf("FreeVar %s at index %d has wrong parent", fv.Name(), i)
+		}
+		s.checkReferrerList(fv)
+	}
+
+	if fn.Blocks != nil && len(fn.Blocks) == 0 {
+		// Function _had_ blocks (so it's not external) but
+		// they were "optimized" away, even the entry block.
+		s.errorf("Blocks slice is non-nil but empty")
+	}
+	for i, b := range fn.Blocks {
+		if b == nil {
+			s.warnf("nil *BasicBlock at f.Blocks[%d]", i)
+			continue
+		}
+		s.checkBlock(b, i)
+	}
+	if fn.Recover != nil && fn.Blocks[fn.Recover.Index] != fn.Recover {
+		s.errorf("Recover block is not in Blocks slice")
+	}
+
+	s.block = nil
+	for i, anon := range fn.AnonFuncs {
+		if anon.Parent() != fn {
+			s.errorf("AnonFuncs[%d]=%s but %s.Parent()=%s", i, anon, anon, anon.Parent())
+		}
+	}
+	s.fn = nil
+	return !s.insane
+}
+
+// sanityCheckPackage checks invariants of packages upon creation.
+// It does not require that the package is built.
+// Unlike sanityCheck (for functions), it just panics at the first error.
+func sanityCheckPackage(pkg *Package) {
+	if pkg.Pkg == nil {
+		panic(fmt.Sprintf("Package %s has no Object", pkg))
+	}
+	pkg.String() // must not crash
+
+	for name, mem := range pkg.Members {
+		if name != mem.Name() {
+			panic(fmt.Sprintf("%s: %T.Name() = %s, want %s",
+				pkg.Pkg.Path(), mem, mem.Name(), name))
+		}
+		obj := mem.Object()
+		if obj == nil {
+			// This check is sound because fields
+			// {Global,Function}.object have type
+			// types.Object.  (If they were declared as
+			// *types.{Var,Func}, we'd have a non-empty
+			// interface containing a nil pointer.)
+
+			continue // not all members have typechecker objects
+		}
+		if obj.Name() != name {
+			if obj.Name() == "init" && strings.HasPrefix(mem.Name(), "init#") {
+				// Ok.  The name of a declared init function varies between
+				// its types.Func ("init") and its ssa.Function ("init#%d").
+			} else {
+				panic(fmt.Sprintf("%s: %T.Object().Name() = %s, want %s",
+					pkg.Pkg.Path(), mem, obj.Name(), name))
+			}
+		}
+		if obj.Pos() != mem.Pos() {
+			panic(fmt.Sprintf("%s Pos=%d obj.Pos=%d", mem, mem.Pos(), obj.Pos()))
+		}
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/source.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/source.go
new file mode 100644
index 00000000..6d2223ed
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/source.go
@@ -0,0 +1,293 @@
+// 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 ssa
+
+// This file defines utilities for working with source positions
+// or source-level named entities ("objects").
+
+// TODO(adonovan): test that {Value,Instruction}.Pos() positions match
+// the originating syntax, as specified.
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// EnclosingFunction returns the function that contains the syntax
+// node denoted by path.
+//
+// Syntax associated with package-level variable specifications is
+// enclosed by the package's init() function.
+//
+// Returns nil if not found; reasons might include:
+//    - the node is not enclosed by any function.
+//    - the node is within an anonymous function (FuncLit) and
+//      its SSA function has not been created yet
+//      (pkg.Build() has not yet been called).
+//
+func EnclosingFunction(pkg *Package, path []ast.Node) *Function {
+	// Start with package-level function...
+	fn := findEnclosingPackageLevelFunction(pkg, path)
+	if fn == nil {
+		return nil // not in any function
+	}
+
+	// ...then walk down the nested anonymous functions.
+	n := len(path)
+outer:
+	for i := range path {
+		if lit, ok := path[n-1-i].(*ast.FuncLit); ok {
+			for _, anon := range fn.AnonFuncs {
+				if anon.Pos() == lit.Type.Func {
+					fn = anon
+					continue outer
+				}
+			}
+			// SSA function not found:
+			// - package not yet built, or maybe
+			// - builder skipped FuncLit in dead block
+			//   (in principle; but currently the Builder
+			//   generates even dead FuncLits).
+			return nil
+		}
+	}
+	return fn
+}
+
+// HasEnclosingFunction returns true if the AST node denoted by path
+// is contained within the declaration of some function or
+// package-level variable.
+//
+// Unlike EnclosingFunction, the behaviour of this function does not
+// depend on whether SSA code for pkg has been built, so it can be
+// used to quickly reject check inputs that will cause
+// EnclosingFunction to fail, prior to SSA building.
+//
+func HasEnclosingFunction(pkg *Package, path []ast.Node) bool {
+	return findEnclosingPackageLevelFunction(pkg, path) != nil
+}
+
+// findEnclosingPackageLevelFunction returns the Function
+// corresponding to the package-level function enclosing path.
+//
+func findEnclosingPackageLevelFunction(pkg *Package, path []ast.Node) *Function {
+	if n := len(path); n >= 2 { // [... {Gen,Func}Decl File]
+		switch decl := path[n-2].(type) {
+		case *ast.GenDecl:
+			if decl.Tok == token.VAR && n >= 3 {
+				// Package-level 'var' initializer.
+				return pkg.init
+			}
+
+		case *ast.FuncDecl:
+			if decl.Recv == nil && decl.Name.Name == "init" {
+				// Explicit init() function.
+				for _, b := range pkg.init.Blocks {
+					for _, instr := range b.Instrs {
+						if instr, ok := instr.(*Call); ok {
+							if callee, ok := instr.Call.Value.(*Function); ok && callee.Pkg == pkg && callee.Pos() == decl.Name.NamePos {
+								return callee
+							}
+						}
+					}
+				}
+				// Hack: return non-nil when SSA is not yet
+				// built so that HasEnclosingFunction works.
+				return pkg.init
+			}
+			// Declared function/method.
+			return findNamedFunc(pkg, decl.Name.NamePos)
+		}
+	}
+	return nil // not in any function
+}
+
+// findNamedFunc returns the named function whose FuncDecl.Ident is at
+// position pos.
+//
+func findNamedFunc(pkg *Package, pos token.Pos) *Function {
+	// Look at all package members and method sets of named types.
+	// Not very efficient.
+	for _, mem := range pkg.Members {
+		switch mem := mem.(type) {
+		case *Function:
+			if mem.Pos() == pos {
+				return mem
+			}
+		case *Type:
+			mset := pkg.Prog.MethodSets.MethodSet(types.NewPointer(mem.Type()))
+			for i, n := 0, mset.Len(); i < n; i++ {
+				// Don't call Program.Method: avoid creating wrappers.
+				obj := mset.At(i).Obj().(*types.Func)
+				if obj.Pos() == pos {
+					return pkg.values[obj].(*Function)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// ValueForExpr returns the SSA Value that corresponds to non-constant
+// expression e.
+//
+// It returns nil if no value was found, e.g.
+//    - the expression is not lexically contained within f;
+//    - f was not built with debug information; or
+//    - e is a constant expression.  (For efficiency, no debug
+//      information is stored for constants. Use
+//      go/types.Info.Types[e].Value instead.)
+//    - e is a reference to nil or a built-in function.
+//    - the value was optimised away.
+//
+// If e is an addressable expression used in an lvalue context,
+// value is the address denoted by e, and isAddr is true.
+//
+// The types of e (or &e, if isAddr) and the result are equal
+// (modulo "untyped" bools resulting from comparisons).
+//
+// (Tip: to find the ssa.Value given a source position, use
+// importer.PathEnclosingInterval to locate the ast.Node, then
+// EnclosingFunction to locate the Function, then ValueForExpr to find
+// the ssa.Value.)
+//
+func (f *Function) ValueForExpr(e ast.Expr) (value Value, isAddr bool) {
+	if f.debugInfo() { // (opt)
+		e = unparen(e)
+		for _, b := range f.Blocks {
+			for _, instr := range b.Instrs {
+				if ref, ok := instr.(*DebugRef); ok {
+					if ref.Expr == e {
+						return ref.X, ref.IsAddr
+					}
+				}
+			}
+		}
+	}
+	return
+}
+
+// --- Lookup functions for source-level named entities (types.Objects) ---
+
+// Package returns the SSA Package corresponding to the specified
+// type-checker package object.
+// It returns nil if no such SSA package has been created.
+//
+func (prog *Program) Package(obj *types.Package) *Package {
+	return prog.packages[obj]
+}
+
+// packageLevelValue returns the package-level value corresponding to
+// the specified named object, which may be a package-level const
+// (*Const), var (*Global) or func (*Function) of some package in
+// prog.  It returns nil if the object is not found.
+//
+func (prog *Program) packageLevelValue(obj types.Object) Value {
+	if pkg, ok := prog.packages[obj.Pkg()]; ok {
+		return pkg.values[obj]
+	}
+	return nil
+}
+
+// FuncValue returns the concrete Function denoted by the source-level
+// named function obj, or nil if obj denotes an interface method.
+//
+// TODO(adonovan): check the invariant that obj.Type() matches the
+// result's Signature, both in the params/results and in the receiver.
+//
+func (prog *Program) FuncValue(obj *types.Func) *Function {
+	fn, _ := prog.packageLevelValue(obj).(*Function)
+	return fn
+}
+
+// ConstValue returns the SSA Value denoted by the source-level named
+// constant obj.
+//
+func (prog *Program) ConstValue(obj *types.Const) *Const {
+	// TODO(adonovan): opt: share (don't reallocate)
+	// Consts for const objects and constant ast.Exprs.
+
+	// Universal constant? {true,false,nil}
+	if obj.Parent() == types.Universe {
+		return NewConst(obj.Val(), obj.Type())
+	}
+	// Package-level named constant?
+	if v := prog.packageLevelValue(obj); v != nil {
+		return v.(*Const)
+	}
+	return NewConst(obj.Val(), obj.Type())
+}
+
+// VarValue returns the SSA Value that corresponds to a specific
+// identifier denoting the source-level named variable obj.
+//
+// VarValue returns nil if a local variable was not found, perhaps
+// because its package was not built, the debug information was not
+// requested during SSA construction, or the value was optimized away.
+//
+// ref is the path to an ast.Ident (e.g. from PathEnclosingInterval),
+// and that ident must resolve to obj.
+//
+// pkg is the package enclosing the reference.  (A reference to a var
+// always occurs within a function, so we need to know where to find it.)
+//
+// If the identifier is a field selector and its base expression is
+// non-addressable, then VarValue returns the value of that field.
+// For example:
+//    func f() struct {x int}
+//    f().x  // VarValue(x) returns a *Field instruction of type int
+//
+// All other identifiers denote addressable locations (variables).
+// For them, VarValue may return either the variable's address or its
+// value, even when the expression is evaluated only for its value; the
+// situation is reported by isAddr, the second component of the result.
+//
+// If !isAddr, the returned value is the one associated with the
+// specific identifier.  For example,
+//       var x int    // VarValue(x) returns Const 0 here
+//       x = 1        // VarValue(x) returns Const 1 here
+//
+// It is not specified whether the value or the address is returned in
+// any particular case, as it may depend upon optimizations performed
+// during SSA code generation, such as registerization, constant
+// folding, avoidance of materialization of subexpressions, etc.
+//
+func (prog *Program) VarValue(obj *types.Var, pkg *Package, ref []ast.Node) (value Value, isAddr bool) {
+	// All references to a var are local to some function, possibly init.
+	fn := EnclosingFunction(pkg, ref)
+	if fn == nil {
+		return // e.g. def of struct field; SSA not built?
+	}
+
+	id := ref[0].(*ast.Ident)
+
+	// Defining ident of a parameter?
+	if id.Pos() == obj.Pos() {
+		for _, param := range fn.Params {
+			if param.Object() == obj {
+				return param, false
+			}
+		}
+	}
+
+	// Other ident?
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			if dr, ok := instr.(*DebugRef); ok {
+				if dr.Pos() == id.Pos() {
+					return dr.X, dr.IsAddr
+				}
+			}
+		}
+	}
+
+	// Defining ident of package-level var?
+	if v := prog.packageLevelValue(obj); v != nil {
+		return v.(*Global), true
+	}
+
+	return // e.g. debug info not requested, or var optimized away
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssa.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssa.go
new file mode 100644
index 00000000..e8350f1c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssa.go
@@ -0,0 +1,1696 @@
+// 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 ssa
+
+// This package defines a high-level intermediate representation for
+// Go programs using static single-assignment (SSA) form.
+
+import (
+	"fmt"
+	"go/ast"
+	exact "go/constant"
+	"go/token"
+	"go/types"
+	"sync"
+
+	"golang.org/x/tools/go/types/typeutil"
+)
+
+// A Program is a partial or complete Go program converted to SSA form.
+type Program struct {
+	Fset       *token.FileSet              // position information for the files of this Program
+	imported   map[string]*Package         // all importable Packages, keyed by import path
+	packages   map[*types.Package]*Package // all loaded Packages, keyed by object
+	mode       BuilderMode                 // set of mode bits for SSA construction
+	MethodSets typeutil.MethodSetCache     // cache of type-checker's method-sets
+
+	methodsMu    sync.Mutex                 // guards the following maps:
+	methodSets   typeutil.Map               // maps type to its concrete methodSet
+	runtimeTypes typeutil.Map               // types for which rtypes are needed
+	canon        typeutil.Map               // type canonicalization map
+	bounds       map[*types.Func]*Function  // bounds for curried x.Method closures
+	thunks       map[selectionKey]*Function // thunks for T.Method expressions
+}
+
+// A Package is a single analyzed Go package containing Members for
+// all package-level functions, variables, constants and types it
+// declares.  These may be accessed directly via Members, or via the
+// type-specific accessor methods Func, Type, Var and Const.
+//
+// Members also contains entries for "init" (the synthetic package
+// initializer) and "init#%d", the nth declared init function,
+// and unspecified other things too.
+//
+type Package struct {
+	Prog    *Program               // the owning program
+	Pkg     *types.Package         // the corresponding go/types.Package
+	Members map[string]Member      // all package members keyed by name (incl. init and init#%d)
+	values  map[types.Object]Value // package members (incl. types and methods), keyed by object
+	init    *Function              // Func("init"); the package's init function
+	debug   bool                   // include full debug info in this package
+
+	// The following fields are set transiently, then cleared
+	// after building.
+	buildOnce sync.Once   // ensures package building occurs once
+	ninit     int32       // number of init functions
+	info      *types.Info // package type information
+	files     []*ast.File // package ASTs
+}
+
+// A Member is a member of a Go package, implemented by *NamedConst,
+// *Global, *Function, or *Type; they are created by package-level
+// const, var, func and type declarations respectively.
+//
+type Member interface {
+	Name() string                    // declared name of the package member
+	String() string                  // package-qualified name of the package member
+	RelString(*types.Package) string // like String, but relative refs are unqualified
+	Object() types.Object            // typechecker's object for this member, if any
+	Pos() token.Pos                  // position of member's declaration, if known
+	Type() types.Type                // type of the package member
+	Token() token.Token              // token.{VAR,FUNC,CONST,TYPE}
+	Package() *Package               // the containing package
+}
+
+// A Type is a Member of a Package representing a package-level named type.
+type Type struct {
+	object *types.TypeName
+	pkg    *Package
+}
+
+// A NamedConst is a Member of a Package representing a package-level
+// named constant.
+//
+// Pos() returns the position of the declaring ast.ValueSpec.Names[*]
+// identifier.
+//
+// NB: a NamedConst is not a Value; it contains a constant Value, which
+// it augments with the name and position of its 'const' declaration.
+//
+type NamedConst struct {
+	object *types.Const
+	Value  *Const
+	pkg    *Package
+}
+
+// A Value is an SSA value that can be referenced by an instruction.
+type Value interface {
+	// Name returns the name of this value, and determines how
+	// this Value appears when used as an operand of an
+	// Instruction.
+	//
+	// This is the same as the source name for Parameters,
+	// Builtins, Functions, FreeVars, Globals.
+	// For constants, it is a representation of the constant's value
+	// and type.  For all other Values this is the name of the
+	// virtual register defined by the instruction.
+	//
+	// The name of an SSA Value is not semantically significant,
+	// and may not even be unique within a function.
+	Name() string
+
+	// If this value is an Instruction, String returns its
+	// disassembled form; otherwise it returns unspecified
+	// human-readable information about the Value, such as its
+	// kind, name and type.
+	String() string
+
+	// Type returns the type of this value.  Many instructions
+	// (e.g. IndexAddr) change their behaviour depending on the
+	// types of their operands.
+	Type() types.Type
+
+	// Parent returns the function to which this Value belongs.
+	// It returns nil for named Functions, Builtin, Const and Global.
+	Parent() *Function
+
+	// Referrers returns the list of instructions that have this
+	// value as one of their operands; it may contain duplicates
+	// if an instruction has a repeated operand.
+	//
+	// Referrers actually returns a pointer through which the
+	// caller may perform mutations to the object's state.
+	//
+	// Referrers is currently only defined if Parent()!=nil,
+	// i.e. for the function-local values FreeVar, Parameter,
+	// Functions (iff anonymous) and all value-defining instructions.
+	// It returns nil for named Functions, Builtin, Const and Global.
+	//
+	// Instruction.Operands contains the inverse of this relation.
+	Referrers() *[]Instruction
+
+	// Pos returns the location of the AST token most closely
+	// associated with the operation that gave rise to this value,
+	// or token.NoPos if it was not explicit in the source.
+	//
+	// For each ast.Node type, a particular token is designated as
+	// the closest location for the expression, e.g. the Lparen
+	// for an *ast.CallExpr.  This permits a compact but
+	// approximate mapping from Values to source positions for use
+	// in diagnostic messages, for example.
+	//
+	// (Do not use this position to determine which Value
+	// corresponds to an ast.Expr; use Function.ValueForExpr
+	// instead.  NB: it requires that the function was built with
+	// debug information.)
+	Pos() token.Pos
+}
+
+// An Instruction is an SSA instruction that computes a new Value or
+// has some effect.
+//
+// An Instruction that defines a value (e.g. BinOp) also implements
+// the Value interface; an Instruction that only has an effect (e.g. Store)
+// does not.
+//
+type Instruction interface {
+	// String returns the disassembled form of this value.
+	//
+	// Examples of Instructions that are Values:
+	//       "x + y"     (BinOp)
+	//       "len([])"   (Call)
+	// Note that the name of the Value is not printed.
+	//
+	// Examples of Instructions that are not Values:
+	//       "return x"  (Return)
+	//       "*y = x"    (Store)
+	//
+	// (The separation Value.Name() from Value.String() is useful
+	// for some analyses which distinguish the operation from the
+	// value it defines, e.g., 'y = local int' is both an allocation
+	// of memory 'local int' and a definition of a pointer y.)
+	String() string
+
+	// Parent returns the function to which this instruction
+	// belongs.
+	Parent() *Function
+
+	// Block returns the basic block to which this instruction
+	// belongs.
+	Block() *BasicBlock
+
+	// setBlock sets the basic block to which this instruction belongs.
+	setBlock(*BasicBlock)
+
+	// Operands returns the operands of this instruction: the
+	// set of Values it references.
+	//
+	// Specifically, it appends their addresses to rands, a
+	// user-provided slice, and returns the resulting slice,
+	// permitting avoidance of memory allocation.
+	//
+	// The operands are appended in undefined order, but the order
+	// is consistent for a given Instruction; the addresses are
+	// always non-nil but may point to a nil Value.  Clients may
+	// store through the pointers, e.g. to effect a value
+	// renaming.
+	//
+	// Value.Referrers is a subset of the inverse of this
+	// relation.  (Referrers are not tracked for all types of
+	// Values.)
+	Operands(rands []*Value) []*Value
+
+	// Pos returns the location of the AST token most closely
+	// associated with the operation that gave rise to this
+	// instruction, or token.NoPos if it was not explicit in the
+	// source.
+	//
+	// For each ast.Node type, a particular token is designated as
+	// the closest location for the expression, e.g. the Go token
+	// for an *ast.GoStmt.  This permits a compact but approximate
+	// mapping from Instructions to source positions for use in
+	// diagnostic messages, for example.
+	//
+	// (Do not use this position to determine which Instruction
+	// corresponds to an ast.Expr; see the notes for Value.Pos.
+	// This position may be used to determine which non-Value
+	// Instruction corresponds to some ast.Stmts, but not all: If
+	// and Jump instructions have no Pos(), for example.)
+	Pos() token.Pos
+}
+
+// A Node is a node in the SSA value graph.  Every concrete type that
+// implements Node is also either a Value, an Instruction, or both.
+//
+// Node contains the methods common to Value and Instruction, plus the
+// Operands and Referrers methods generalized to return nil for
+// non-Instructions and non-Values, respectively.
+//
+// Node is provided to simplify SSA graph algorithms.  Clients should
+// use the more specific and informative Value or Instruction
+// interfaces where appropriate.
+//
+type Node interface {
+	// Common methods:
+	String() string
+	Pos() token.Pos
+	Parent() *Function
+
+	// Partial methods:
+	Operands(rands []*Value) []*Value // nil for non-Instructions
+	Referrers() *[]Instruction        // nil for non-Values
+}
+
+// Function represents the parameters, results, and code of a function
+// or method.
+//
+// If Blocks is nil, this indicates an external function for which no
+// Go source code is available.  In this case, FreeVars and Locals
+// are nil too.  Clients performing whole-program analysis must
+// handle external functions specially.
+//
+// Blocks contains the function's control-flow graph (CFG).
+// Blocks[0] is the function entry point; block order is not otherwise
+// semantically significant, though it may affect the readability of
+// the disassembly.
+// To iterate over the blocks in dominance order, use DomPreorder().
+//
+// Recover is an optional second entry point to which control resumes
+// after a recovered panic.  The Recover block may contain only a return
+// statement, preceded by a load of the function's named return
+// parameters, if any.
+//
+// A nested function (Parent()!=nil) that refers to one or more
+// lexically enclosing local variables ("free variables") has FreeVars.
+// Such functions cannot be called directly but require a
+// value created by MakeClosure which, via its Bindings, supplies
+// values for these parameters.
+//
+// If the function is a method (Signature.Recv() != nil) then the first
+// element of Params is the receiver parameter.
+//
+// A Go package may declare many functions called "init".
+// For each one, Object().Name() returns "init" but Name() returns
+// "init#1", etc, in declaration order.
+//
+// Pos() returns the declaring ast.FuncLit.Type.Func or the position
+// of the ast.FuncDecl.Name, if the function was explicit in the
+// source.  Synthetic wrappers, for which Synthetic != "", may share
+// the same position as the function they wrap.
+// Syntax.Pos() always returns the position of the declaring "func" token.
+//
+// Type() returns the function's Signature.
+//
+type Function struct {
+	name      string
+	object    types.Object     // a declared *types.Func or one of its wrappers
+	method    *types.Selection // info about provenance of synthetic methods
+	Signature *types.Signature
+	pos       token.Pos
+
+	Synthetic string        // provenance of synthetic function; "" for true source functions
+	syntax    ast.Node      // *ast.Func{Decl,Lit}; replaced with simple ast.Node after build, unless debug mode
+	parent    *Function     // enclosing function if anon; nil if global
+	Pkg       *Package      // enclosing package; nil for shared funcs (wrappers and error.Error)
+	Prog      *Program      // enclosing program
+	Params    []*Parameter  // function parameters; for methods, includes receiver
+	FreeVars  []*FreeVar    // free variables whose values must be supplied by closure
+	Locals    []*Alloc      // local variables of this function
+	Blocks    []*BasicBlock // basic blocks of the function; nil => external
+	Recover   *BasicBlock   // optional; control transfers here after recovered panic
+	AnonFuncs []*Function   // anonymous functions directly beneath this one
+	referrers []Instruction // referring instructions (iff Parent() != nil)
+
+	// The following fields are set transiently during building,
+	// then cleared.
+	currentBlock *BasicBlock             // where to emit code
+	objects      map[types.Object]Value  // addresses of local variables
+	namedResults []*Alloc                // tuple of named results
+	targets      *targets                // linked stack of branch targets
+	lblocks      map[*ast.Object]*lblock // labelled blocks
+}
+
+// BasicBlock represents an SSA basic block.
+//
+// The final element of Instrs is always an explicit transfer of
+// control (If, Jump, Return, or Panic).
+//
+// A block may contain no Instructions only if it is unreachable,
+// i.e., Preds is nil.  Empty blocks are typically pruned.
+//
+// BasicBlocks and their Preds/Succs relation form a (possibly cyclic)
+// graph independent of the SSA Value graph: the control-flow graph or
+// CFG.  It is illegal for multiple edges to exist between the same
+// pair of blocks.
+//
+// Each BasicBlock is also a node in the dominator tree of the CFG.
+// The tree may be navigated using Idom()/Dominees() and queried using
+// Dominates().
+//
+// The order of Preds and Succs is significant (to Phi and If
+// instructions, respectively).
+//
+type BasicBlock struct {
+	Index        int            // index of this block within Parent().Blocks
+	Comment      string         // optional label; no semantic significance
+	parent       *Function      // parent function
+	Instrs       []Instruction  // instructions in order
+	Preds, Succs []*BasicBlock  // predecessors and successors
+	succs2       [2]*BasicBlock // initial space for Succs
+	dom          domInfo        // dominator tree info
+	gaps         int            // number of nil Instrs (transient)
+	rundefers    int            // number of rundefers (transient)
+}
+
+// Pure values ----------------------------------------
+
+// A FreeVar represents a free variable of the function to which it
+// belongs.
+//
+// FreeVars are used to implement anonymous functions, whose free
+// variables are lexically captured in a closure formed by
+// MakeClosure.  The value of such a free var is an Alloc or another
+// FreeVar and is considered a potentially escaping heap address, with
+// pointer type.
+//
+// FreeVars are also used to implement bound method closures.  Such a
+// free var represents the receiver value and may be of any type that
+// has concrete methods.
+//
+// Pos() returns the position of the value that was captured, which
+// belongs to an enclosing function.
+//
+type FreeVar struct {
+	name      string
+	typ       types.Type
+	pos       token.Pos
+	parent    *Function
+	referrers []Instruction
+
+	// Transiently needed during building.
+	outer Value // the Value captured from the enclosing context.
+}
+
+// A Parameter represents an input parameter of a function.
+//
+type Parameter struct {
+	name      string
+	object    types.Object // a *types.Var; nil for non-source locals
+	typ       types.Type
+	pos       token.Pos
+	parent    *Function
+	referrers []Instruction
+}
+
+// A Const represents the value of a constant expression.
+//
+// The underlying type of a constant may be any boolean, numeric, or
+// string type.  In addition, a Const may represent the nil value of
+// any reference type---interface, map, channel, pointer, slice, or
+// function---but not "untyped nil".
+//
+// All source-level constant expressions are represented by a Const
+// of the same type and value.
+//
+// Value holds the exact value of the constant, independent of its
+// Type(), using the same representation as package go/exact uses for
+// constants, or nil for a typed nil value.
+//
+// Pos() returns token.NoPos.
+//
+// Example printed form:
+// 	42:int
+//	"hello":untyped string
+//	3+4i:MyComplex
+//
+type Const struct {
+	typ   types.Type
+	Value exact.Value
+}
+
+// A Global is a named Value holding the address of a package-level
+// variable.
+//
+// Pos() returns the position of the ast.ValueSpec.Names[*]
+// identifier.
+//
+type Global struct {
+	name   string
+	object types.Object // a *types.Var; may be nil for synthetics e.g. init$guard
+	typ    types.Type
+	pos    token.Pos
+
+	Pkg *Package
+}
+
+// A Builtin represents a specific use of a built-in function, e.g. len.
+//
+// Builtins are immutable values.  Builtins do not have addresses.
+// Builtins can only appear in CallCommon.Func.
+//
+// Name() indicates the function: one of the built-in functions from the
+// Go spec (excluding "make" and "new") or one of these ssa-defined
+// intrinsics:
+//
+//   // wrapnilchk returns ptr if non-nil, panics otherwise.
+//   // (For use in indirection wrappers.)
+//   func ssa:wrapnilchk(ptr *T, recvType, methodName string) *T
+//
+// Object() returns a *types.Builtin for built-ins defined by the spec,
+// nil for others.
+//
+// Type() returns a *types.Signature representing the effective
+// signature of the built-in for this call.
+//
+type Builtin struct {
+	name string
+	sig  *types.Signature
+}
+
+// Value-defining instructions  ----------------------------------------
+
+// The Alloc instruction reserves space for a variable of the given type,
+// zero-initializes it, and yields its address.
+//
+// Alloc values are always addresses, and have pointer types, so the
+// type of the allocated variable is actually
+// Type().Underlying().(*types.Pointer).Elem().
+//
+// If Heap is false, Alloc allocates space in the function's
+// activation record (frame); we refer to an Alloc(Heap=false) as a
+// "local" alloc.  Each local Alloc returns the same address each time
+// it is executed within the same activation; the space is
+// re-initialized to zero.
+//
+// If Heap is true, Alloc allocates space in the heap; we
+// refer to an Alloc(Heap=true) as a "new" alloc.  Each new Alloc
+// returns a different address each time it is executed.
+//
+// When Alloc is applied to a channel, map or slice type, it returns
+// the address of an uninitialized (nil) reference of that kind; store
+// the result of MakeSlice, MakeMap or MakeChan in that location to
+// instantiate these types.
+//
+// Pos() returns the ast.CompositeLit.Lbrace for a composite literal,
+// or the ast.CallExpr.Rparen for a call to new() or for a call that
+// allocates a varargs slice.
+//
+// Example printed form:
+// 	t0 = local int
+// 	t1 = new int
+//
+type Alloc struct {
+	register
+	Comment string
+	Heap    bool
+	index   int // dense numbering; for lifting
+}
+
+// The Phi instruction represents an SSA φ-node, which combines values
+// that differ across incoming control-flow edges and yields a new
+// value.  Within a block, all φ-nodes must appear before all non-φ
+// nodes.
+//
+// Pos() returns the position of the && or || for short-circuit
+// control-flow joins, or that of the *Alloc for φ-nodes inserted
+// during SSA renaming.
+//
+// Example printed form:
+// 	t2 = phi [0: t0, 1: t1]
+//
+type Phi struct {
+	register
+	Comment string  // a hint as to its purpose
+	Edges   []Value // Edges[i] is value for Block().Preds[i]
+}
+
+// The Call instruction represents a function or method call.
+//
+// The Call instruction yields the function result if there is exactly
+// one.  Otherwise it returns a tuple, the components of which are
+// accessed via Extract.
+//
+// See CallCommon for generic function call documentation.
+//
+// Pos() returns the ast.CallExpr.Lparen, if explicit in the source.
+//
+// Example printed form:
+// 	t2 = println(t0, t1)
+// 	t4 = t3()
+// 	t7 = invoke t5.Println(...t6)
+//
+type Call struct {
+	register
+	Call CallCommon
+}
+
+// The BinOp instruction yields the result of binary operation X Op Y.
+//
+// Pos() returns the ast.BinaryExpr.OpPos, if explicit in the source.
+//
+// Example printed form:
+// 	t1 = t0 + 1:int
+//
+type BinOp struct {
+	register
+	// One of:
+	// ADD SUB MUL QUO REM          + - * / %
+	// AND OR XOR SHL SHR AND_NOT   & | ^ << >> &~
+	// EQL LSS GTR NEQ LEQ GEQ      == != < <= < >=
+	Op   token.Token
+	X, Y Value
+}
+
+// The UnOp instruction yields the result of Op X.
+// ARROW is channel receive.
+// MUL is pointer indirection (load).
+// XOR is bitwise complement.
+// SUB is negation.
+// NOT is logical negation.
+//
+// If CommaOk and Op=ARROW, the result is a 2-tuple of the value above
+// and a boolean indicating the success of the receive.  The
+// components of the tuple are accessed using Extract.
+//
+// Pos() returns the ast.UnaryExpr.OpPos, if explicit in the source.
+// For receive operations (ARROW) implicit in ranging over a channel,
+// Pos() returns the ast.RangeStmt.For.
+// For implicit memory loads (STAR), Pos() returns the position of the
+// most closely associated source-level construct; the details are not
+// specified.
+//
+// Example printed form:
+// 	t0 = *x
+// 	t2 = <-t1,ok
+//
+type UnOp struct {
+	register
+	Op      token.Token // One of: NOT SUB ARROW MUL XOR ! - <- * ^
+	X       Value
+	CommaOk bool
+}
+
+// The ChangeType instruction applies to X a value-preserving type
+// change to Type().
+//
+// Type changes are permitted:
+//    - between a named type and its underlying type.
+//    - between two named types of the same underlying type.
+//    - between (possibly named) pointers to identical base types.
+//    - from a bidirectional channel to a read- or write-channel,
+//      optionally adding/removing a name.
+//
+// This operation cannot fail dynamically.
+//
+// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
+// from an explicit conversion in the source.
+//
+// Example printed form:
+// 	t1 = changetype *int <- IntPtr (t0)
+//
+type ChangeType struct {
+	register
+	X Value
+}
+
+// The Convert instruction yields the conversion of value X to type
+// Type().  One or both of those types is basic (but possibly named).
+//
+// A conversion may change the value and representation of its operand.
+// Conversions are permitted:
+//    - between real numeric types.
+//    - between complex numeric types.
+//    - between string and []byte or []rune.
+//    - between pointers and unsafe.Pointer.
+//    - between unsafe.Pointer and uintptr.
+//    - from (Unicode) integer to (UTF-8) string.
+// A conversion may imply a type name change also.
+//
+// This operation cannot fail dynamically.
+//
+// Conversions of untyped string/number/bool constants to a specific
+// representation are eliminated during SSA construction.
+//
+// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
+// from an explicit conversion in the source.
+//
+// Example printed form:
+// 	t1 = convert []byte <- string (t0)
+//
+type Convert struct {
+	register
+	X Value
+}
+
+// ChangeInterface constructs a value of one interface type from a
+// value of another interface type known to be assignable to it.
+// This operation cannot fail.
+//
+// Pos() returns the ast.CallExpr.Lparen if the instruction arose from
+// an explicit T(e) conversion; the ast.TypeAssertExpr.Lparen if the
+// instruction arose from an explicit e.(T) operation; or token.NoPos
+// otherwise.
+//
+// Example printed form:
+// 	t1 = change interface interface{} <- I (t0)
+//
+type ChangeInterface struct {
+	register
+	X Value
+}
+
+// MakeInterface constructs an instance of an interface type from a
+// value of a concrete type.
+//
+// Use Program.MethodSets.MethodSet(X.Type()) to find the method-set
+// of X, and Program.Method(m) to find the implementation of a method.
+//
+// To construct the zero value of an interface type T, use:
+// 	NewConst(exact.MakeNil(), T, pos)
+//
+// Pos() returns the ast.CallExpr.Lparen, if the instruction arose
+// from an explicit conversion in the source.
+//
+// Example printed form:
+// 	t1 = make interface{} <- int (42:int)
+// 	t2 = make Stringer <- t0
+//
+type MakeInterface struct {
+	register
+	X Value
+}
+
+// The MakeClosure instruction yields a closure value whose code is
+// Fn and whose free variables' values are supplied by Bindings.
+//
+// Type() returns a (possibly named) *types.Signature.
+//
+// Pos() returns the ast.FuncLit.Type.Func for a function literal
+// closure or the ast.SelectorExpr.Sel for a bound method closure.
+//
+// Example printed form:
+// 	t0 = make closure anon@1.2 [x y z]
+// 	t1 = make closure bound$(main.I).add [i]
+//
+type MakeClosure struct {
+	register
+	Fn       Value   // always a *Function
+	Bindings []Value // values for each free variable in Fn.FreeVars
+}
+
+// The MakeMap instruction creates a new hash-table-based map object
+// and yields a value of kind map.
+//
+// Type() returns a (possibly named) *types.Map.
+//
+// Pos() returns the ast.CallExpr.Lparen, if created by make(map), or
+// the ast.CompositeLit.Lbrack if created by a literal.
+//
+// Example printed form:
+// 	t1 = make map[string]int t0
+// 	t1 = make StringIntMap t0
+//
+type MakeMap struct {
+	register
+	Reserve Value // initial space reservation; nil => default
+}
+
+// The MakeChan instruction creates a new channel object and yields a
+// value of kind chan.
+//
+// Type() returns a (possibly named) *types.Chan.
+//
+// Pos() returns the ast.CallExpr.Lparen for the make(chan) that
+// created it.
+//
+// Example printed form:
+// 	t0 = make chan int 0
+// 	t0 = make IntChan 0
+//
+type MakeChan struct {
+	register
+	Size Value // int; size of buffer; zero => synchronous.
+}
+
+// The MakeSlice instruction yields a slice of length Len backed by a
+// newly allocated array of length Cap.
+//
+// Both Len and Cap must be non-nil Values of integer type.
+//
+// (Alloc(types.Array) followed by Slice will not suffice because
+// Alloc can only create arrays of constant length.)
+//
+// Type() returns a (possibly named) *types.Slice.
+//
+// Pos() returns the ast.CallExpr.Lparen for the make([]T) that
+// created it.
+//
+// Example printed form:
+// 	t1 = make []string 1:int t0
+// 	t1 = make StringSlice 1:int t0
+//
+type MakeSlice struct {
+	register
+	Len Value
+	Cap Value
+}
+
+// The Slice instruction yields a slice of an existing string, slice
+// or *array X between optional integer bounds Low and High.
+//
+// Dynamically, this instruction panics if X evaluates to a nil *array
+// pointer.
+//
+// Type() returns string if the type of X was string, otherwise a
+// *types.Slice with the same element type as X.
+//
+// Pos() returns the ast.SliceExpr.Lbrack if created by a x[:] slice
+// operation, the ast.CompositeLit.Lbrace if created by a literal, or
+// NoPos if not explicit in the source (e.g. a variadic argument slice).
+//
+// Example printed form:
+// 	t1 = slice t0[1:]
+//
+type Slice struct {
+	register
+	X              Value // slice, string, or *array
+	Low, High, Max Value // each may be nil
+}
+
+// The FieldAddr instruction yields the address of Field of *struct X.
+//
+// The field is identified by its index within the field list of the
+// struct type of X.
+//
+// Dynamically, this instruction panics if X evaluates to a nil
+// pointer.
+//
+// Type() returns a (possibly named) *types.Pointer.
+//
+// Pos() returns the position of the ast.SelectorExpr.Sel for the
+// field, if explicit in the source.
+//
+// Example printed form:
+// 	t1 = &t0.name [#1]
+//
+type FieldAddr struct {
+	register
+	X     Value // *struct
+	Field int   // index into X.Type().Deref().(*types.Struct).Fields
+}
+
+// The Field instruction yields the Field of struct X.
+//
+// The field is identified by its index within the field list of the
+// struct type of X; by using numeric indices we avoid ambiguity of
+// package-local identifiers and permit compact representations.
+//
+// Pos() returns the position of the ast.SelectorExpr.Sel for the
+// field, if explicit in the source.
+//
+// Example printed form:
+// 	t1 = t0.name [#1]
+//
+type Field struct {
+	register
+	X     Value // struct
+	Field int   // index into X.Type().(*types.Struct).Fields
+}
+
+// The IndexAddr instruction yields the address of the element at
+// index Index of collection X.  Index is an integer expression.
+//
+// The elements of maps and strings are not addressable; use Lookup or
+// MapUpdate instead.
+//
+// Dynamically, this instruction panics if X evaluates to a nil *array
+// pointer.
+//
+// Type() returns a (possibly named) *types.Pointer.
+//
+// Pos() returns the ast.IndexExpr.Lbrack for the index operation, if
+// explicit in the source.
+//
+// Example printed form:
+// 	t2 = &t0[t1]
+//
+type IndexAddr struct {
+	register
+	X     Value // slice or *array,
+	Index Value // numeric index
+}
+
+// The Index instruction yields element Index of array X.
+//
+// Pos() returns the ast.IndexExpr.Lbrack for the index operation, if
+// explicit in the source.
+//
+// Example printed form:
+// 	t2 = t0[t1]
+//
+type Index struct {
+	register
+	X     Value // array
+	Index Value // integer index
+}
+
+// The Lookup instruction yields element Index of collection X, a map
+// or string.  Index is an integer expression if X is a string or the
+// appropriate key type if X is a map.
+//
+// If CommaOk, the result is a 2-tuple of the value above and a
+// boolean indicating the result of a map membership test for the key.
+// The components of the tuple are accessed using Extract.
+//
+// Pos() returns the ast.IndexExpr.Lbrack, if explicit in the source.
+//
+// Example printed form:
+// 	t2 = t0[t1]
+// 	t5 = t3[t4],ok
+//
+type Lookup struct {
+	register
+	X       Value // string or map
+	Index   Value // numeric or key-typed index
+	CommaOk bool  // return a value,ok pair
+}
+
+// SelectState is a helper for Select.
+// It represents one goal state and its corresponding communication.
+//
+type SelectState struct {
+	Dir       types.ChanDir // direction of case (SendOnly or RecvOnly)
+	Chan      Value         // channel to use (for send or receive)
+	Send      Value         // value to send (for send)
+	Pos       token.Pos     // position of token.ARROW
+	DebugNode ast.Node      // ast.SendStmt or ast.UnaryExpr(<-) [debug mode]
+}
+
+// The Select instruction tests whether (or blocks until) one
+// of the specified sent or received states is entered.
+//
+// Let n be the number of States for which Dir==RECV and T_i (0<=i<n)
+// be the element type of each such state's Chan.
+// Select returns an n+2-tuple
+//    (index int, recvOk bool, r_0 T_0, ... r_n-1 T_n-1)
+// The tuple's components, described below, must be accessed via the
+// Extract instruction.
+//
+// If Blocking, select waits until exactly one state holds, i.e. a
+// channel becomes ready for the designated operation of sending or
+// receiving; select chooses one among the ready states
+// pseudorandomly, performs the send or receive operation, and sets
+// 'index' to the index of the chosen channel.
+//
+// If !Blocking, select doesn't block if no states hold; instead it
+// returns immediately with index equal to -1.
+//
+// If the chosen channel was used for a receive, the r_i component is
+// set to the received value, where i is the index of that state among
+// all n receive states; otherwise r_i has the zero value of type T_i.
+// Note that the receive index i is not the same as the state
+// index index.
+//
+// The second component of the triple, recvOk, is a boolean whose value
+// is true iff the selected operation was a receive and the receive
+// successfully yielded a value.
+//
+// Pos() returns the ast.SelectStmt.Select.
+//
+// Example printed form:
+// 	t3 = select nonblocking [<-t0, t1<-t2]
+// 	t4 = select blocking []
+//
+type Select struct {
+	register
+	States   []*SelectState
+	Blocking bool
+}
+
+// The Range instruction yields an iterator over the domain and range
+// of X, which must be a string or map.
+//
+// Elements are accessed via Next.
+//
+// Type() returns an opaque and degenerate "rangeIter" type.
+//
+// Pos() returns the ast.RangeStmt.For.
+//
+// Example printed form:
+// 	t0 = range "hello":string
+//
+type Range struct {
+	register
+	X Value // string or map
+}
+
+// The Next instruction reads and advances the (map or string)
+// iterator Iter and returns a 3-tuple value (ok, k, v).  If the
+// iterator is not exhausted, ok is true and k and v are the next
+// elements of the domain and range, respectively.  Otherwise ok is
+// false and k and v are undefined.
+//
+// Components of the tuple are accessed using Extract.
+//
+// The IsString field distinguishes iterators over strings from those
+// over maps, as the Type() alone is insufficient: consider
+// map[int]rune.
+//
+// Type() returns a *types.Tuple for the triple (ok, k, v).
+// The types of k and/or v may be types.Invalid.
+//
+// Example printed form:
+// 	t1 = next t0
+//
+type Next struct {
+	register
+	Iter     Value
+	IsString bool // true => string iterator; false => map iterator.
+}
+
+// The TypeAssert instruction tests whether interface value X has type
+// AssertedType.
+//
+// If !CommaOk, on success it returns v, the result of the conversion
+// (defined below); on failure it panics.
+//
+// If CommaOk: on success it returns a pair (v, true) where v is the
+// result of the conversion; on failure it returns (z, false) where z
+// is AssertedType's zero value.  The components of the pair must be
+// accessed using the Extract instruction.
+//
+// If AssertedType is a concrete type, TypeAssert checks whether the
+// dynamic type in interface X is equal to it, and if so, the result
+// of the conversion is a copy of the value in the interface.
+//
+// If AssertedType is an interface, TypeAssert checks whether the
+// dynamic type of the interface is assignable to it, and if so, the
+// result of the conversion is a copy of the interface value X.
+// If AssertedType is a superinterface of X.Type(), the operation will
+// fail iff the operand is nil.  (Contrast with ChangeInterface, which
+// performs no nil-check.)
+//
+// Type() reflects the actual type of the result, possibly a
+// 2-types.Tuple; AssertedType is the asserted type.
+//
+// Pos() returns the ast.CallExpr.Lparen if the instruction arose from
+// an explicit T(e) conversion; the ast.TypeAssertExpr.Lparen if the
+// instruction arose from an explicit e.(T) operation; or the
+// ast.CaseClause.Case if the instruction arose from a case of a
+// type-switch statement.
+//
+// Example printed form:
+// 	t1 = typeassert t0.(int)
+// 	t3 = typeassert,ok t2.(T)
+//
+type TypeAssert struct {
+	register
+	X            Value
+	AssertedType types.Type
+	CommaOk      bool
+}
+
+// The Extract instruction yields component Index of Tuple.
+//
+// This is used to access the results of instructions with multiple
+// return values, such as Call, TypeAssert, Next, UnOp(ARROW) and
+// IndexExpr(Map).
+//
+// Example printed form:
+// 	t1 = extract t0 #1
+//
+type Extract struct {
+	register
+	Tuple Value
+	Index int
+}
+
+// Instructions executed for effect.  They do not yield a value. --------------------
+
+// The Jump instruction transfers control to the sole successor of its
+// owning block.
+//
+// A Jump must be the last instruction of its containing BasicBlock.
+//
+// Pos() returns NoPos.
+//
+// Example printed form:
+// 	jump done
+//
+type Jump struct {
+	anInstruction
+}
+
+// The If instruction transfers control to one of the two successors
+// of its owning block, depending on the boolean Cond: the first if
+// true, the second if false.
+//
+// An If instruction must be the last instruction of its containing
+// BasicBlock.
+//
+// Pos() returns NoPos.
+//
+// Example printed form:
+// 	if t0 goto done else body
+//
+type If struct {
+	anInstruction
+	Cond Value
+}
+
+// The Return instruction returns values and control back to the calling
+// function.
+//
+// len(Results) is always equal to the number of results in the
+// function's signature.
+//
+// If len(Results) > 1, Return returns a tuple value with the specified
+// components which the caller must access using Extract instructions.
+//
+// There is no instruction to return a ready-made tuple like those
+// returned by a "value,ok"-mode TypeAssert, Lookup or UnOp(ARROW) or
+// a tail-call to a function with multiple result parameters.
+//
+// Return must be the last instruction of its containing BasicBlock.
+// Such a block has no successors.
+//
+// Pos() returns the ast.ReturnStmt.Return, if explicit in the source.
+//
+// Example printed form:
+// 	return
+// 	return nil:I, 2:int
+//
+type Return struct {
+	anInstruction
+	Results []Value
+	pos     token.Pos
+}
+
+// The RunDefers instruction pops and invokes the entire stack of
+// procedure calls pushed by Defer instructions in this function.
+//
+// It is legal to encounter multiple 'rundefers' instructions in a
+// single control-flow path through a function; this is useful in
+// the combined init() function, for example.
+//
+// Pos() returns NoPos.
+//
+// Example printed form:
+//	rundefers
+//
+type RunDefers struct {
+	anInstruction
+}
+
+// The Panic instruction initiates a panic with value X.
+//
+// A Panic instruction must be the last instruction of its containing
+// BasicBlock, which must have no successors.
+//
+// NB: 'go panic(x)' and 'defer panic(x)' do not use this instruction;
+// they are treated as calls to a built-in function.
+//
+// Pos() returns the ast.CallExpr.Lparen if this panic was explicit
+// in the source.
+//
+// Example printed form:
+// 	panic t0
+//
+type Panic struct {
+	anInstruction
+	X   Value // an interface{}
+	pos token.Pos
+}
+
+// The Go instruction creates a new goroutine and calls the specified
+// function within it.
+//
+// See CallCommon for generic function call documentation.
+//
+// Pos() returns the ast.GoStmt.Go.
+//
+// Example printed form:
+// 	go println(t0, t1)
+// 	go t3()
+// 	go invoke t5.Println(...t6)
+//
+type Go struct {
+	anInstruction
+	Call CallCommon
+	pos  token.Pos
+}
+
+// The Defer instruction pushes the specified call onto a stack of
+// functions to be called by a RunDefers instruction or by a panic.
+//
+// See CallCommon for generic function call documentation.
+//
+// Pos() returns the ast.DeferStmt.Defer.
+//
+// Example printed form:
+// 	defer println(t0, t1)
+// 	defer t3()
+// 	defer invoke t5.Println(...t6)
+//
+type Defer struct {
+	anInstruction
+	Call CallCommon
+	pos  token.Pos
+}
+
+// The Send instruction sends X on channel Chan.
+//
+// Pos() returns the ast.SendStmt.Arrow, if explicit in the source.
+//
+// Example printed form:
+// 	send t0 <- t1
+//
+type Send struct {
+	anInstruction
+	Chan, X Value
+	pos     token.Pos
+}
+
+// The Store instruction stores Val at address Addr.
+// Stores can be of arbitrary types.
+//
+// Pos() returns the position of the source-level construct most closely
+// associated with the memory store operation.
+// Since implicit memory stores are numerous and varied and depend upon
+// implementation choices, the details are not specified.
+//
+// Example printed form:
+// 	*x = y
+//
+type Store struct {
+	anInstruction
+	Addr Value
+	Val  Value
+	pos  token.Pos
+}
+
+// The MapUpdate instruction updates the association of Map[Key] to
+// Value.
+//
+// Pos() returns the ast.KeyValueExpr.Colon or ast.IndexExpr.Lbrack,
+// if explicit in the source.
+//
+// Example printed form:
+//	t0[t1] = t2
+//
+type MapUpdate struct {
+	anInstruction
+	Map   Value
+	Key   Value
+	Value Value
+	pos   token.Pos
+}
+
+// A DebugRef instruction maps a source-level expression Expr to the
+// SSA value X that represents the value (!IsAddr) or address (IsAddr)
+// of that expression.
+//
+// DebugRef is a pseudo-instruction: it has no dynamic effect.
+//
+// Pos() returns Expr.Pos(), the start position of the source-level
+// expression.  This is not the same as the "designated" token as
+// documented at Value.Pos(). e.g. CallExpr.Pos() does not return the
+// position of the ("designated") Lparen token.
+//
+// If Expr is an *ast.Ident denoting a var or func, Object() returns
+// the object; though this information can be obtained from the type
+// checker, including it here greatly facilitates debugging.
+// For non-Ident expressions, Object() returns nil.
+//
+// DebugRefs are generated only for functions built with debugging
+// enabled; see Package.SetDebugMode() and the GlobalDebug builder
+// mode flag.
+//
+// DebugRefs are not emitted for ast.Idents referring to constants or
+// predeclared identifiers, since they are trivial and numerous.
+// Nor are they emitted for ast.ParenExprs.
+//
+// (By representing these as instructions, rather than out-of-band,
+// consistency is maintained during transformation passes by the
+// ordinary SSA renaming machinery.)
+//
+// Example printed form:
+//      ; *ast.CallExpr @ 102:9 is t5
+//      ; var x float64 @ 109:72 is x
+//      ; address of *ast.CompositeLit @ 216:10 is t0
+//
+type DebugRef struct {
+	anInstruction
+	Expr   ast.Expr     // the referring expression (never *ast.ParenExpr)
+	object types.Object // the identity of the source var/func
+	IsAddr bool         // Expr is addressable and X is the address it denotes
+	X      Value        // the value or address of Expr
+}
+
+// Embeddable mix-ins and helpers for common parts of other structs. -----------
+
+// register is a mix-in embedded by all SSA values that are also
+// instructions, i.e. virtual registers, and provides a uniform
+// implementation of most of the Value interface: Value.Name() is a
+// numbered register (e.g. "t0"); the other methods are field accessors.
+//
+// Temporary names are automatically assigned to each register on
+// completion of building a function in SSA form.
+//
+// Clients must not assume that the 'id' value (and the Name() derived
+// from it) is unique within a function.  As always in this API,
+// semantics are determined only by identity; names exist only to
+// facilitate debugging.
+//
+type register struct {
+	anInstruction
+	num       int        // "name" of virtual register, e.g. "t0".  Not guaranteed unique.
+	typ       types.Type // type of virtual register
+	pos       token.Pos  // position of source expression, or NoPos
+	referrers []Instruction
+}
+
+// anInstruction is a mix-in embedded by all Instructions.
+// It provides the implementations of the Block and setBlock methods.
+type anInstruction struct {
+	block *BasicBlock // the basic block of this instruction
+}
+
+// CallCommon is contained by Go, Defer and Call to hold the
+// common parts of a function or method call.
+//
+// Each CallCommon exists in one of two modes, function call and
+// interface method invocation, or "call" and "invoke" for short.
+//
+// 1. "call" mode: when Method is nil (!IsInvoke), a CallCommon
+// represents an ordinary function call of the value in Value,
+// which may be a *Builtin, a *Function or any other value of kind
+// 'func'.
+//
+// Value may be one of:
+//    (a) a *Function, indicating a statically dispatched call
+//        to a package-level function, an anonymous function, or
+//        a method of a named type.
+//    (b) a *MakeClosure, indicating an immediately applied
+//        function literal with free variables.
+//    (c) a *Builtin, indicating a statically dispatched call
+//        to a built-in function.
+//    (d) any other value, indicating a dynamically dispatched
+//        function call.
+// StaticCallee returns the identity of the callee in cases
+// (a) and (b), nil otherwise.
+//
+// Args contains the arguments to the call.  If Value is a method,
+// Args[0] contains the receiver parameter.
+//
+// Example printed form:
+// 	t2 = println(t0, t1)
+// 	go t3()
+//	defer t5(...t6)
+//
+// 2. "invoke" mode: when Method is non-nil (IsInvoke), a CallCommon
+// represents a dynamically dispatched call to an interface method.
+// In this mode, Value is the interface value and Method is the
+// interface's abstract method.  Note: an abstract method may be
+// shared by multiple interfaces due to embedding; Value.Type()
+// provides the specific interface used for this call.
+//
+// Value is implicitly supplied to the concrete method implementation
+// as the receiver parameter; in other words, Args[0] holds not the
+// receiver but the first true argument.
+//
+// Example printed form:
+// 	t1 = invoke t0.String()
+// 	go invoke t3.Run(t2)
+// 	defer invoke t4.Handle(...t5)
+//
+// For all calls to variadic functions (Signature().Variadic()),
+// the last element of Args is a slice.
+//
+type CallCommon struct {
+	Value  Value       // receiver (invoke mode) or func value (call mode)
+	Method *types.Func // abstract method (invoke mode)
+	Args   []Value     // actual parameters (in static method call, includes receiver)
+	pos    token.Pos   // position of CallExpr.Lparen, iff explicit in source
+}
+
+// IsInvoke returns true if this call has "invoke" (not "call") mode.
+func (c *CallCommon) IsInvoke() bool {
+	return c.Method != nil
+}
+
+func (c *CallCommon) Pos() token.Pos { return c.pos }
+
+// Signature returns the signature of the called function.
+//
+// For an "invoke"-mode call, the signature of the interface method is
+// returned.
+//
+// In either "call" or "invoke" mode, if the callee is a method, its
+// receiver is represented by sig.Recv, not sig.Params().At(0).
+//
+func (c *CallCommon) Signature() *types.Signature {
+	if c.Method != nil {
+		return c.Method.Type().(*types.Signature)
+	}
+	return c.Value.Type().Underlying().(*types.Signature)
+}
+
+// StaticCallee returns the callee if this is a trivially static
+// "call"-mode call to a function.
+func (c *CallCommon) StaticCallee() *Function {
+	switch fn := c.Value.(type) {
+	case *Function:
+		return fn
+	case *MakeClosure:
+		return fn.Fn.(*Function)
+	}
+	return nil
+}
+
+// Description returns a description of the mode of this call suitable
+// for a user interface, e.g., "static method call".
+func (c *CallCommon) Description() string {
+	switch fn := c.Value.(type) {
+	case *Builtin:
+		return "built-in function call"
+	case *MakeClosure:
+		return "static function closure call"
+	case *Function:
+		if fn.Signature.Recv() != nil {
+			return "static method call"
+		}
+		return "static function call"
+	}
+	if c.IsInvoke() {
+		return "dynamic method call" // ("invoke" mode)
+	}
+	return "dynamic function call"
+}
+
+// The CallInstruction interface, implemented by *Go, *Defer and *Call,
+// exposes the common parts of function-calling instructions,
+// yet provides a way back to the Value defined by *Call alone.
+//
+type CallInstruction interface {
+	Instruction
+	Common() *CallCommon // returns the common parts of the call
+	Value() *Call        // returns the result value of the call (*Call) or nil (*Go, *Defer)
+}
+
+func (s *Call) Common() *CallCommon  { return &s.Call }
+func (s *Defer) Common() *CallCommon { return &s.Call }
+func (s *Go) Common() *CallCommon    { return &s.Call }
+
+func (s *Call) Value() *Call  { return s }
+func (s *Defer) Value() *Call { return nil }
+func (s *Go) Value() *Call    { return nil }
+
+func (v *Builtin) Type() types.Type        { return v.sig }
+func (v *Builtin) Name() string            { return v.name }
+func (*Builtin) Referrers() *[]Instruction { return nil }
+func (v *Builtin) Pos() token.Pos          { return token.NoPos }
+func (v *Builtin) Object() types.Object    { return types.Universe.Lookup(v.name) }
+func (v *Builtin) Parent() *Function       { return nil }
+
+func (v *FreeVar) Type() types.Type          { return v.typ }
+func (v *FreeVar) Name() string              { return v.name }
+func (v *FreeVar) Referrers() *[]Instruction { return &v.referrers }
+func (v *FreeVar) Pos() token.Pos            { return v.pos }
+func (v *FreeVar) Parent() *Function         { return v.parent }
+
+func (v *Global) Type() types.Type                     { return v.typ }
+func (v *Global) Name() string                         { return v.name }
+func (v *Global) Parent() *Function                    { return nil }
+func (v *Global) Pos() token.Pos                       { return v.pos }
+func (v *Global) Referrers() *[]Instruction            { return nil }
+func (v *Global) Token() token.Token                   { return token.VAR }
+func (v *Global) Object() types.Object                 { return v.object }
+func (v *Global) String() string                       { return v.RelString(nil) }
+func (v *Global) Package() *Package                    { return v.Pkg }
+func (v *Global) RelString(from *types.Package) string { return relString(v, from) }
+
+func (v *Function) Name() string         { return v.name }
+func (v *Function) Type() types.Type     { return v.Signature }
+func (v *Function) Pos() token.Pos       { return v.pos }
+func (v *Function) Token() token.Token   { return token.FUNC }
+func (v *Function) Object() types.Object { return v.object }
+func (v *Function) String() string       { return v.RelString(nil) }
+func (v *Function) Package() *Package    { return v.Pkg }
+func (v *Function) Parent() *Function    { return v.parent }
+func (v *Function) Referrers() *[]Instruction {
+	if v.parent != nil {
+		return &v.referrers
+	}
+	return nil
+}
+
+func (v *Parameter) Type() types.Type          { return v.typ }
+func (v *Parameter) Name() string              { return v.name }
+func (v *Parameter) Object() types.Object      { return v.object }
+func (v *Parameter) Referrers() *[]Instruction { return &v.referrers }
+func (v *Parameter) Pos() token.Pos            { return v.pos }
+func (v *Parameter) Parent() *Function         { return v.parent }
+
+func (v *Alloc) Type() types.Type          { return v.typ }
+func (v *Alloc) Referrers() *[]Instruction { return &v.referrers }
+func (v *Alloc) Pos() token.Pos            { return v.pos }
+
+func (v *register) Type() types.Type          { return v.typ }
+func (v *register) setType(typ types.Type)    { v.typ = typ }
+func (v *register) Name() string              { return fmt.Sprintf("t%d", v.num) }
+func (v *register) setNum(num int)            { v.num = num }
+func (v *register) Referrers() *[]Instruction { return &v.referrers }
+func (v *register) Pos() token.Pos            { return v.pos }
+func (v *register) setPos(pos token.Pos)      { v.pos = pos }
+
+func (v *anInstruction) Parent() *Function          { return v.block.parent }
+func (v *anInstruction) Block() *BasicBlock         { return v.block }
+func (v *anInstruction) setBlock(block *BasicBlock) { v.block = block }
+func (v *anInstruction) Referrers() *[]Instruction  { return nil }
+
+func (t *Type) Name() string                         { return t.object.Name() }
+func (t *Type) Pos() token.Pos                       { return t.object.Pos() }
+func (t *Type) Type() types.Type                     { return t.object.Type() }
+func (t *Type) Token() token.Token                   { return token.TYPE }
+func (t *Type) Object() types.Object                 { return t.object }
+func (t *Type) String() string                       { return t.RelString(nil) }
+func (t *Type) Package() *Package                    { return t.pkg }
+func (t *Type) RelString(from *types.Package) string { return relString(t, from) }
+
+func (c *NamedConst) Name() string                         { return c.object.Name() }
+func (c *NamedConst) Pos() token.Pos                       { return c.object.Pos() }
+func (c *NamedConst) String() string                       { return c.RelString(nil) }
+func (c *NamedConst) Type() types.Type                     { return c.object.Type() }
+func (c *NamedConst) Token() token.Token                   { return token.CONST }
+func (c *NamedConst) Object() types.Object                 { return c.object }
+func (c *NamedConst) Package() *Package                    { return c.pkg }
+func (c *NamedConst) RelString(from *types.Package) string { return relString(c, from) }
+
+// Func returns the package-level function of the specified name,
+// or nil if not found.
+//
+func (p *Package) Func(name string) (f *Function) {
+	f, _ = p.Members[name].(*Function)
+	return
+}
+
+// Var returns the package-level variable of the specified name,
+// or nil if not found.
+//
+func (p *Package) Var(name string) (g *Global) {
+	g, _ = p.Members[name].(*Global)
+	return
+}
+
+// Const returns the package-level constant of the specified name,
+// or nil if not found.
+//
+func (p *Package) Const(name string) (c *NamedConst) {
+	c, _ = p.Members[name].(*NamedConst)
+	return
+}
+
+// Type returns the package-level type of the specified name,
+// or nil if not found.
+//
+func (p *Package) Type(name string) (t *Type) {
+	t, _ = p.Members[name].(*Type)
+	return
+}
+
+func (v *Call) Pos() token.Pos      { return v.Call.pos }
+func (s *Defer) Pos() token.Pos     { return s.pos }
+func (s *Go) Pos() token.Pos        { return s.pos }
+func (s *MapUpdate) Pos() token.Pos { return s.pos }
+func (s *Panic) Pos() token.Pos     { return s.pos }
+func (s *Return) Pos() token.Pos    { return s.pos }
+func (s *Send) Pos() token.Pos      { return s.pos }
+func (s *Store) Pos() token.Pos     { return s.pos }
+func (s *If) Pos() token.Pos        { return token.NoPos }
+func (s *Jump) Pos() token.Pos      { return token.NoPos }
+func (s *RunDefers) Pos() token.Pos { return token.NoPos }
+func (s *DebugRef) Pos() token.Pos  { return s.Expr.Pos() }
+
+// Operands.
+
+func (v *Alloc) Operands(rands []*Value) []*Value {
+	return rands
+}
+
+func (v *BinOp) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X, &v.Y)
+}
+
+func (c *CallCommon) Operands(rands []*Value) []*Value {
+	rands = append(rands, &c.Value)
+	for i := range c.Args {
+		rands = append(rands, &c.Args[i])
+	}
+	return rands
+}
+
+func (s *Go) Operands(rands []*Value) []*Value {
+	return s.Call.Operands(rands)
+}
+
+func (s *Call) Operands(rands []*Value) []*Value {
+	return s.Call.Operands(rands)
+}
+
+func (s *Defer) Operands(rands []*Value) []*Value {
+	return s.Call.Operands(rands)
+}
+
+func (v *ChangeInterface) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (v *ChangeType) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (v *Convert) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (s *DebugRef) Operands(rands []*Value) []*Value {
+	return append(rands, &s.X)
+}
+
+func (v *Extract) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Tuple)
+}
+
+func (v *Field) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (v *FieldAddr) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (s *If) Operands(rands []*Value) []*Value {
+	return append(rands, &s.Cond)
+}
+
+func (v *Index) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X, &v.Index)
+}
+
+func (v *IndexAddr) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X, &v.Index)
+}
+
+func (*Jump) Operands(rands []*Value) []*Value {
+	return rands
+}
+
+func (v *Lookup) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X, &v.Index)
+}
+
+func (v *MakeChan) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Size)
+}
+
+func (v *MakeClosure) Operands(rands []*Value) []*Value {
+	rands = append(rands, &v.Fn)
+	for i := range v.Bindings {
+		rands = append(rands, &v.Bindings[i])
+	}
+	return rands
+}
+
+func (v *MakeInterface) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (v *MakeMap) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Reserve)
+}
+
+func (v *MakeSlice) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Len, &v.Cap)
+}
+
+func (v *MapUpdate) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Map, &v.Key, &v.Value)
+}
+
+func (v *Next) Operands(rands []*Value) []*Value {
+	return append(rands, &v.Iter)
+}
+
+func (s *Panic) Operands(rands []*Value) []*Value {
+	return append(rands, &s.X)
+}
+
+func (v *Phi) Operands(rands []*Value) []*Value {
+	for i := range v.Edges {
+		rands = append(rands, &v.Edges[i])
+	}
+	return rands
+}
+
+func (v *Range) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (s *Return) Operands(rands []*Value) []*Value {
+	for i := range s.Results {
+		rands = append(rands, &s.Results[i])
+	}
+	return rands
+}
+
+func (*RunDefers) Operands(rands []*Value) []*Value {
+	return rands
+}
+
+func (v *Select) Operands(rands []*Value) []*Value {
+	for i := range v.States {
+		rands = append(rands, &v.States[i].Chan, &v.States[i].Send)
+	}
+	return rands
+}
+
+func (s *Send) Operands(rands []*Value) []*Value {
+	return append(rands, &s.Chan, &s.X)
+}
+
+func (v *Slice) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X, &v.Low, &v.High, &v.Max)
+}
+
+func (s *Store) Operands(rands []*Value) []*Value {
+	return append(rands, &s.Addr, &s.Val)
+}
+
+func (v *TypeAssert) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+func (v *UnOp) Operands(rands []*Value) []*Value {
+	return append(rands, &v.X)
+}
+
+// Non-Instruction Values:
+func (v *Builtin) Operands(rands []*Value) []*Value   { return rands }
+func (v *FreeVar) Operands(rands []*Value) []*Value   { return rands }
+func (v *Const) Operands(rands []*Value) []*Value     { return rands }
+func (v *Function) Operands(rands []*Value) []*Value  { return rands }
+func (v *Global) Operands(rands []*Value) []*Value    { return rands }
+func (v *Parameter) Operands(rands []*Value) []*Value { return rands }
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/load.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/load.go
new file mode 100644
index 00000000..30b8053c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/load.go
@@ -0,0 +1,95 @@
+// 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.
+
+package ssautil
+
+// This file defines utility functions for constructing programs in SSA form.
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+)
+
+// CreateProgram returns a new program in SSA form, given a program
+// loaded from source.  An SSA package is created for each transitively
+// error-free package of lprog.
+//
+// Code for bodies of functions is not built until Build is called
+// on the result.
+//
+// mode controls diagnostics and checking during SSA construction.
+//
+func CreateProgram(lprog *loader.Program, mode ssa.BuilderMode) *ssa.Program {
+	prog := ssa.NewProgram(lprog.Fset, mode)
+
+	for _, info := range lprog.AllPackages {
+		if info.TransitivelyErrorFree {
+			prog.CreatePackage(info.Pkg, info.Files, &info.Info, info.Importable)
+		}
+	}
+
+	return prog
+}
+
+// BuildPackage builds an SSA program with IR for a single package.
+//
+// It populates pkg by type-checking the specified file ASTs.  All
+// dependencies are loaded using the importer specified by tc, which
+// typically loads compiler export data; SSA code cannot be built for
+// those packages.  BuildPackage then constructs an ssa.Program with all
+// dependency packages created, and builds and returns the SSA package
+// corresponding to pkg.
+//
+// The caller must have set pkg.Path() to the import path.
+//
+// The operation fails if there were any type-checking or import errors.
+//
+// See ../ssa/example_test.go for an example.
+//
+func BuildPackage(tc *types.Config, fset *token.FileSet, pkg *types.Package, files []*ast.File, mode ssa.BuilderMode) (*ssa.Package, *types.Info, error) {
+	if fset == nil {
+		panic("no token.FileSet")
+	}
+	if pkg.Path() == "" {
+		panic("package has no import path")
+	}
+
+	info := &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Scopes:     make(map[ast.Node]*types.Scope),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+	}
+	if err := types.NewChecker(tc, fset, pkg, info).Files(files); err != nil {
+		return nil, nil, err
+	}
+
+	prog := ssa.NewProgram(fset, mode)
+
+	// Create SSA packages for all imports.
+	// Order is not significant.
+	created := make(map[*types.Package]bool)
+	var createAll func(pkgs []*types.Package)
+	createAll = func(pkgs []*types.Package) {
+		for _, p := range pkgs {
+			if !created[p] {
+				created[p] = true
+				prog.CreatePackage(p, nil, nil, true)
+				createAll(p.Imports())
+			}
+		}
+	}
+	createAll(pkg.Imports())
+
+	// Create and build the primary package.
+	ssapkg := prog.CreatePackage(pkg, files, info, false)
+	ssapkg.Build()
+	return ssapkg, info, nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go
new file mode 100644
index 00000000..db03bf55
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/switch.go
@@ -0,0 +1,234 @@
+// 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 ssautil
+
+// This file implements discovery of switch and type-switch constructs
+// from low-level control flow.
+//
+// Many techniques exist for compiling a high-level switch with
+// constant cases to efficient machine code.  The optimal choice will
+// depend on the data type, the specific case values, the code in the
+// body of each case, and the hardware.
+// Some examples:
+// - a lookup table (for a switch that maps constants to constants)
+// - a computed goto
+// - a binary tree
+// - a perfect hash
+// - a two-level switch (to partition constant strings by their first byte).
+
+import (
+	"bytes"
+	"fmt"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/ssa"
+)
+
+// A ConstCase represents a single constant comparison.
+// It is part of a Switch.
+type ConstCase struct {
+	Block *ssa.BasicBlock // block performing the comparison
+	Body  *ssa.BasicBlock // body of the case
+	Value *ssa.Const      // case comparand
+}
+
+// A TypeCase represents a single type assertion.
+// It is part of a Switch.
+type TypeCase struct {
+	Block   *ssa.BasicBlock // block performing the type assert
+	Body    *ssa.BasicBlock // body of the case
+	Type    types.Type      // case type
+	Binding ssa.Value       // value bound by this case
+}
+
+// A Switch is a logical high-level control flow operation
+// (a multiway branch) discovered by analysis of a CFG containing
+// only if/else chains.  It is not part of the ssa.Instruction set.
+//
+// One of ConstCases and TypeCases has length >= 2;
+// the other is nil.
+//
+// In a value switch, the list of cases may contain duplicate constants.
+// A type switch may contain duplicate types, or types assignable
+// to an interface type also in the list.
+// TODO(adonovan): eliminate such duplicates.
+//
+type Switch struct {
+	Start      *ssa.BasicBlock // block containing start of if/else chain
+	X          ssa.Value       // the switch operand
+	ConstCases []ConstCase     // ordered list of constant comparisons
+	TypeCases  []TypeCase      // ordered list of type assertions
+	Default    *ssa.BasicBlock // successor if all comparisons fail
+}
+
+func (sw *Switch) String() string {
+	// We represent each block by the String() of its
+	// first Instruction, e.g. "print(42:int)".
+	var buf bytes.Buffer
+	if sw.ConstCases != nil {
+		fmt.Fprintf(&buf, "switch %s {\n", sw.X.Name())
+		for _, c := range sw.ConstCases {
+			fmt.Fprintf(&buf, "case %s: %s\n", c.Value, c.Body.Instrs[0])
+		}
+	} else {
+		fmt.Fprintf(&buf, "switch %s.(type) {\n", sw.X.Name())
+		for _, c := range sw.TypeCases {
+			fmt.Fprintf(&buf, "case %s %s: %s\n",
+				c.Binding.Name(), c.Type, c.Body.Instrs[0])
+		}
+	}
+	if sw.Default != nil {
+		fmt.Fprintf(&buf, "default: %s\n", sw.Default.Instrs[0])
+	}
+	fmt.Fprintf(&buf, "}")
+	return buf.String()
+}
+
+// Switches examines the control-flow graph of fn and returns the
+// set of inferred value and type switches.  A value switch tests an
+// ssa.Value for equality against two or more compile-time constant
+// values.  Switches involving link-time constants (addresses) are
+// ignored.  A type switch type-asserts an ssa.Value against two or
+// more types.
+//
+// The switches are returned in dominance order.
+//
+// The resulting switches do not necessarily correspond to uses of the
+// 'switch' keyword in the source: for example, a single source-level
+// switch statement with non-constant cases may result in zero, one or
+// many Switches, one per plural sequence of constant cases.
+// Switches may even be inferred from if/else- or goto-based control flow.
+// (In general, the control flow constructs of the source program
+// cannot be faithfully reproduced from the SSA representation.)
+//
+func Switches(fn *ssa.Function) []Switch {
+	// Traverse the CFG in dominance order, so we don't
+	// enter an if/else-chain in the middle.
+	var switches []Switch
+	seen := make(map[*ssa.BasicBlock]bool) // TODO(adonovan): opt: use ssa.blockSet
+	for _, b := range fn.DomPreorder() {
+		if x, k := isComparisonBlock(b); x != nil {
+			// Block b starts a switch.
+			sw := Switch{Start: b, X: x}
+			valueSwitch(&sw, k, seen)
+			if len(sw.ConstCases) > 1 {
+				switches = append(switches, sw)
+			}
+		}
+
+		if y, x, T := isTypeAssertBlock(b); y != nil {
+			// Block b starts a type switch.
+			sw := Switch{Start: b, X: x}
+			typeSwitch(&sw, y, T, seen)
+			if len(sw.TypeCases) > 1 {
+				switches = append(switches, sw)
+			}
+		}
+	}
+	return switches
+}
+
+func valueSwitch(sw *Switch, k *ssa.Const, seen map[*ssa.BasicBlock]bool) {
+	b := sw.Start
+	x := sw.X
+	for x == sw.X {
+		if seen[b] {
+			break
+		}
+		seen[b] = true
+
+		sw.ConstCases = append(sw.ConstCases, ConstCase{
+			Block: b,
+			Body:  b.Succs[0],
+			Value: k,
+		})
+		b = b.Succs[1]
+		if len(b.Instrs) > 2 {
+			// Block b contains not just 'if x == k',
+			// so it may have side effects that
+			// make it unsafe to elide.
+			break
+		}
+		if len(b.Preds) != 1 {
+			// Block b has multiple predecessors,
+			// so it cannot be treated as a case.
+			break
+		}
+		x, k = isComparisonBlock(b)
+	}
+	sw.Default = b
+}
+
+func typeSwitch(sw *Switch, y ssa.Value, T types.Type, seen map[*ssa.BasicBlock]bool) {
+	b := sw.Start
+	x := sw.X
+	for x == sw.X {
+		if seen[b] {
+			break
+		}
+		seen[b] = true
+
+		sw.TypeCases = append(sw.TypeCases, TypeCase{
+			Block:   b,
+			Body:    b.Succs[0],
+			Type:    T,
+			Binding: y,
+		})
+		b = b.Succs[1]
+		if len(b.Instrs) > 4 {
+			// Block b contains not just
+			//  {TypeAssert; Extract #0; Extract #1; If}
+			// so it may have side effects that
+			// make it unsafe to elide.
+			break
+		}
+		if len(b.Preds) != 1 {
+			// Block b has multiple predecessors,
+			// so it cannot be treated as a case.
+			break
+		}
+		y, x, T = isTypeAssertBlock(b)
+	}
+	sw.Default = b
+}
+
+// isComparisonBlock returns the operands (v, k) if a block ends with
+// a comparison v==k, where k is a compile-time constant.
+//
+func isComparisonBlock(b *ssa.BasicBlock) (v ssa.Value, k *ssa.Const) {
+	if n := len(b.Instrs); n >= 2 {
+		if i, ok := b.Instrs[n-1].(*ssa.If); ok {
+			if binop, ok := i.Cond.(*ssa.BinOp); ok && binop.Block() == b && binop.Op == token.EQL {
+				if k, ok := binop.Y.(*ssa.Const); ok {
+					return binop.X, k
+				}
+				if k, ok := binop.X.(*ssa.Const); ok {
+					return binop.Y, k
+				}
+			}
+		}
+	}
+	return
+}
+
+// isTypeAssertBlock returns the operands (y, x, T) if a block ends with
+// a type assertion "if y, ok := x.(T); ok {".
+//
+func isTypeAssertBlock(b *ssa.BasicBlock) (y, x ssa.Value, T types.Type) {
+	if n := len(b.Instrs); n >= 4 {
+		if i, ok := b.Instrs[n-1].(*ssa.If); ok {
+			if ext1, ok := i.Cond.(*ssa.Extract); ok && ext1.Block() == b && ext1.Index == 1 {
+				if ta, ok := ext1.Tuple.(*ssa.TypeAssert); ok && ta.Block() == b {
+					// hack: relies upon instruction ordering.
+					if ext0, ok := b.Instrs[n-3].(*ssa.Extract); ok {
+						return ext0, ta.X, ta.AssertedType
+					}
+				}
+			}
+		}
+	}
+	return
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go
new file mode 100644
index 00000000..3424e8a3
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/ssautil/visit.go
@@ -0,0 +1,79 @@
+// 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 ssautil // import "golang.org/x/tools/go/ssa/ssautil"
+
+import "golang.org/x/tools/go/ssa"
+
+// This file defines utilities for visiting the SSA representation of
+// a Program.
+//
+// TODO(adonovan): test coverage.
+
+// AllFunctions finds and returns the set of functions potentially
+// needed by program prog, as determined by a simple linker-style
+// reachability algorithm starting from the members and method-sets of
+// each package.  The result may include anonymous functions and
+// synthetic wrappers.
+//
+// Precondition: all packages are built.
+//
+func AllFunctions(prog *ssa.Program) map[*ssa.Function]bool {
+	visit := visitor{
+		prog: prog,
+		seen: make(map[*ssa.Function]bool),
+	}
+	visit.program()
+	return visit.seen
+}
+
+type visitor struct {
+	prog *ssa.Program
+	seen map[*ssa.Function]bool
+}
+
+func (visit *visitor) program() {
+	for _, pkg := range visit.prog.AllPackages() {
+		for _, mem := range pkg.Members {
+			if fn, ok := mem.(*ssa.Function); ok {
+				visit.function(fn)
+			}
+		}
+	}
+	for _, T := range visit.prog.RuntimeTypes() {
+		mset := visit.prog.MethodSets.MethodSet(T)
+		for i, n := 0, mset.Len(); i < n; i++ {
+			visit.function(visit.prog.MethodValue(mset.At(i)))
+		}
+	}
+}
+
+func (visit *visitor) function(fn *ssa.Function) {
+	if !visit.seen[fn] {
+		visit.seen[fn] = true
+		var buf [10]*ssa.Value // avoid alloc in common case
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				for _, op := range instr.Operands(buf[:0]) {
+					if fn, ok := (*op).(*ssa.Function); ok {
+						visit.function(fn)
+					}
+				}
+			}
+		}
+	}
+}
+
+// MainPackages returns the subset of the specified packages
+// named "main" that define a main function.
+// The result may include synthetic "testmain" packages.
+func MainPackages(pkgs []*ssa.Package) []*ssa.Package {
+	var mains []*ssa.Package
+	for _, pkg := range pkgs {
+		if pkg.Pkg.Name() == "main" && pkg.Func("main") != nil {
+			mains = append(mains, pkg)
+		}
+	}
+	return mains
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/testmain.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/testmain.go
new file mode 100644
index 00000000..ea232ada
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/testmain.go
@@ -0,0 +1,267 @@
+// 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 ssa
+
+// CreateTestMainPackage synthesizes a main package that runs all the
+// tests of the supplied packages.
+// It is closely coupled to $GOROOT/src/cmd/go/test.go and $GOROOT/src/testing.
+//
+// TODO(adonovan): this file no longer needs to live in the ssa package.
+// Move it to ssautil.
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/types"
+	"log"
+	"os"
+	"strings"
+	"text/template"
+)
+
+// FindTests returns the Test, Benchmark, and Example functions
+// (as defined by "go test") defined in the specified package,
+// and its TestMain function, if any.
+func FindTests(pkg *Package) (tests, benchmarks, examples []*Function, main *Function) {
+	prog := pkg.Prog
+
+	// The first two of these may be nil: if the program doesn't import "testing",
+	// it can't contain any tests, but it may yet contain Examples.
+	var testSig *types.Signature                              // func(*testing.T)
+	var benchmarkSig *types.Signature                         // func(*testing.B)
+	var exampleSig = types.NewSignature(nil, nil, nil, false) // func()
+
+	// Obtain the types from the parameters of testing.MainStart.
+	if testingPkg := prog.ImportedPackage("testing"); testingPkg != nil {
+		mainStart := testingPkg.Func("MainStart")
+		params := mainStart.Signature.Params()
+		testSig = funcField(params.At(1).Type())
+		benchmarkSig = funcField(params.At(2).Type())
+
+		// Does the package define this function?
+		//   func TestMain(*testing.M)
+		if f := pkg.Func("TestMain"); f != nil {
+			sig := f.Type().(*types.Signature)
+			starM := mainStart.Signature.Results().At(0).Type() // *testing.M
+			if sig.Results().Len() == 0 &&
+				sig.Params().Len() == 1 &&
+				types.Identical(sig.Params().At(0).Type(), starM) {
+				main = f
+			}
+		}
+	}
+
+	// TODO(adonovan): use a stable order, e.g. lexical.
+	for _, mem := range pkg.Members {
+		if f, ok := mem.(*Function); ok &&
+			ast.IsExported(f.Name()) &&
+			strings.HasSuffix(prog.Fset.Position(f.Pos()).Filename, "_test.go") {
+
+			switch {
+			case testSig != nil && isTestSig(f, "Test", testSig):
+				tests = append(tests, f)
+			case benchmarkSig != nil && isTestSig(f, "Benchmark", benchmarkSig):
+				benchmarks = append(benchmarks, f)
+			case isTestSig(f, "Example", exampleSig):
+				examples = append(examples, f)
+			default:
+				continue
+			}
+		}
+	}
+	return
+}
+
+// Like isTest, but checks the signature too.
+func isTestSig(f *Function, prefix string, sig *types.Signature) bool {
+	return isTest(f.Name(), prefix) && types.Identical(f.Signature, sig)
+}
+
+// Given the type of one of the three slice parameters of testing.Main,
+// returns the function type.
+func funcField(slice types.Type) *types.Signature {
+	return slice.(*types.Slice).Elem().Underlying().(*types.Struct).Field(1).Type().(*types.Signature)
+}
+
+// isTest tells whether name looks like a test (or benchmark, according to prefix).
+// It is a Test (say) if there is a character after Test that is not a lower-case letter.
+// We don't want TesticularCancer.
+// Plundered from $GOROOT/src/cmd/go/test.go
+func isTest(name, prefix string) bool {
+	if !strings.HasPrefix(name, prefix) {
+		return false
+	}
+	if len(name) == len(prefix) { // "Test" is ok
+		return true
+	}
+	return ast.IsExported(name[len(prefix):])
+}
+
+// CreateTestMainPackage creates and returns a synthetic "testmain"
+// package for the specified package if it defines tests, benchmarks or
+// executable examples, or nil otherwise.  The new package is named
+// "main" and provides a function named "main" that runs the tests,
+// similar to the one that would be created by the 'go test' tool.
+//
+// Subsequent calls to prog.AllPackages include the new package.
+// The package pkg must belong to the program prog.
+func (prog *Program) CreateTestMainPackage(pkg *Package) *Package {
+	if pkg.Prog != prog {
+		log.Fatal("Package does not belong to Program")
+	}
+
+	// Template data
+	var data struct {
+		Pkg                         *Package
+		Tests, Benchmarks, Examples []*Function
+		Main                        *Function
+		Go18                        bool
+	}
+	data.Pkg = pkg
+
+	// Enumerate tests.
+	data.Tests, data.Benchmarks, data.Examples, data.Main = FindTests(pkg)
+	if data.Main == nil &&
+		data.Tests == nil && data.Benchmarks == nil && data.Examples == nil {
+		return nil
+	}
+
+	// Synthesize source for testmain package.
+	path := pkg.Pkg.Path() + "$testmain"
+	tmpl := testmainTmpl
+	if testingPkg := prog.ImportedPackage("testing"); testingPkg != nil {
+		// In Go 1.8, testing.MainStart's first argument is an interface, not a func.
+		data.Go18 = types.IsInterface(testingPkg.Func("MainStart").Signature.Params().At(0).Type())
+	} else {
+		// The program does not import "testing", but FindTests
+		// returned non-nil, which must mean there were Examples
+		// but no Test, Benchmark, or TestMain functions.
+
+		// We'll simply call them from testmain.main; this will
+		// ensure they don't panic, but will not check any
+		// "Output:" comments.
+		// (We should not execute an Example that has no
+		// "Output:" comment, but it's impossible to tell here.)
+		tmpl = examplesOnlyTmpl
+	}
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		log.Fatalf("internal error expanding template for %s: %v", path, err)
+	}
+	if false { // debugging
+		fmt.Fprintln(os.Stderr, buf.String())
+	}
+
+	// Parse and type-check the testmain package.
+	f, err := parser.ParseFile(prog.Fset, path+".go", &buf, parser.Mode(0))
+	if err != nil {
+		log.Fatalf("internal error parsing %s: %v", path, err)
+	}
+	conf := types.Config{
+		DisableUnusedImportCheck: true,
+		Importer:                 importer{pkg},
+	}
+	files := []*ast.File{f}
+	info := &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Scopes:     make(map[ast.Node]*types.Scope),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+	}
+	testmainPkg, err := conf.Check(path, prog.Fset, files, info)
+	if err != nil {
+		log.Fatalf("internal error type-checking %s: %v", path, err)
+	}
+
+	// Create and build SSA code.
+	testmain := prog.CreatePackage(testmainPkg, files, info, false)
+	testmain.SetDebugMode(false)
+	testmain.Build()
+	testmain.Func("main").Synthetic = "test main function"
+	testmain.Func("init").Synthetic = "package initializer"
+	return testmain
+}
+
+// An implementation of types.Importer for an already loaded SSA program.
+type importer struct {
+	pkg *Package // package under test; may be non-importable
+}
+
+func (imp importer) Import(path string) (*types.Package, error) {
+	if p := imp.pkg.Prog.ImportedPackage(path); p != nil {
+		return p.Pkg, nil
+	}
+	if path == imp.pkg.Pkg.Path() {
+		return imp.pkg.Pkg, nil
+	}
+	return nil, fmt.Errorf("not found") // can't happen
+}
+
+var testmainTmpl = template.Must(template.New("testmain").Parse(`
+package main
+
+import "io"
+import "os"
+import "testing"
+import p {{printf "%q" .Pkg.Pkg.Path}}
+
+{{if .Go18}}
+type deps struct{}
+
+func (deps) ImportPath() string { return "" }
+func (deps) MatchString(pat, str string) (bool, error) { return true, nil }
+func (deps) StartCPUProfile(io.Writer) error { return nil }
+func (deps) StartTestLog(io.Writer) {}
+func (deps) StopCPUProfile() {}
+func (deps) StopTestLog() error { return nil }
+func (deps) WriteHeapProfile(io.Writer) error { return nil }
+func (deps) WriteProfileTo(string, io.Writer, int) error { return nil }
+
+var match deps
+{{else}}
+func match(_, _ string) (bool, error) { return true, nil }
+{{end}}
+
+func main() {
+	tests := []testing.InternalTest{
+{{range .Tests}}
+		{ {{printf "%q" .Name}}, p.{{.Name}} },
+{{end}}
+	}
+	benchmarks := []testing.InternalBenchmark{
+{{range .Benchmarks}}
+		{ {{printf "%q" .Name}}, p.{{.Name}} },
+{{end}}
+	}
+	examples := []testing.InternalExample{
+{{range .Examples}}
+		{Name: {{printf "%q" .Name}}, F: p.{{.Name}}},
+{{end}}
+	}
+	m := testing.MainStart(match, tests, benchmarks, examples)
+{{with .Main}}
+	p.{{.Name}}(m)
+{{else}}
+	os.Exit(m.Run())
+{{end}}
+}
+
+`))
+
+var examplesOnlyTmpl = template.Must(template.New("examples").Parse(`
+package main
+
+import p {{printf "%q" .Pkg.Pkg.Path}}
+
+func main() {
+{{range .Examples}}
+	p.{{.Name}}()
+{{end}}
+}
+`))
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/util.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/util.go
new file mode 100644
index 00000000..ddb11846
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/util.go
@@ -0,0 +1,119 @@
+// 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 ssa
+
+// This file defines a number of miscellaneous utility functions.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+//// AST utilities
+
+func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) }
+
+// isBlankIdent returns true iff e is an Ident with name "_".
+// They have no associated types.Object, and thus no type.
+//
+func isBlankIdent(e ast.Expr) bool {
+	id, ok := e.(*ast.Ident)
+	return ok && id.Name == "_"
+}
+
+//// Type utilities.  Some of these belong in go/types.
+
+// isPointer returns true for types whose underlying type is a pointer.
+func isPointer(typ types.Type) bool {
+	_, ok := typ.Underlying().(*types.Pointer)
+	return ok
+}
+
+func isInterface(T types.Type) bool { return types.IsInterface(T) }
+
+// deref returns a pointer's element type; otherwise it returns typ.
+func deref(typ types.Type) types.Type {
+	if p, ok := typ.Underlying().(*types.Pointer); ok {
+		return p.Elem()
+	}
+	return typ
+}
+
+// recvType returns the receiver type of method obj.
+func recvType(obj *types.Func) types.Type {
+	return obj.Type().(*types.Signature).Recv().Type()
+}
+
+// DefaultType returns the default "typed" type for an "untyped" type;
+// it returns the incoming type for all other types.  The default type
+// for untyped nil is untyped nil.
+//
+// Exported to ssa/interp.
+//
+// TODO(adonovan): use go/types.DefaultType after 1.8.
+//
+func DefaultType(typ types.Type) types.Type {
+	if t, ok := typ.(*types.Basic); ok {
+		k := t.Kind()
+		switch k {
+		case types.UntypedBool:
+			k = types.Bool
+		case types.UntypedInt:
+			k = types.Int
+		case types.UntypedRune:
+			k = types.Rune
+		case types.UntypedFloat:
+			k = types.Float64
+		case types.UntypedComplex:
+			k = types.Complex128
+		case types.UntypedString:
+			k = types.String
+		}
+		typ = types.Typ[k]
+	}
+	return typ
+}
+
+// logStack prints the formatted "start" message to stderr and
+// returns a closure that prints the corresponding "end" message.
+// Call using 'defer logStack(...)()' to show builder stack on panic.
+// Don't forget trailing parens!
+//
+func logStack(format string, args ...interface{}) func() {
+	msg := fmt.Sprintf(format, args...)
+	io.WriteString(os.Stderr, msg)
+	io.WriteString(os.Stderr, "\n")
+	return func() {
+		io.WriteString(os.Stderr, msg)
+		io.WriteString(os.Stderr, " end\n")
+	}
+}
+
+// newVar creates a 'var' for use in a types.Tuple.
+func newVar(name string, typ types.Type) *types.Var {
+	return types.NewParam(token.NoPos, nil, name, typ)
+}
+
+// anonVar creates an anonymous 'var' for use in a types.Tuple.
+func anonVar(typ types.Type) *types.Var {
+	return newVar("", typ)
+}
+
+var lenResults = types.NewTuple(anonVar(tInt))
+
+// makeLen returns the len builtin specialized to type func(T)int.
+func makeLen(T types.Type) *Builtin {
+	lenParams := types.NewTuple(anonVar(T))
+	return &Builtin{
+		name: "len",
+		sig:  types.NewSignature(nil, lenParams, lenResults, false),
+	}
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/ssa/wrappers.go b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/wrappers.go
new file mode 100644
index 00000000..701dd90d
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/ssa/wrappers.go
@@ -0,0 +1,294 @@
+// 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 ssa
+
+// This file defines synthesis of Functions that delegate to declared
+// methods; they come in three kinds:
+//
+// (1) wrappers: methods that wrap declared methods, performing
+//     implicit pointer indirections and embedded field selections.
+//
+// (2) thunks: funcs that wrap declared methods.  Like wrappers,
+//     thunks perform indirections and field selections. The thunk's
+//     first parameter is used as the receiver for the method call.
+//
+// (3) bounds: funcs that wrap declared methods.  The bound's sole
+//     free variable, supplied by a closure, is used as the receiver
+//     for the method call.  No indirections or field selections are
+//     performed since they can be done before the call.
+
+import (
+	"fmt"
+
+	"go/types"
+)
+
+// -- wrappers -----------------------------------------------------------
+
+// makeWrapper returns a synthetic method that delegates to the
+// declared method denoted by meth.Obj(), first performing any
+// necessary pointer indirections or field selections implied by meth.
+//
+// The resulting method's receiver type is meth.Recv().
+//
+// This function is versatile but quite subtle!  Consider the
+// following axes of variation when making changes:
+//   - optional receiver indirection
+//   - optional implicit field selections
+//   - meth.Obj() may denote a concrete or an interface method
+//   - the result may be a thunk or a wrapper.
+//
+// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
+//
+func makeWrapper(prog *Program, sel *types.Selection) *Function {
+	obj := sel.Obj().(*types.Func)       // the declared function
+	sig := sel.Type().(*types.Signature) // type of this wrapper
+
+	var recv *types.Var // wrapper's receiver or thunk's params[0]
+	name := obj.Name()
+	var description string
+	var start int // first regular param
+	if sel.Kind() == types.MethodExpr {
+		name += "$thunk"
+		description = "thunk"
+		recv = sig.Params().At(0)
+		start = 1
+	} else {
+		description = "wrapper"
+		recv = sig.Recv()
+	}
+
+	description = fmt.Sprintf("%s for %s", description, sel.Obj())
+	if prog.mode&LogSource != 0 {
+		defer logStack("make %s to (%s)", description, recv.Type())()
+	}
+	fn := &Function{
+		name:      name,
+		method:    sel,
+		object:    obj,
+		Signature: sig,
+		Synthetic: description,
+		Prog:      prog,
+		pos:       obj.Pos(),
+	}
+	fn.startBody()
+	fn.addSpilledParam(recv)
+	createParams(fn, start)
+
+	indices := sel.Index()
+
+	var v Value = fn.Locals[0] // spilled receiver
+	if isPointer(sel.Recv()) {
+		v = emitLoad(fn, v)
+
+		// For simple indirection wrappers, perform an informative nil-check:
+		// "value method (T).f called using nil *T pointer"
+		if len(indices) == 1 && !isPointer(recvType(obj)) {
+			var c Call
+			c.Call.Value = &Builtin{
+				name: "ssa:wrapnilchk",
+				sig: types.NewSignature(nil,
+					types.NewTuple(anonVar(sel.Recv()), anonVar(tString), anonVar(tString)),
+					types.NewTuple(anonVar(sel.Recv())), false),
+			}
+			c.Call.Args = []Value{
+				v,
+				stringConst(deref(sel.Recv()).String()),
+				stringConst(sel.Obj().Name()),
+			}
+			c.setType(v.Type())
+			v = fn.emit(&c)
+		}
+	}
+
+	// Invariant: v is a pointer, either
+	//   value of *A receiver param, or
+	// address of  A spilled receiver.
+
+	// We use pointer arithmetic (FieldAddr possibly followed by
+	// Load) in preference to value extraction (Field possibly
+	// preceded by Load).
+
+	v = emitImplicitSelections(fn, v, indices[:len(indices)-1])
+
+	// Invariant: v is a pointer, either
+	//   value of implicit *C field, or
+	// address of implicit  C field.
+
+	var c Call
+	if r := recvType(obj); !isInterface(r) { // concrete method
+		if !isPointer(r) {
+			v = emitLoad(fn, v)
+		}
+		c.Call.Value = prog.declaredFunc(obj)
+		c.Call.Args = append(c.Call.Args, v)
+	} else {
+		c.Call.Method = obj
+		c.Call.Value = emitLoad(fn, v)
+	}
+	for _, arg := range fn.Params[1:] {
+		c.Call.Args = append(c.Call.Args, arg)
+	}
+	emitTailCall(fn, &c)
+	fn.finishBody()
+	return fn
+}
+
+// createParams creates parameters for wrapper method fn based on its
+// Signature.Params, which do not include the receiver.
+// start is the index of the first regular parameter to use.
+//
+func createParams(fn *Function, start int) {
+	var last *Parameter
+	tparams := fn.Signature.Params()
+	for i, n := start, tparams.Len(); i < n; i++ {
+		last = fn.addParamObj(tparams.At(i))
+	}
+	if fn.Signature.Variadic() {
+		last.typ = types.NewSlice(last.typ)
+	}
+}
+
+// -- bounds -----------------------------------------------------------
+
+// makeBound returns a bound method wrapper (or "bound"), a synthetic
+// function that delegates to a concrete or interface method denoted
+// by obj.  The resulting function has no receiver, but has one free
+// variable which will be used as the method's receiver in the
+// tail-call.
+//
+// Use MakeClosure with such a wrapper to construct a bound method
+// closure.  e.g.:
+//
+//   type T int          or:  type T interface { meth() }
+//   func (t T) meth()
+//   var t T
+//   f := t.meth
+//   f() // calls t.meth()
+//
+// f is a closure of a synthetic wrapper defined as if by:
+//
+//   f := func() { return t.meth() }
+//
+// Unlike makeWrapper, makeBound need perform no indirection or field
+// selections because that can be done before the closure is
+// constructed.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
+//
+func makeBound(prog *Program, obj *types.Func) *Function {
+	prog.methodsMu.Lock()
+	defer prog.methodsMu.Unlock()
+	fn, ok := prog.bounds[obj]
+	if !ok {
+		description := fmt.Sprintf("bound method wrapper for %s", obj)
+		if prog.mode&LogSource != 0 {
+			defer logStack("%s", description)()
+		}
+		fn = &Function{
+			name:      obj.Name() + "$bound",
+			object:    obj,
+			Signature: changeRecv(obj.Type().(*types.Signature), nil), // drop receiver
+			Synthetic: description,
+			Prog:      prog,
+			pos:       obj.Pos(),
+		}
+
+		fv := &FreeVar{name: "recv", typ: recvType(obj), parent: fn}
+		fn.FreeVars = []*FreeVar{fv}
+		fn.startBody()
+		createParams(fn, 0)
+		var c Call
+
+		if !isInterface(recvType(obj)) { // concrete
+			c.Call.Value = prog.declaredFunc(obj)
+			c.Call.Args = []Value{fv}
+		} else {
+			c.Call.Value = fv
+			c.Call.Method = obj
+		}
+		for _, arg := range fn.Params {
+			c.Call.Args = append(c.Call.Args, arg)
+		}
+		emitTailCall(fn, &c)
+		fn.finishBody()
+
+		prog.bounds[obj] = fn
+	}
+	return fn
+}
+
+// -- thunks -----------------------------------------------------------
+
+// makeThunk returns a thunk, a synthetic function that delegates to a
+// concrete or interface method denoted by sel.Obj().  The resulting
+// function has no receiver, but has an additional (first) regular
+// parameter.
+//
+// Precondition: sel.Kind() == types.MethodExpr.
+//
+//   type T int          or:  type T interface { meth() }
+//   func (t T) meth()
+//   f := T.meth
+//   var t T
+//   f(t) // calls t.meth()
+//
+// f is a synthetic wrapper defined as if by:
+//
+//   f := func(t T) { return t.meth() }
+//
+// TODO(adonovan): opt: currently the stub is created even when used
+// directly in a function call: C.f(i, 0).  This is less efficient
+// than inlining the stub.
+//
+// EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
+//
+func makeThunk(prog *Program, sel *types.Selection) *Function {
+	if sel.Kind() != types.MethodExpr {
+		panic(sel)
+	}
+
+	key := selectionKey{
+		kind:     sel.Kind(),
+		recv:     sel.Recv(),
+		obj:      sel.Obj(),
+		index:    fmt.Sprint(sel.Index()),
+		indirect: sel.Indirect(),
+	}
+
+	prog.methodsMu.Lock()
+	defer prog.methodsMu.Unlock()
+
+	// Canonicalize key.recv to avoid constructing duplicate thunks.
+	canonRecv, ok := prog.canon.At(key.recv).(types.Type)
+	if !ok {
+		canonRecv = key.recv
+		prog.canon.Set(key.recv, canonRecv)
+	}
+	key.recv = canonRecv
+
+	fn, ok := prog.thunks[key]
+	if !ok {
+		fn = makeWrapper(prog, sel)
+		if fn.Signature.Recv() != nil {
+			panic(fn) // unexpected receiver
+		}
+		prog.thunks[key] = fn
+	}
+	return fn
+}
+
+func changeRecv(s *types.Signature, recv *types.Var) *types.Signature {
+	return types.NewSignature(recv, s.Params(), s.Results(), s.Variadic())
+}
+
+// selectionKey is like types.Selection but a usable map key.
+type selectionKey struct {
+	kind     types.SelectionKind
+	recv     types.Type // canonicalized via Program.canon
+	obj      types.Object
+	index    string
+	indirect bool
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/imports.go
new file mode 100644
index 00000000..9c441dba
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/imports.go
@@ -0,0 +1,31 @@
+// 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.
+
+package typeutil
+
+import "go/types"
+
+// Dependencies returns all dependencies of the specified packages.
+//
+// Dependent packages appear in topological order: if package P imports
+// package Q, Q appears earlier than P in the result.
+// The algorithm follows import statements in the order they
+// appear in the source code, so the result is a total order.
+//
+func Dependencies(pkgs ...*types.Package) []*types.Package {
+	var result []*types.Package
+	seen := make(map[*types.Package]bool)
+	var visit func(pkgs []*types.Package)
+	visit = func(pkgs []*types.Package) {
+		for _, p := range pkgs {
+			if !seen[p] {
+				seen[p] = true
+				visit(p.Imports())
+				result = append(result, p)
+			}
+		}
+	}
+	visit(pkgs)
+	return result
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/map.go b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/map.go
new file mode 100644
index 00000000..c7f75450
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -0,0 +1,313 @@
+// 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.
+
+// Package typeutil defines various utilities for types, such as Map,
+// a mapping from types.Type to interface{} values.
+package typeutil // import "golang.org/x/tools/go/types/typeutil"
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"reflect"
+)
+
+// Map is a hash-table-based mapping from types (types.Type) to
+// arbitrary interface{} values.  The concrete types that implement
+// the Type interface are pointers.  Since they are not canonicalized,
+// == cannot be used to check for equivalence, and thus we cannot
+// simply use a Go map.
+//
+// Just as with map[K]V, a nil *Map is a valid empty map.
+//
+// Not thread-safe.
+//
+type Map struct {
+	hasher Hasher             // shared by many Maps
+	table  map[uint32][]entry // maps hash to bucket; entry.key==nil means unused
+	length int                // number of map entries
+}
+
+// entry is an entry (key/value association) in a hash bucket.
+type entry struct {
+	key   types.Type
+	value interface{}
+}
+
+// SetHasher sets the hasher used by Map.
+//
+// All Hashers are functionally equivalent but contain internal state
+// used to cache the results of hashing previously seen types.
+//
+// A single Hasher created by MakeHasher() may be shared among many
+// Maps.  This is recommended if the instances have many keys in
+// common, as it will amortize the cost of hash computation.
+//
+// A Hasher may grow without bound as new types are seen.  Even when a
+// type is deleted from the map, the Hasher never shrinks, since other
+// types in the map may reference the deleted type indirectly.
+//
+// Hashers are not thread-safe, and read-only operations such as
+// Map.Lookup require updates to the hasher, so a full Mutex lock (not a
+// read-lock) is require around all Map operations if a shared
+// hasher is accessed from multiple threads.
+//
+// If SetHasher is not called, the Map will create a private hasher at
+// the first call to Insert.
+//
+func (m *Map) SetHasher(hasher Hasher) {
+	m.hasher = hasher
+}
+
+// Delete removes the entry with the given key, if any.
+// It returns true if the entry was found.
+//
+func (m *Map) Delete(key types.Type) bool {
+	if m != nil && m.table != nil {
+		hash := m.hasher.Hash(key)
+		bucket := m.table[hash]
+		for i, e := range bucket {
+			if e.key != nil && types.Identical(key, e.key) {
+				// We can't compact the bucket as it
+				// would disturb iterators.
+				bucket[i] = entry{}
+				m.length--
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// At returns the map entry for the given key.
+// The result is nil if the entry is not present.
+//
+func (m *Map) At(key types.Type) interface{} {
+	if m != nil && m.table != nil {
+		for _, e := range m.table[m.hasher.Hash(key)] {
+			if e.key != nil && types.Identical(key, e.key) {
+				return e.value
+			}
+		}
+	}
+	return nil
+}
+
+// Set sets the map entry for key to val,
+// and returns the previous entry, if any.
+func (m *Map) Set(key types.Type, value interface{}) (prev interface{}) {
+	if m.table != nil {
+		hash := m.hasher.Hash(key)
+		bucket := m.table[hash]
+		var hole *entry
+		for i, e := range bucket {
+			if e.key == nil {
+				hole = &bucket[i]
+			} else if types.Identical(key, e.key) {
+				prev = e.value
+				bucket[i].value = value
+				return
+			}
+		}
+
+		if hole != nil {
+			*hole = entry{key, value} // overwrite deleted entry
+		} else {
+			m.table[hash] = append(bucket, entry{key, value})
+		}
+	} else {
+		if m.hasher.memo == nil {
+			m.hasher = MakeHasher()
+		}
+		hash := m.hasher.Hash(key)
+		m.table = map[uint32][]entry{hash: {entry{key, value}}}
+	}
+
+	m.length++
+	return
+}
+
+// Len returns the number of map entries.
+func (m *Map) Len() int {
+	if m != nil {
+		return m.length
+	}
+	return 0
+}
+
+// Iterate calls function f on each entry in the map in unspecified order.
+//
+// If f should mutate the map, Iterate provides the same guarantees as
+// Go maps: if f deletes a map entry that Iterate has not yet reached,
+// f will not be invoked for it, but if f inserts a map entry that
+// Iterate has not yet reached, whether or not f will be invoked for
+// it is unspecified.
+//
+func (m *Map) Iterate(f func(key types.Type, value interface{})) {
+	if m != nil {
+		for _, bucket := range m.table {
+			for _, e := range bucket {
+				if e.key != nil {
+					f(e.key, e.value)
+				}
+			}
+		}
+	}
+}
+
+// Keys returns a new slice containing the set of map keys.
+// The order is unspecified.
+func (m *Map) Keys() []types.Type {
+	keys := make([]types.Type, 0, m.Len())
+	m.Iterate(func(key types.Type, _ interface{}) {
+		keys = append(keys, key)
+	})
+	return keys
+}
+
+func (m *Map) toString(values bool) string {
+	if m == nil {
+		return "{}"
+	}
+	var buf bytes.Buffer
+	fmt.Fprint(&buf, "{")
+	sep := ""
+	m.Iterate(func(key types.Type, value interface{}) {
+		fmt.Fprint(&buf, sep)
+		sep = ", "
+		fmt.Fprint(&buf, key)
+		if values {
+			fmt.Fprintf(&buf, ": %q", value)
+		}
+	})
+	fmt.Fprint(&buf, "}")
+	return buf.String()
+}
+
+// String returns a string representation of the map's entries.
+// Values are printed using fmt.Sprintf("%v", v).
+// Order is unspecified.
+//
+func (m *Map) String() string {
+	return m.toString(true)
+}
+
+// KeysString returns a string representation of the map's key set.
+// Order is unspecified.
+//
+func (m *Map) KeysString() string {
+	return m.toString(false)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Hasher
+
+// A Hasher maps each type to its hash value.
+// For efficiency, a hasher uses memoization; thus its memory
+// footprint grows monotonically over time.
+// Hashers are not thread-safe.
+// Hashers have reference semantics.
+// Call MakeHasher to create a Hasher.
+type Hasher struct {
+	memo map[types.Type]uint32
+}
+
+// MakeHasher returns a new Hasher instance.
+func MakeHasher() Hasher {
+	return Hasher{make(map[types.Type]uint32)}
+}
+
+// Hash computes a hash value for the given type t such that
+// Identical(t, t') => Hash(t) == Hash(t').
+func (h Hasher) Hash(t types.Type) uint32 {
+	hash, ok := h.memo[t]
+	if !ok {
+		hash = h.hashFor(t)
+		h.memo[t] = hash
+	}
+	return hash
+}
+
+// hashString computes the Fowler–Noll–Vo hash of s.
+func hashString(s string) uint32 {
+	var h uint32
+	for i := 0; i < len(s); i++ {
+		h ^= uint32(s[i])
+		h *= 16777619
+	}
+	return h
+}
+
+// hashFor computes the hash of t.
+func (h Hasher) hashFor(t types.Type) uint32 {
+	// See Identical for rationale.
+	switch t := t.(type) {
+	case *types.Basic:
+		return uint32(t.Kind())
+
+	case *types.Array:
+		return 9043 + 2*uint32(t.Len()) + 3*h.Hash(t.Elem())
+
+	case *types.Slice:
+		return 9049 + 2*h.Hash(t.Elem())
+
+	case *types.Struct:
+		var hash uint32 = 9059
+		for i, n := 0, t.NumFields(); i < n; i++ {
+			f := t.Field(i)
+			if f.Anonymous() {
+				hash += 8861
+			}
+			hash += hashString(t.Tag(i))
+			hash += hashString(f.Name()) // (ignore f.Pkg)
+			hash += h.Hash(f.Type())
+		}
+		return hash
+
+	case *types.Pointer:
+		return 9067 + 2*h.Hash(t.Elem())
+
+	case *types.Signature:
+		var hash uint32 = 9091
+		if t.Variadic() {
+			hash *= 8863
+		}
+		return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
+
+	case *types.Interface:
+		var hash uint32 = 9103
+		for i, n := 0, t.NumMethods(); i < n; i++ {
+			// See go/types.identicalMethods for rationale.
+			// Method order is not significant.
+			// Ignore m.Pkg().
+			m := t.Method(i)
+			hash += 3*hashString(m.Name()) + 5*h.Hash(m.Type())
+		}
+		return hash
+
+	case *types.Map:
+		return 9109 + 2*h.Hash(t.Key()) + 3*h.Hash(t.Elem())
+
+	case *types.Chan:
+		return 9127 + 2*uint32(t.Dir()) + 3*h.Hash(t.Elem())
+
+	case *types.Named:
+		// Not safe with a copying GC; objects may move.
+		return uint32(reflect.ValueOf(t.Obj()).Pointer())
+
+	case *types.Tuple:
+		return h.hashTuple(t)
+	}
+	panic(t)
+}
+
+func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {
+	// See go/types.identicalTypes for rationale.
+	n := tuple.Len()
+	var hash uint32 = 9137 + 2*uint32(n)
+	for i := 0; i < n; i++ {
+		hash += 3 * h.Hash(tuple.At(i).Type())
+	}
+	return hash
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
new file mode 100644
index 00000000..32084610
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
@@ -0,0 +1,72 @@
+// 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.
+
+// This file implements a cache of method sets.
+
+package typeutil
+
+import (
+	"go/types"
+	"sync"
+)
+
+// A MethodSetCache records the method set of each type T for which
+// MethodSet(T) is called so that repeat queries are fast.
+// The zero value is a ready-to-use cache instance.
+type MethodSetCache struct {
+	mu     sync.Mutex
+	named  map[*types.Named]struct{ value, pointer *types.MethodSet } // method sets for named N and *N
+	others map[types.Type]*types.MethodSet                            // all other types
+}
+
+// MethodSet returns the method set of type T.  It is thread-safe.
+//
+// If cache is nil, this function is equivalent to types.NewMethodSet(T).
+// Utility functions can thus expose an optional *MethodSetCache
+// parameter to clients that care about performance.
+//
+func (cache *MethodSetCache) MethodSet(T types.Type) *types.MethodSet {
+	if cache == nil {
+		return types.NewMethodSet(T)
+	}
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	switch T := T.(type) {
+	case *types.Named:
+		return cache.lookupNamed(T).value
+
+	case *types.Pointer:
+		if N, ok := T.Elem().(*types.Named); ok {
+			return cache.lookupNamed(N).pointer
+		}
+	}
+
+	// all other types
+	// (The map uses pointer equivalence, not type identity.)
+	mset := cache.others[T]
+	if mset == nil {
+		mset = types.NewMethodSet(T)
+		if cache.others == nil {
+			cache.others = make(map[types.Type]*types.MethodSet)
+		}
+		cache.others[T] = mset
+	}
+	return mset
+}
+
+func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } {
+	if cache.named == nil {
+		cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet })
+	}
+	// Avoid recomputing mset(*T) for each distinct Pointer
+	// instance whose underlying type is a named type.
+	msets, ok := cache.named[named]
+	if !ok {
+		msets.value = types.NewMethodSet(named)
+		msets.pointer = types.NewMethodSet(types.NewPointer(named))
+		cache.named[named] = msets
+	}
+	return msets
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/ui.go
new file mode 100644
index 00000000..9849c24c
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/go/types/typeutil/ui.go
@@ -0,0 +1,52 @@
+// 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.
+
+package typeutil
+
+// This file defines utilities for user interfaces that display types.
+
+import "go/types"
+
+// IntuitiveMethodSet returns the intuitive method set of a type T,
+// which is the set of methods you can call on an addressable value of
+// that type.
+//
+// The result always contains MethodSet(T), and is exactly MethodSet(T)
+// for interface types and for pointer-to-concrete types.
+// For all other concrete types T, the result additionally
+// contains each method belonging to *T if there is no identically
+// named method on T itself.
+//
+// This corresponds to user intuition about method sets;
+// this function is intended only for user interfaces.
+//
+// The order of the result is as for types.MethodSet(T).
+//
+func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
+	isPointerToConcrete := func(T types.Type) bool {
+		ptr, ok := T.(*types.Pointer)
+		return ok && !types.IsInterface(ptr.Elem())
+	}
+
+	var result []*types.Selection
+	mset := msets.MethodSet(T)
+	if types.IsInterface(T) || isPointerToConcrete(T) {
+		for i, n := 0, mset.Len(); i < n; i++ {
+			result = append(result, mset.At(i))
+		}
+	} else {
+		// T is some other concrete type.
+		// Report methods of T and *T, preferring those of T.
+		pmset := msets.MethodSet(types.NewPointer(T))
+		for i, n := 0, pmset.Len(); i < n; i++ {
+			meth := pmset.At(i)
+			if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil {
+				meth = m
+			}
+			result = append(result, meth)
+		}
+
+	}
+	return result
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/imports/fix.go b/src/margo.sh/vendor/golang.org/x/tools/imports/fix.go
new file mode 100644
index 00000000..ebb228d1
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/imports/fix.go
@@ -0,0 +1,1125 @@
+// 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"
+	"context"
+	"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"
+	"golang.org/x/tools/internal/fastwalk"
+)
+
+// Debug controls verbose logging.
+var Debug = false
+
+// LocalPrefix is a comma-separated string of import path prefixes, which, if
+// set, instructs Process to sort the import paths with the given prefixes
+// into another group after 3rd-party packages.
+var LocalPrefix string
+
+func localPrefixes() []string {
+	if LocalPrefix != "" {
+		return strings.Split(LocalPrefix, ",")
+	}
+	return nil
+}
+
+// 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) {
+		for _, p := range localPrefixes() {
+			if strings.HasPrefix(importPath, p) || strings.TrimSuffix(p, "/") == importPath {
+				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
+	// refs are a set of package references currently satisfied by imports.
+	// first key: either base package (e.g. "fmt") or renamed package
+	// second key: referenced package symbol (e.g. "Println")
+	Refs map[string]map[string]bool
+}
+
+// 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")
+
+	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),
+		Refs:    make(map[string]map[string]bool),
+	}
+
+	visitor := collectReferences(info.Refs)
+	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
+		}
+
+		ast.Walk(visitor, root)
+	}
+	return info, nil
+}
+
+// collectReferences returns a visitor that collects all exported package
+// references
+func collectReferences(refs map[string]map[string]bool) visitFn {
+	var visitor visitFn
+	visitor = func(node ast.Node) ast.Visitor {
+		if node == nil {
+			return visitor
+		}
+		switch v := node.(type) {
+		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
+			r := refs[pkgName]
+			if r == nil {
+				r = make(map[string]bool)
+				refs[pkgName] = r
+			}
+			if ast.IsExported(v.Sel.Name) {
+				r[v.Sel.Name] = true
+			}
+		}
+		return visitor
+	}
+	return visitor
+}
+
+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.
+	type result struct {
+		ipath string // import path
+		name  string // optional name to rename import as
+	}
+	results := make(chan result, len(refs))
+
+	ctx, cancel := context.WithCancel(context.TODO())
+	var wg sync.WaitGroup
+	defer func() {
+		cancel()
+		wg.Wait()
+	}()
+	var (
+		firstErr     error
+		firstErrOnce sync.Once
+	)
+	for pkgName, symbols := range refs {
+		wg.Add(1)
+		go func(pkgName string, symbols map[string]bool) {
+			defer wg.Done()
+
+			if packageInfo != nil {
+				sibling := packageInfo.Imports[pkgName]
+				if sibling.Path != "" {
+					refs := packageInfo.Refs[pkgName]
+					for symbol := range symbols {
+						if refs[symbol] {
+							results <- result{ipath: sibling.Path, name: sibling.Alias}
+							return
+						}
+					}
+				}
+			}
+
+			ipath, rename, err := findImport(ctx, pkgName, symbols, filename)
+			if err != nil {
+				firstErrOnce.Do(func() {
+					firstErr = err
+					cancel()
+				})
+				return
+			}
+
+			if ipath == "" {
+				return // No matching package.
+			}
+
+			r := result{ipath: ipath}
+			if rename {
+				r.name = pkgName
+			}
+			results <- r
+			return
+		}(pkgName, symbols)
+	}
+	go func() {
+		wg.Wait()
+		close(results)
+	}()
+
+	for result := range results {
+		if result.name != "" {
+			astutil.AddNamedImport(fset, f, result.name, result.ipath)
+		} else {
+			astutil.AddImport(fset, f, result.ipath)
+		}
+		added = append(added, result.ipath)
+	}
+
+	if firstErr != nil {
+		return nil, firstErr
+	}
+	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.Mutex
+	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")
+}
+
+type pkgDistance struct {
+	pkg      *pkg
+	distance int // relative distance to target
+}
+
+// byDistanceOrImportPathShortLength sorts by relative distance breaking ties
+// on the short import path length and then the import string itself.
+type byDistanceOrImportPathShortLength []pkgDistance
+
+func (s byDistanceOrImportPathShortLength) Len() int { return len(s) }
+func (s byDistanceOrImportPathShortLength) Less(i, j int) bool {
+	di, dj := s[i].distance, s[j].distance
+	if di == -1 {
+		return false
+	}
+	if dj == -1 {
+		return true
+	}
+	if di != dj {
+		return di < dj
+	}
+
+	vi, vj := s[i].pkg.importPathShort, s[j].pkg.importPathShort
+	if len(vi) != len(vj) {
+		return len(vi) < len(vj)
+	}
+	return vi < vj
+}
+func (s byDistanceOrImportPathShortLength) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+func distance(basepath, targetpath string) int {
+	p, err := filepath.Rel(basepath, targetpath)
+	if err != nil {
+		return -1
+	}
+	if p == "." {
+		return 0
+	}
+	return strings.Count(p, string(filepath.Separator)) + 1
+}
+
+// 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, 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 {
+		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) {}
+
+type goDirType string
+
+const (
+	goRoot goDirType = "$GOROOT"
+	goPath goDirType = "$GOPATH"
+)
+
+var scanGoRootDone = make(chan struct{}) // closed when scanGoRoot is done
+
+// scanGoDirs populates the dirScan map for the given directory type. It may be
+// called concurrently (and usually is, if both directory types are needed).
+func scanGoDirs(which goDirType) {
+	if Debug {
+		log.Printf("scanning %s", which)
+		defer log.Printf("scanned %s", which)
+	}
+
+	for _, srcDir := range build.Default.SrcDirs() {
+		isGoroot := srcDir == filepath.Join(build.Default.GOROOT, "src")
+		if isGoroot != (which == 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()
+				defer dirScanMu.Unlock()
+				if _, dup := dirScan[dir]; dup {
+					return nil
+				}
+				if dirScan == nil {
+					dirScan = make(map[string]*pkg)
+				}
+				importpath := filepath.ToSlash(dir[len(srcDir)+len("/"):])
+				dirScan[dir] = &pkg{
+					importPath:      importpath,
+					importPathShort: VendorlessPath(importpath),
+					dir:             dir,
+				}
+				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 fastwalk.TraverseLink
+				}
+			}
+			return nil
+		}
+		if err := fastwalk.Walk(srcDir, walkFn); err != nil {
+			log.Printf("goimports: scanning directory %v: %v", srcDir, err)
+		}
+	}
+}
+
+// VendorlessPath returns the devendorized version of the import path ipath.
+// For example, VendorlessPath("foo/bar/vendor/a/b") returns "a/b".
+func VendorlessPath(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(ctx context.Context, expectPackage, dir string) (map[string]bool, error) = loadExportsGoPath
+
+func loadExportsGoPath(ctx context.Context, expectPackage, dir string) (map[string]bool, error) {
+	if Debug {
+		log.Printf("loading exports in dir %s (seeking package %s)", dir, expectPackage)
+	}
+	exports := make(map[string]bool)
+
+	buildCtx := 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.
+	buildCtx.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 := buildCtx.ReadDir(dir)
+	if err != nil {
+		log.Print(err)
+		return nil, err
+	}
+
+	fset := token.NewFileSet()
+
+	for _, fi := range files {
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+
+		match, err := buildCtx.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, err
+		}
+		pkgName := f.Name.Name
+		if pkgName == "documentation" {
+			// Special case from go/build.ImportDir, not
+			// handled by buildCtx.MatchFile.
+			continue
+		}
+		if pkgName != expectPackage {
+			err := fmt.Errorf("scan of dir %v is not expected package %v (actually %v)", dir, expectPackage, pkgName)
+			if Debug {
+				log.Print(err)
+			}
+			return nil, err
+		}
+		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, nil
+}
+
+// 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(ctx context.Context, 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(ctx context.Context, pkgName string, symbols map[string]bool, filename string) (foundPkg string, rename bool, err error) {
+	pkgDir, err := filepath.Abs(filename)
+	if err != nil {
+		return "", false, err
+	}
+	pkgDir = filepath.Dir(pkgDir)
+
+	// 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, ok := findImportStdlib(pkgName, symbols); ok {
+		return pkg, false, 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(func() {
+		go func() {
+			scanGoDirs(goRoot)
+			close(scanGoRootDone)
+		}()
+	})
+	if !fileInDir(filename, build.Default.GOROOT) {
+		scanGoPathOnce.Do(func() { scanGoDirs(goPath) })
+	}
+	<-scanGoRootDone
+
+	// Find candidate packages, looking only at their directory names first.
+	var candidates []pkgDistance
+	for _, pkg := range dirScan {
+		if pkgIsCandidate(filename, pkgName, pkg) {
+			candidates = append(candidates, pkgDistance{
+				pkg:      pkg,
+				distance: distance(pkgDir, pkg.dir),
+			})
+		}
+	}
+
+	// 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(byDistanceOrImportPathShortLength(candidates))
+	if Debug {
+		for i, c := range candidates {
+			log.Printf("%s candidate %d/%d: %v in %v", pkgName, i+1, len(candidates), c.pkg.importPathShort, c.pkg.dir)
+		}
+	}
+
+	// Collect exports for packages with matching names.
+
+	rescv := make([]chan *pkg, len(candidates))
+	for i := range candidates {
+		rescv[i] = make(chan *pkg, 1)
+	}
+	const maxConcurrentPackageImport = 4
+	loadExportsSem := make(chan struct{}, maxConcurrentPackageImport)
+
+	ctx, cancel := context.WithCancel(ctx)
+	var wg sync.WaitGroup
+	defer func() {
+		cancel()
+		wg.Wait()
+	}()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for i, c := range candidates {
+			select {
+			case loadExportsSem <- struct{}{}:
+			case <-ctx.Done():
+				return
+			}
+
+			wg.Add(1)
+			go func(c pkgDistance, resc chan<- *pkg) {
+				defer func() {
+					<-loadExportsSem
+					wg.Done()
+				}()
+
+				exports, err := loadExports(ctx, pkgName, c.pkg.dir)
+				if err != nil {
+					resc <- nil
+					return
+				}
+
+				// If it doesn't have the right
+				// symbols, send nil to mean no match.
+				for symbol := range symbols {
+					if !exports[symbol] {
+						resc <- nil
+						return
+					}
+				}
+				resc <- c.pkg
+			}(c, rescv[i])
+		}
+	}()
+
+	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, ok bool) {
+	for symbol := range symbols {
+		key := shortPkg + "." + symbol
+		path := stdlib[key]
+		if path == "" {
+			if key == "rand.Read" {
+				continue
+			}
+			return "", false
+		}
+		if importPath != "" && importPath != path {
+			// Ambiguous. Symbols pointed to different things.
+			return "", false
+		}
+		importPath = path
+	}
+	if importPath == "" && shortPkg == "rand" && symbols["Read"] {
+		return "crypto/rand", true
+	}
+	return importPath, 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/src/margo.sh/vendor/golang.org/x/tools/imports/imports.go b/src/margo.sh/vendor/golang.org/x/tools/imports/imports.go
new file mode 100644
index 00000000..a4cbf5c7
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/imports/imports.go
@@ -0,0 +1,310 @@
+// 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"
+	"io/ioutil"
+	"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}
+	}
+	if src == nil {
+		b, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return nil, err
+		}
+		src = b
+	}
+
+	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, err = addImportSpaces(bytes.NewReader(out), spacesBefore)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	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 parse errors are on
+	// the correct line.
+	const prefix = "package main;"
+	psrc := append([]byte(prefix), src...)
+	file, err = parser.ParseFile(fset, filename, psrc, parserMode)
+	if err == nil {
+		// Gofmt will turn the ; into a \n.
+		// Do that ourselves now and update the file contents,
+		// so that positions and line numbers are correct going forward.
+		psrc[len(prefix)-1] = '\n'
+		fset.File(file.Package).SetLinesForContent(psrc)
+
+		// 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.
+			src = src[len(prefix):]
+			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, error) {
+	var out bytes.Buffer
+	in := bufio.NewReader(r)
+	inImports := false
+	done := false
+	for {
+		s, err := in.ReadString('\n')
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+
+		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.Fprint(&out, s)
+	}
+	return out.Bytes(), nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/imports/mkindex.go b/src/margo.sh/vendor/golang.org/x/tools/imports/mkindex.go
new file mode 100644
index 00000000..755e2394
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/imports/mkstdlib.go b/src/margo.sh/vendor/golang.org/x/tools/imports/mkstdlib.go
new file mode 100644
index 00000000..02e4727e
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/imports/mkstdlib.go
@@ -0,0 +1,107 @@
+// +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"
+	"runtime"
+	"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(runtime.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")),
+		mustOpen(api("go1.10.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/src/margo.sh/vendor/golang.org/x/tools/imports/sortimports.go b/src/margo.sh/vendor/golang.org/x/tools/imports/sortimports.go
new file mode 100644
index 00000000..653afc51
--- /dev/null
+++ b/src/margo.sh/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/src/margo.sh/vendor/golang.org/x/tools/imports/zstdlib.go b/src/margo.sh/vendor/golang.org/x/tools/imports/zstdlib.go
new file mode 100644
index 00000000..c590a4b1
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/imports/zstdlib.go
@@ -0,0 +1,9734 @@
+// 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.MarshalWithParams":                        "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.TagNumericString":                         "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.Connector":                              "database/sql/driver",
+	"driver.DefaultParameterConverter":              "database/sql/driver",
+	"driver.Driver":                                 "database/sql/driver",
+	"driver.DriverContext":                          "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.SessionResetter":                        "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_16":                                  "debug/elf",
+	"elf.R_386_32":                                  "debug/elf",
+	"elf.R_386_32PLT":                               "debug/elf",
+	"elf.R_386_8":                                   "debug/elf",
+	"elf.R_386_COPY":                                "debug/elf",
+	"elf.R_386_GLOB_DAT":                            "debug/elf",
+	"elf.R_386_GOT32":                               "debug/elf",
+	"elf.R_386_GOT32X":                              "debug/elf",
+	"elf.R_386_GOTOFF":                              "debug/elf",
+	"elf.R_386_GOTPC":                               "debug/elf",
+	"elf.R_386_IRELATIVE":                           "debug/elf",
+	"elf.R_386_JMP_SLOT":                            "debug/elf",
+	"elf.R_386_NONE":                                "debug/elf",
+	"elf.R_386_PC16":                                "debug/elf",
+	"elf.R_386_PC32":                                "debug/elf",
+	"elf.R_386_PC8":                                 "debug/elf",
+	"elf.R_386_PLT32":                               "debug/elf",
+	"elf.R_386_RELATIVE":                            "debug/elf",
+	"elf.R_386_SIZE32":                              "debug/elf",
+	"elf.R_386_TLS_DESC":                            "debug/elf",
+	"elf.R_386_TLS_DESC_CALL":                       "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_GOTDESC":                         "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_GOTOFF_LO15":                "debug/elf",
+	"elf.R_AARCH64_LD64_GOTPAGE_LO15":               "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_TLSGD_ADR_PREL21":                "debug/elf",
+	"elf.R_AARCH64_TLSGD_MOVW_G0_NC":                "debug/elf",
+	"elf.R_AARCH64_TLSGD_MOVW_G1":                   "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_TLSLD_ADR_PAGE21":                "debug/elf",
+	"elf.R_AARCH64_TLSLD_ADR_PREL21":                "debug/elf",
+	"elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12":       "debug/elf",
+	"elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC":    "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_LDST128_TPREL_LO12":        "debug/elf",
+	"elf.R_AARCH64_TLSLE_LDST128_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_ABS32_NOI":                           "debug/elf",
+	"elf.R_ARM_ABS8":                                "debug/elf",
+	"elf.R_ARM_ALU_PCREL_15_8":                      "debug/elf",
+	"elf.R_ARM_ALU_PCREL_23_15":                     "debug/elf",
+	"elf.R_ARM_ALU_PCREL_7_0":                       "debug/elf",
+	"elf.R_ARM_ALU_PC_G0":                           "debug/elf",
+	"elf.R_ARM_ALU_PC_G0_NC":                        "debug/elf",
+	"elf.R_ARM_ALU_PC_G1":                           "debug/elf",
+	"elf.R_ARM_ALU_PC_G1_NC":                        "debug/elf",
+	"elf.R_ARM_ALU_PC_G2":                           "debug/elf",
+	"elf.R_ARM_ALU_SBREL_19_12_NC":                  "debug/elf",
+	"elf.R_ARM_ALU_SBREL_27_20_CK":                  "debug/elf",
+	"elf.R_ARM_ALU_SB_G0":                           "debug/elf",
+	"elf.R_ARM_ALU_SB_G0_NC":                        "debug/elf",
+	"elf.R_ARM_ALU_SB_G1":                           "debug/elf",
+	"elf.R_ARM_ALU_SB_G1_NC":                        "debug/elf",
+	"elf.R_ARM_ALU_SB_G2":                           "debug/elf",
+	"elf.R_ARM_AMP_VCALL9":                          "debug/elf",
+	"elf.R_ARM_BASE_ABS":                            "debug/elf",
+	"elf.R_ARM_CALL":                                "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_GOTOFF12":                            "debug/elf",
+	"elf.R_ARM_GOTPC":                               "debug/elf",
+	"elf.R_ARM_GOTRELAX":                            "debug/elf",
+	"elf.R_ARM_GOT_ABS":                             "debug/elf",
+	"elf.R_ARM_GOT_BREL12":                          "debug/elf",
+	"elf.R_ARM_GOT_PREL":                            "debug/elf",
+	"elf.R_ARM_IRELATIVE":                           "debug/elf",
+	"elf.R_ARM_JUMP24":                              "debug/elf",
+	"elf.R_ARM_JUMP_SLOT":                           "debug/elf",
+	"elf.R_ARM_LDC_PC_G0":                           "debug/elf",
+	"elf.R_ARM_LDC_PC_G1":                           "debug/elf",
+	"elf.R_ARM_LDC_PC_G2":                           "debug/elf",
+	"elf.R_ARM_LDC_SB_G0":                           "debug/elf",
+	"elf.R_ARM_LDC_SB_G1":                           "debug/elf",
+	"elf.R_ARM_LDC_SB_G2":                           "debug/elf",
+	"elf.R_ARM_LDRS_PC_G0":                          "debug/elf",
+	"elf.R_ARM_LDRS_PC_G1":                          "debug/elf",
+	"elf.R_ARM_LDRS_PC_G2":                          "debug/elf",
+	"elf.R_ARM_LDRS_SB_G0":                          "debug/elf",
+	"elf.R_ARM_LDRS_SB_G1":                          "debug/elf",
+	"elf.R_ARM_LDRS_SB_G2":                          "debug/elf",
+	"elf.R_ARM_LDR_PC_G1":                           "debug/elf",
+	"elf.R_ARM_LDR_PC_G2":                           "debug/elf",
+	"elf.R_ARM_LDR_SBREL_11_10_NC":                  "debug/elf",
+	"elf.R_ARM_LDR_SB_G0":                           "debug/elf",
+	"elf.R_ARM_LDR_SB_G1":                           "debug/elf",
+	"elf.R_ARM_LDR_SB_G2":                           "debug/elf",
+	"elf.R_ARM_ME_TOO":                              "debug/elf",
+	"elf.R_ARM_MOVT_ABS":                            "debug/elf",
+	"elf.R_ARM_MOVT_BREL":                           "debug/elf",
+	"elf.R_ARM_MOVT_PREL":                           "debug/elf",
+	"elf.R_ARM_MOVW_ABS_NC":                         "debug/elf",
+	"elf.R_ARM_MOVW_BREL":                           "debug/elf",
+	"elf.R_ARM_MOVW_BREL_NC":                        "debug/elf",
+	"elf.R_ARM_MOVW_PREL_NC":                        "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_PLT32_ABS":                           "debug/elf",
+	"elf.R_ARM_PREL31":                              "debug/elf",
+	"elf.R_ARM_PRIVATE_0":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_1":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_10":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_11":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_12":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_13":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_14":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_15":                          "debug/elf",
+	"elf.R_ARM_PRIVATE_2":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_3":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_4":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_5":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_6":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_7":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_8":                           "debug/elf",
+	"elf.R_ARM_PRIVATE_9":                           "debug/elf",
+	"elf.R_ARM_RABS32":                              "debug/elf",
+	"elf.R_ARM_RBASE":                               "debug/elf",
+	"elf.R_ARM_REL32":                               "debug/elf",
+	"elf.R_ARM_REL32_NOI":                           "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_RXPC25":                              "debug/elf",
+	"elf.R_ARM_SBREL31":                             "debug/elf",
+	"elf.R_ARM_SBREL32":                             "debug/elf",
+	"elf.R_ARM_SWI24":                               "debug/elf",
+	"elf.R_ARM_TARGET1":                             "debug/elf",
+	"elf.R_ARM_TARGET2":                             "debug/elf",
+	"elf.R_ARM_THM_ABS5":                            "debug/elf",
+	"elf.R_ARM_THM_ALU_ABS_G0_NC":                   "debug/elf",
+	"elf.R_ARM_THM_ALU_ABS_G1_NC":                   "debug/elf",
+	"elf.R_ARM_THM_ALU_ABS_G2_NC":                   "debug/elf",
+	"elf.R_ARM_THM_ALU_ABS_G3":                      "debug/elf",
+	"elf.R_ARM_THM_ALU_PREL_11_0":                   "debug/elf",
+	"elf.R_ARM_THM_GOT_BREL12":                      "debug/elf",
+	"elf.R_ARM_THM_JUMP11":                          "debug/elf",
+	"elf.R_ARM_THM_JUMP19":                          "debug/elf",
+	"elf.R_ARM_THM_JUMP24":                          "debug/elf",
+	"elf.R_ARM_THM_JUMP6":                           "debug/elf",
+	"elf.R_ARM_THM_JUMP8":                           "debug/elf",
+	"elf.R_ARM_THM_MOVT_ABS":                        "debug/elf",
+	"elf.R_ARM_THM_MOVT_BREL":                       "debug/elf",
+	"elf.R_ARM_THM_MOVT_PREL":                       "debug/elf",
+	"elf.R_ARM_THM_MOVW_ABS_NC":                     "debug/elf",
+	"elf.R_ARM_THM_MOVW_BREL":                       "debug/elf",
+	"elf.R_ARM_THM_MOVW_BREL_NC":                    "debug/elf",
+	"elf.R_ARM_THM_MOVW_PREL_NC":                    "debug/elf",
+	"elf.R_ARM_THM_PC12":                            "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_TLS_CALL":                        "debug/elf",
+	"elf.R_ARM_THM_TLS_DESCSEQ16":                   "debug/elf",
+	"elf.R_ARM_THM_TLS_DESCSEQ32":                   "debug/elf",
+	"elf.R_ARM_THM_XPC22":                           "debug/elf",
+	"elf.R_ARM_TLS_CALL":                            "debug/elf",
+	"elf.R_ARM_TLS_DESCSEQ":                         "debug/elf",
+	"elf.R_ARM_TLS_DTPMOD32":                        "debug/elf",
+	"elf.R_ARM_TLS_DTPOFF32":                        "debug/elf",
+	"elf.R_ARM_TLS_GD32":                            "debug/elf",
+	"elf.R_ARM_TLS_GOTDESC":                         "debug/elf",
+	"elf.R_ARM_TLS_IE12GP":                          "debug/elf",
+	"elf.R_ARM_TLS_IE32":                            "debug/elf",
+	"elf.R_ARM_TLS_LDM32":                           "debug/elf",
+	"elf.R_ARM_TLS_LDO12":                           "debug/elf",
+	"elf.R_ARM_TLS_LDO32":                           "debug/elf",
+	"elf.R_ARM_TLS_LE12":                            "debug/elf",
+	"elf.R_ARM_TLS_LE32":                            "debug/elf",
+	"elf.R_ARM_TLS_TPOFF32":                         "debug/elf",
+	"elf.R_ARM_V4BX":                                "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_HIGH":                       "debug/elf",
+	"elf.R_PPC64_ADDR16_HIGHA":                      "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_ADDR64_LOCAL":                      "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_HIGH":                     "debug/elf",
+	"elf.R_PPC64_DTPREL16_HIGHA":                    "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_ENTRY":                             "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_IRELATIVE":                         "debug/elf",
+	"elf.R_PPC64_JMP_IREL":                          "debug/elf",
+	"elf.R_PPC64_JMP_SLOT":                          "debug/elf",
+	"elf.R_PPC64_NONE":                              "debug/elf",
+	"elf.R_PPC64_PLT16_LO_DS":                       "debug/elf",
+	"elf.R_PPC64_PLTGOT16":                          "debug/elf",
+	"elf.R_PPC64_PLTGOT16_DS":                       "debug/elf",
+	"elf.R_PPC64_PLTGOT16_HA":                       "debug/elf",
+	"elf.R_PPC64_PLTGOT16_HI":                       "debug/elf",
+	"elf.R_PPC64_PLTGOT16_LO":                       "debug/elf",
+	"elf.R_PPC64_PLTGOT_LO_DS":                      "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_REL16DX_HA":                        "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_REL24_NOTOC":                       "debug/elf",
+	"elf.R_PPC64_REL32":                             "debug/elf",
+	"elf.R_PPC64_REL64":                             "debug/elf",
+	"elf.R_PPC64_SECTOFF_DS":                        "debug/elf",
+	"elf.R_PPC64_SECTOFF_LO_DS":                     "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_TOCSAVE":                           "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_HIGH":                      "debug/elf",
+	"elf.R_PPC64_TPREL16_HIGHA":                     "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_GOT64":                            "debug/elf",
+	"elf.R_X86_64_GOTOFF64":                         "debug/elf",
+	"elf.R_X86_64_GOTPC32":                          "debug/elf",
+	"elf.R_X86_64_GOTPC32_TLSDESC":                  "debug/elf",
+	"elf.R_X86_64_GOTPC64":                          "debug/elf",
+	"elf.R_X86_64_GOTPCREL":                         "debug/elf",
+	"elf.R_X86_64_GOTPCREL64":                       "debug/elf",
+	"elf.R_X86_64_GOTPCRELX":                        "debug/elf",
+	"elf.R_X86_64_GOTPLT64":                         "debug/elf",
+	"elf.R_X86_64_GOTTPOFF":                         "debug/elf",
+	"elf.R_X86_64_IRELATIVE":                        "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_PC32_BND":                         "debug/elf",
+	"elf.R_X86_64_PC64":                             "debug/elf",
+	"elf.R_X86_64_PC8":                              "debug/elf",
+	"elf.R_X86_64_PLT32":                            "debug/elf",
+	"elf.R_X86_64_PLT32_BND":                        "debug/elf",
+	"elf.R_X86_64_PLTOFF64":                         "debug/elf",
+	"elf.R_X86_64_RELATIVE":                         "debug/elf",
+	"elf.R_X86_64_RELATIVE64":                       "debug/elf",
+	"elf.R_X86_64_REX_GOTPCRELX":                    "debug/elf",
+	"elf.R_X86_64_SIZE32":                           "debug/elf",
+	"elf.R_X86_64_SIZE64":                           "debug/elf",
+	"elf.R_X86_64_TLSDESC":                          "debug/elf",
+	"elf.R_X86_64_TLSDESC_CALL":                     "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",
+	"hex.NewDecoder":                                "encoding/hex",
+	"hex.NewEncoder":                                "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.ARM64_RELOC_ADDEND":                      "debug/macho",
+	"macho.ARM64_RELOC_BRANCH26":                    "debug/macho",
+	"macho.ARM64_RELOC_GOT_LOAD_PAGE21":             "debug/macho",
+	"macho.ARM64_RELOC_GOT_LOAD_PAGEOFF12":          "debug/macho",
+	"macho.ARM64_RELOC_PAGE21":                      "debug/macho",
+	"macho.ARM64_RELOC_PAGEOFF12":                   "debug/macho",
+	"macho.ARM64_RELOC_POINTER_TO_GOT":              "debug/macho",
+	"macho.ARM64_RELOC_SUBTRACTOR":                  "debug/macho",
+	"macho.ARM64_RELOC_TLVP_LOAD_PAGE21":            "debug/macho",
+	"macho.ARM64_RELOC_TLVP_LOAD_PAGEOFF12":         "debug/macho",
+	"macho.ARM64_RELOC_UNSIGNED":                    "debug/macho",
+	"macho.ARM_RELOC_BR24":                          "debug/macho",
+	"macho.ARM_RELOC_HALF":                          "debug/macho",
+	"macho.ARM_RELOC_HALF_SECTDIFF":                 "debug/macho",
+	"macho.ARM_RELOC_LOCAL_SECTDIFF":                "debug/macho",
+	"macho.ARM_RELOC_PAIR":                          "debug/macho",
+	"macho.ARM_RELOC_PB_LA_PTR":                     "debug/macho",
+	"macho.ARM_RELOC_SECTDIFF":                      "debug/macho",
+	"macho.ARM_RELOC_VANILLA":                       "debug/macho",
+	"macho.ARM_THUMB_32BIT_BRANCH":                  "debug/macho",
+	"macho.ARM_THUMB_RELOC_BR22":                    "debug/macho",
+	"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.FlagAllModsBound":                        "debug/macho",
+	"macho.FlagAllowStackExecution":                 "debug/macho",
+	"macho.FlagAppExtensionSafe":                    "debug/macho",
+	"macho.FlagBindAtLoad":                          "debug/macho",
+	"macho.FlagBindsToWeak":                         "debug/macho",
+	"macho.FlagCanonical":                           "debug/macho",
+	"macho.FlagDeadStrippableDylib":                 "debug/macho",
+	"macho.FlagDyldLink":                            "debug/macho",
+	"macho.FlagForceFlat":                           "debug/macho",
+	"macho.FlagHasTLVDescriptors":                   "debug/macho",
+	"macho.FlagIncrLink":                            "debug/macho",
+	"macho.FlagLazyInit":                            "debug/macho",
+	"macho.FlagNoFixPrebinding":                     "debug/macho",
+	"macho.FlagNoHeapExecution":                     "debug/macho",
+	"macho.FlagNoMultiDefs":                         "debug/macho",
+	"macho.FlagNoReexportedDylibs":                  "debug/macho",
+	"macho.FlagNoUndefs":                            "debug/macho",
+	"macho.FlagPIE":                                 "debug/macho",
+	"macho.FlagPrebindable":                         "debug/macho",
+	"macho.FlagPrebound":                            "debug/macho",
+	"macho.FlagRootSafe":                            "debug/macho",
+	"macho.FlagSetuidSafe":                          "debug/macho",
+	"macho.FlagSplitSegs":                           "debug/macho",
+	"macho.FlagSubsectionsViaSymbols":               "debug/macho",
+	"macho.FlagTwoLevel":                            "debug/macho",
+	"macho.FlagWeakDefines":                         "debug/macho",
+	"macho.FormatError":                             "debug/macho",
+	"macho.GENERIC_RELOC_LOCAL_SECTDIFF":            "debug/macho",
+	"macho.GENERIC_RELOC_PAIR":                      "debug/macho",
+	"macho.GENERIC_RELOC_PB_LA_PTR":                 "debug/macho",
+	"macho.GENERIC_RELOC_SECTDIFF":                  "debug/macho",
+	"macho.GENERIC_RELOC_TLV":                       "debug/macho",
+	"macho.GENERIC_RELOC_VANILLA":                   "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.LoadCmdRpath":                            "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.Reloc":                                   "debug/macho",
+	"macho.RelocTypeARM":                            "debug/macho",
+	"macho.RelocTypeARM64":                          "debug/macho",
+	"macho.RelocTypeGeneric":                        "debug/macho",
+	"macho.RelocTypeX86_64":                         "debug/macho",
+	"macho.Rpath":                                   "debug/macho",
+	"macho.RpathCmd":                                "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",
+	"macho.X86_64_RELOC_BRANCH":                     "debug/macho",
+	"macho.X86_64_RELOC_GOT":                        "debug/macho",
+	"macho.X86_64_RELOC_GOT_LOAD":                   "debug/macho",
+	"macho.X86_64_RELOC_SIGNED":                     "debug/macho",
+	"macho.X86_64_RELOC_SIGNED_1":                   "debug/macho",
+	"macho.X86_64_RELOC_SIGNED_2":                   "debug/macho",
+	"macho.X86_64_RELOC_SIGNED_4":                   "debug/macho",
+	"macho.X86_64_RELOC_SUBTRACTOR":                 "debug/macho",
+	"macho.X86_64_RELOC_TLV":                        "debug/macho",
+	"macho.X86_64_RELOC_UNSIGNED":                   "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.Erfcinv":                                  "math",
+	"math.Erfinv":                                   "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.Round":                                    "math",
+	"math.RoundToEven":                              "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.ErrNoDeadline":                              "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.IsTimeout":                                  "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.Shuffle":                    "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.OpenDB":                                           "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.Builder":                                      "strings",
+	"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.CreateProcessAsUser":                          "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.Format":                                           "archive/tar",
+	"tar.FormatGNU":                                        "archive/tar",
+	"tar.FormatPAX":                                        "archive/tar",
+	"tar.FormatUSTAR":                                      "archive/tar",
+	"tar.FormatUnknown":                                    "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.Srcset": "html/template",
+	// "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.LoadLocationFromTZData":                    "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.ECDSAWithSHA1":                              "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.Masaram_Gondi":                          "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.Nushu":                                  "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.Regional_Indicator":                     "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.Soyombo":                                "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.Zanabazar_Square":                       "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.CANotAuthorizedForExtKeyUsage":             "crypto/x509",
+	"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.ExtKeyUsageMicrosoftCommercialCodeSigning": "crypto/x509",
+	"x509.ExtKeyUsageMicrosoftKernelCodeSigning":     "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.MarshalPKCS1PublicKey":                     "crypto/x509",
+	"x509.MarshalPKCS8PrivateKey":                    "crypto/x509",
+	"x509.MarshalPKIXPublicKey":                      "crypto/x509",
+	"x509.NameConstraintsWithoutSANs":                "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.ParsePKCS1PublicKey":                       "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.TooManyConstraints":                        "crypto/x509",
+	"x509.TooManyIntermediates":                      "crypto/x509",
+	"x509.UnconstrainedName":                         "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.NewTokenDecoder":                            "encoding/xml",
+	"xml.ProcInst":                                   "encoding/xml",
+	"xml.StartElement":                               "encoding/xml",
+	"xml.SyntaxError":                                "encoding/xml",
+	"xml.TagPathError":                               "encoding/xml",
+	"xml.Token":                                      "encoding/xml",
+	"xml.TokenReader":                                "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/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go
new file mode 100644
index 00000000..5cc7df53
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go
@@ -0,0 +1,191 @@
+// 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.
+
+// Package fastwalk provides a faster version of filepath.Walk for file system
+// scanning tools.
+package fastwalk
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+// TraverseLink is used as a return value from WalkFuncs to indicate that the
+// symlink named in the call may be traversed.
+var TraverseLink = errors.New("fastwalk: traverse symlink, assuming target is a directory")
+
+// Walk is a faster implementation of filepath.Walk.
+//
+// filepath.Walk's design necessarily calls os.Lstat on each file,
+// even if the caller needs less info.
+// Many tools need only the type of each file.
+// On some platforms, this information is provided directly by the readdir
+// system call, avoiding the need to stat each file individually.
+// fastwalk_unix.go contains a fork of the syscall routines.
+//
+// See golang.org/issue/16399
+//
+// Walk 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 Walk(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/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go
new file mode 100644
index 00000000..ccffec5a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/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 fastwalk
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Fileno)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go
new file mode 100644
index 00000000..ab7fbc0a
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/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 fastwalk
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Ino)
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go
new file mode 100644
index 00000000..e8ea50d6
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go
@@ -0,0 +1,29 @@
+// 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 appengine !linux,!darwin,!freebsd,!openbsd,!netbsd
+
+package fastwalk
+
+import (
+	"io/ioutil"
+	"os"
+)
+
+// readDir calls fn for each directory entry in dirName.
+// It does not descend into directories or follow symlinks.
+// If fn returns a non-nil error, readDir returns with that error
+// immediately.
+func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
+	fis, err := ioutil.ReadDir(dirName)
+	if err != nil {
+		return err
+	}
+	for _, fi := range fis {
+		if err := fn(dirName, fi.Name(), fi.Mode()&os.ModeType); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go
new file mode 100644
index 00000000..67db6caf
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/internal/fastwalk/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 fastwalk
+
+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 &os.PathError{Op: "open", Path: dirName, Err: 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/src/margo.sh/vendor/golang.org/x/tools/refactor/importgraph/graph.go b/src/margo.sh/vendor/golang.org/x/tools/refactor/importgraph/graph.go
new file mode 100644
index 00000000..d2d8f098
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/refactor/importgraph/graph.go
@@ -0,0 +1,167 @@
+// 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.
+
+// Package importgraph computes the forward and reverse import
+// dependency graphs for all packages in a Go workspace.
+package importgraph // import "golang.org/x/tools/refactor/importgraph"
+
+import (
+	"go/build"
+	"sync"
+
+	"golang.org/x/tools/go/buildutil"
+)
+
+// A Graph is an import dependency graph, either forward or reverse.
+//
+// The graph maps each node (a package import path) to the set of its
+// successors in the graph.  For a forward graph, this is the set of
+// imported packages (prerequisites); for a reverse graph, it is the set
+// of importing packages (clients).
+//
+// Graph construction inspects all imports in each package's directory,
+// including those in _test.go files, so the resulting graph may be cyclic.
+type Graph map[string]map[string]bool
+
+func (g Graph) addEdge(from, to string) {
+	edges := g[from]
+	if edges == nil {
+		edges = make(map[string]bool)
+		g[from] = edges
+	}
+	edges[to] = true
+}
+
+// Search returns all the nodes of the graph reachable from
+// any of the specified roots, by following edges forwards.
+// Relationally, this is the reflexive transitive closure.
+func (g Graph) Search(roots ...string) map[string]bool {
+	seen := make(map[string]bool)
+	var visit func(x string)
+	visit = func(x string) {
+		if !seen[x] {
+			seen[x] = true
+			for y := range g[x] {
+				visit(y)
+			}
+		}
+	}
+	for _, root := range roots {
+		visit(root)
+	}
+	return seen
+}
+
+// Build scans the specified Go workspace and builds the forward and
+// reverse import dependency graphs for all its packages.
+// It also returns a mapping from canonical import paths to errors for packages
+// whose loading was not entirely successful.
+// A package may appear in the graph and in the errors mapping.
+// All package paths are canonical and may contain "/vendor/".
+func Build(ctxt *build.Context) (forward, reverse Graph, errors map[string]error) {
+	type importEdge struct {
+		from, to string
+	}
+	type pathError struct {
+		path string
+		err  error
+	}
+
+	ch := make(chan interface{})
+
+	go func() {
+		sema := make(chan int, 20) // I/O concurrency limiting semaphore
+		var wg sync.WaitGroup
+		buildutil.ForEachPackage(ctxt, func(path string, err error) {
+			if err != nil {
+				ch <- pathError{path, err}
+				return
+			}
+
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+
+				sema <- 1
+				bp, err := ctxt.Import(path, "", 0)
+				<-sema
+
+				if err != nil {
+					if _, ok := err.(*build.NoGoError); ok {
+						// empty directory is not an error
+					} else {
+						ch <- pathError{path, err}
+					}
+					// Even in error cases, Import usually returns a package.
+				}
+
+				// absolutize resolves an import path relative
+				// to the current package bp.
+				// The absolute form may contain "vendor".
+				//
+				// The vendoring feature slows down Build by 3×.
+				// Here are timings from a 1400 package workspace:
+				//    1100ms: current code (with vendor check)
+				//     880ms: with a nonblocking cache around ctxt.IsDir
+				//     840ms: nonblocking cache with duplicate suppression
+				//     340ms: original code (no vendor check)
+				// TODO(adonovan): optimize, somehow.
+				memo := make(map[string]string)
+				absolutize := func(path string) string {
+					canon, ok := memo[path]
+					if !ok {
+						sema <- 1
+						bp2, _ := ctxt.Import(path, bp.Dir, build.FindOnly)
+						<-sema
+
+						if bp2 != nil {
+							canon = bp2.ImportPath
+						} else {
+							canon = path
+						}
+						memo[path] = canon
+					}
+					return canon
+				}
+
+				if bp != nil {
+					for _, imp := range bp.Imports {
+						ch <- importEdge{path, absolutize(imp)}
+					}
+					for _, imp := range bp.TestImports {
+						ch <- importEdge{path, absolutize(imp)}
+					}
+					for _, imp := range bp.XTestImports {
+						ch <- importEdge{path, absolutize(imp)}
+					}
+				}
+
+			}()
+		})
+		wg.Wait()
+		close(ch)
+	}()
+
+	forward = make(Graph)
+	reverse = make(Graph)
+
+	for e := range ch {
+		switch e := e.(type) {
+		case pathError:
+			if errors == nil {
+				errors = make(map[string]error)
+			}
+			errors[e.path] = e.err
+
+		case importEdge:
+			if e.to == "C" {
+				continue // "C" is fake
+			}
+			forward.addEdge(e.from, e.to)
+			reverse.addEdge(e.to, e.from)
+		}
+	}
+
+	return forward, reverse, errors
+}
diff --git a/src/margo.sh/vendor/golang.org/x/tools/third_party/moduleloader/LICENSE b/src/margo.sh/vendor/golang.org/x/tools/third_party/moduleloader/LICENSE
new file mode 100644
index 00000000..1723a224
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/third_party/moduleloader/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2013-2016 Guy Bedford, Luke Hoban, Addy Osmani
+
+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/src/margo.sh/vendor/golang.org/x/tools/third_party/typescript/LICENSE b/src/margo.sh/vendor/golang.org/x/tools/third_party/typescript/LICENSE
new file mode 100644
index 00000000..e7259f84
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/third_party/typescript/LICENSE
@@ -0,0 +1,55 @@
+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:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+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
+
+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
\ No newline at end of file
diff --git a/src/margo.sh/vendor/golang.org/x/tools/third_party/webcomponents/LICENSE b/src/margo.sh/vendor/golang.org/x/tools/third_party/webcomponents/LICENSE
new file mode 100644
index 00000000..e648283b
--- /dev/null
+++ b/src/margo.sh/vendor/golang.org/x/tools/third_party/webcomponents/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2015 The Polymer 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.
\ No newline at end of file